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 remote mux handoff and layout recovery
RoversX0ed576b15efb
diff --git a/Cargo.lock b/Cargo.lockindex 7f6f8304..7b93d836 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -8097,6 +8097,7 @@ dependencies = ["promise","rangeset","rcgen",+ "serde","serde_json","smol","tempfile",diff --git a/codec/src/lib.rs b/codec/src/lib.rsindex aef4d4ee..4a870122 100644--- a/codec/src/lib.rs+++ b/codec/src/lib.rs@@ -459,7 +459,9 @@ macro_rules! pdu {/// 54: Server-authoritative ThinkTerm Thread landing and materialization./// 55: Panes report alternate screen state so renderers can route the wheel./// 56: Pane entries carry that state too, so a renderer knows it on arrival.-pub const CODEC_VERSION: usize = 57;+/// 57: Frontends publish and follow a shared per-tab scroll position.+/// 58: Connection-wide A/B access modes and atomic geometry-bearing claims.+pub const CODEC_VERSION: usize = 58;// Defines the Pdu enum.// Each struct has an explicit identifying number.@@ -535,6 +537,8 @@ pdu! {EnsureThinkTermThread: 75,EnsureThinkTermThreadResponse: 76,SetClientView: 77,+ SetFrontendAccessMode: 78,+ FrontendAccessState: 79,}impl Pdu {@@ -1049,12 +1053,46 @@ pub struct SetClientViewport {pub viewport: ClientViewport,}-/// Claim a tab's viewport after a real renderer interaction. The server uses-/// the viewport previously advertised by this registered client; this request-/// carries no geometry or owner identity for the server to trust.+/// Claim access after a real terminal-area interaction and install the exact+/// geometry used for that interaction as one atomic server operation.+///+/// In shared mode this moves only `tab_id`'s layout lease. In handoff mode it+/// moves the connection-wide visibility/input lease. The registered transport+/// supplies the identity; no owner identity is accepted from the wire.#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]pub struct ClaimClientViewport {pub tab_id: TabId,+ pub viewport: ClientViewport,+}++/// A is the tmux-like mode: every renderer may see and interact, while the+/// last terminal-area interaction on each tab chooses its canonical grid.+/// B is an exclusive handoff: only one renderer may see or interact with any+/// tab on this mux connection.+#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone, Copy, Default)]+pub enum FrontendAccessMode {+ TmuxLatest,+ #[default]+ Handoff,+}++/// Runtime connection-wide visibility/input ownership. The selected mode is+/// persisted by the server; owner and generation deliberately are not.+#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]+pub struct FrontendAccessState {+ pub mode: FrontendAccessMode,+ pub owner: Option<ClientId>,+ pub generation: u64,+}++/// Change the server-wide mode. Supplying the active tab and its current+/// geometry lets the authorization check and resulting ownership/layout change+/// happen without an observable intermediate state.+#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]+pub struct SetFrontendAccessMode {+ pub mode: FrontendAccessMode,+ pub tab_id: TabId,+ pub viewport: ClientViewport,}/// Authoritative viewport state returned by `SetClientViewport` and pushed@@ -1062,12 +1100,16 @@ pub struct ClaimClientViewport {#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]pub struct ClientViewportState {pub tab_id: TabId,+ /// Per-tab layout owner used by `TmuxLatest` mode.pub owner: Option<ClientId>,pub canonical_size: TerminalSize,/// What the owner is looking at, when the owner is a renderer that says./// `None` means nobody offered one, and a follower keeps its own view.pub view: Option<ClientView>,pub generation: u64,+ /// A same-response snapshot of the connection-wide access state. This is+ /// what makes a handoff claim atomic from a renderer's point of view.+ pub access: FrontendAccessState,}/// What the renderer holding a tab's viewport is currently looking at.@@ -1585,8 +1627,8 @@ mod test {}#[test]- fn thinkterm_session_viewport_and_landing_protocol_round_trip_at_version_56() {- assert_eq!(CODEC_VERSION, 57);+ fn thinkterm_session_viewport_and_landing_protocol_round_trip_at_version_58() {+ assert_eq!(CODEC_VERSION, 58);let size = TerminalSize {rows: 40,cols: 132,@@ -1610,7 +1652,10 @@ mod test {});- let claim = ClaimClientViewport { tab_id: 17 };+ let claim = ClaimClientViewport {+ tab_id: 17,+ viewport: ClientViewport::CellGrid { size },+ };let mut encoded = Vec::new();Pdu::ClaimClientViewport(claim.clone()).encode(&mut encoded, 0x53)@@ -1623,6 +1668,40 @@ mod test {});+ let mode = SetFrontendAccessMode {+ mode: FrontendAccessMode::TmuxLatest,+ tab_id: 17,+ viewport: ClientViewport::CellGrid { size },+ };+ encoded.clear();+ Pdu::SetFrontendAccessMode(mode.clone())+ .encode(&mut encoded, 0x54)+ .unwrap();+ assert_eq!(+ Pdu::decode(encoded.as_slice()).unwrap(),+ DecodedPdu {+ serial: 0x54,+ pdu: Pdu::SetFrontendAccessMode(mode),+ }+ );++ let access = FrontendAccessState {+ mode: FrontendAccessMode::Handoff,+ owner: None,+ generation: 27,+ };+ encoded.clear();+ Pdu::FrontendAccessState(access.clone())+ .encode(&mut encoded, 0x55)+ .unwrap();+ assert_eq!(+ Pdu::decode(encoded.as_slice()).unwrap(),+ DecodedPdu {+ serial: 0x55,+ pdu: Pdu::FrontendAccessState(access),+ }+ );+let session = ThinkTermSessionState {server_id: "server-runtime-id".into(),tree_revision: 9,diff --git a/config/src/config.rs b/config/src/config.rsindex bc8a9c8d..16381a84 100644--- a/config/src/config.rs+++ b/config/src/config.rs@@ -1099,7 +1099,7 @@ impl Config {file_name: Some(path_item.path.clone()),lua: None,warnings: vec![],- }+ };}Ok(None) => continue,Ok(Some(loaded)) => return loaded,@@ -2001,6 +2001,11 @@ fn default_unicode_version() -> u8 {fn default_mux_env_remove() -> Vec<String> {vec![+ // The remote proxy is intentionally launched without a tty. Shell+ // startup files sometimes translate that into NO_COLOR=1, which then+ // leaks through the long-lived mux daemon into real PTY panes. Color+ // policy belongs to the pane/session, not to the transport process.+ "NO_COLOR".to_string(),"SSH_AUTH_SOCK".to_string(),"SSH_CLIENT".to_string(),"SSH_CONNECTION".to_string(),@@ -2410,8 +2415,8 @@ fn default_colr_rasterizer() -> FontRasterizerSelection {#[cfg(test)]mod tests {use super::{- active_thinkterm_config_candidates, copy_legacy_data_item, migrate_legacy_data_dir, Config,- HOME_DIR, LEGACY_PRODUCT_DIR_NAME, PRODUCT_DIR_NAME,+ active_thinkterm_config_candidates, copy_legacy_data_item, default_mux_env_remove,+ migrate_legacy_data_dir, Config, HOME_DIR, LEGACY_PRODUCT_DIR_NAME, PRODUCT_DIR_NAME,};use std::sync::Mutex;@@ -2592,6 +2597,13 @@ return config);}+ #[test]+ fn mux_does_not_inherit_proxy_color_policy() {+ assert!(default_mux_env_remove()+ .iter()+ .any(|name| name == "NO_COLOR"));+ }+#[test]fn legacy_data_migration_only_copies_durable_items() {let dir = tempfile::tempdir().unwrap();diff --git a/mux/src/client.rs b/mux/src/client.rsindex 581a50a4..4c35be9b 100644--- a/mux/src/client.rs+++ b/mux/src/client.rs@@ -37,6 +37,36 @@ impl ClientId {ssh_auth_sock: crate::AgentProxy::default_ssh_auth_sock(),}}++ /// Whether two ids describe the same logical client, allowing for the+ /// transport-only decoration applied by an SSH mux proxy.+ ///+ /// The server appends ` (via proxy pid N)` to the hostname and replaces+ /// `ssh_auth_sock` so that `list-clients` can explain the route. Neither+ /// change should make the originating renderer stop recognizing itself.+ pub fn same_logical_client(&self, other: &Self) -> bool {+ proxy_hostname_base(&self.hostname) == proxy_hostname_base(&other.hostname)+ && self.username == other.username+ && self.pid == other.pid+ && self.epoch == other.epoch+ && self.id == other.id+ }+}++fn proxy_hostname_base(hostname: &str) -> &str {+ const PREFIX: &str = " (via proxy pid ";++ let Some((base, suffix)) = hostname.rsplit_once(PREFIX) else {+ return hostname;+ };+ let Some(pid) = suffix.strip_suffix(')') else {+ return hostname;+ };+ if !pid.is_empty() && pid.bytes().all(|byte| byte.is_ascii_digit()) {+ base+ } else {+ hostname+ }}#[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]@@ -82,3 +112,48 @@ fn utc_now() -> DateTime<Utc> {DateTime::<Utc>::from_timestamp(duration.as_secs() as i64, duration.subsec_nanos()).expect("system time should fit chrono timestamp range")}++#[cfg(test)]+mod tests {+ use super::*;++ fn client_id(hostname: &str, id: usize, ssh_auth_sock: Option<&str>) -> ClientId {+ ClientId {+ hostname: hostname.to_string(),+ username: "test-user".to_string(),+ pid: 42,+ epoch: 123,+ id,+ ssh_auth_sock: ssh_auth_sock.map(str::to_string),+ }+ }++ #[test]+ fn proxied_identity_matches_its_originating_client() {+ let local = client_id("myhost.local", 7, Some("/local/agent"));+ let proxied = client_id(+ "myhost.local (via proxy pid 190892)",+ 7,+ Some("/remote/agent"),+ );++ assert!(local.same_logical_client(&proxied));+ assert!(proxied.same_logical_client(&local));+ }++ #[test]+ fn proxy_decoration_does_not_merge_distinct_clients() {+ let local = client_id("myhost.local", 7, None);+ let other = client_id("myhost.local (via proxy pid 190892)", 8, None);++ assert!(!local.same_logical_client(&other));+ }++ #[test]+ fn malformed_proxy_decoration_is_part_of_the_hostname() {+ let local = client_id("myhost.local", 7, None);+ let malformed = client_id("myhost.local (via proxy pid unknown)", 7, None);++ assert!(!local.same_logical_client(&malformed));+ }+}diff --git a/mux/src/lib.rs b/mux/src/lib.rsindex c4bceb5b..4e057cfd 100644--- a/mux/src/lib.rs+++ b/mux/src/lib.rs@@ -108,6 +108,8 @@ pub enum MuxNotification {/// The renderer allowed to drive one tab's shared PTY geometry changed,/// or that owner published a new canonical viewport.FrontendLeaseChanged(FrontendViewportState),+ /// The connection-wide A/B mode or the exclusive handoff owner changed.+ FrontendAccessChanged(FrontendAccessState),}static SUB_ID: AtomicUsize = AtomicUsize::new(0);@@ -195,6 +197,7 @@ pub struct FrontendView {#[derive(Clone, Debug, PartialEq, Eq)]pub struct FrontendViewportState {pub tab_id: TabId,+ /// Per-tab layout owner used by `TmuxLatest` mode.pub owner: Option<ClientId>,pub canonical_size: wezterm_term::TerminalSize,/// What the owner is looking at, when the owner is a renderer that says.@@ -202,11 +205,29 @@ pub struct FrontendViewportState {/// rather than being pulled somewhere arbitrary.pub view: Option<FrontendView>,pub generation: u64,+ pub access: FrontendAccessState,+}++#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum FrontendAccessMode {+ TmuxLatest,+ #[default]+ Handoff,+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct FrontendAccessState {+ pub mode: FrontendAccessMode,+ pub owner: Option<ClientId>,+ pub generation: u64,}#[derive(Default)]struct TabFrontendLease {owner: Option<ClientId>,+ /// Last geometry advertised by each renderer. Network claims always carry+ /// their geometry and never trust this cache; it remains useful for the+ /// in-process GUI, whose Pane input reaches the mux without a wire PDU.viewports: HashMap<ClientId, FrontendViewport>,/// Written by the owner alone, and dropped the moment the lease moves, so/// it can never describe a renderer that is no longer driving.@@ -216,6 +237,13 @@ struct TabFrontendLease {struct FrontendLeaseState {tabs: HashMap<TabId, TabFrontendLease>,+ access_mode: FrontendAccessMode,+ handoff_owner: Option<ClientId>,+ /// Distinguishes initial server startup (first renderer auto-owns) from an+ /// owner disconnect (everyone stays blocked until an explicit takeover).+ handoff_ever_owned: bool,+ access_initialized: bool,+ access_generation: u64,next_generation: u64,}@@ -223,6 +251,11 @@ impl Default for FrontendLeaseState {fn default() -> Self {Self {tabs: HashMap::new(),+ access_mode: FrontendAccessMode::Handoff,+ handoff_owner: None,+ handoff_ever_owned: false,+ access_initialized: false,+ access_generation: 0,next_generation: 1,}}@@ -340,6 +373,9 @@ pub struct Mux {clients: RwLock<HashMap<ClientId, ClientInfo>>,client_registrations: RwLock<HashMap<ClientId, ClientRegistrationId>>,frontend_lease: Mutex<FrontendLeaseState>,+ tab_resize_notifications: Mutex<TabResizeNotificationState>,+ #[cfg(test)]+ frontend_geometry_failures: Mutex<std::collections::VecDeque<bool>>,palette_advisories: Mutex<PaletteAdvisoryState>,identity: RwLock<Option<Arc<ClientId>>>,num_panes_by_workspace: RwLock<HashMap<String, usize>>,@@ -347,6 +383,73 @@ pub struct Mux {agent: Option<AgentProxy>,}+#[derive(Default)]+struct TabResizeNotificationState {+ depth: HashMap<TabId, usize>,+ pending: HashSet<TabId>,+ aborted: HashSet<TabId>,+}++impl TabResizeNotificationState {+ fn begin(&mut self, tab_id: TabId) {+ if self.depth.get(&tab_id).copied().unwrap_or_default() == 0 {+ self.aborted.remove(&tab_id);+ }+ *self.depth.entry(tab_id).or_default() += 1;+ }++ fn defer(&mut self, tab_id: TabId) -> bool {+ if self.depth.get(&tab_id).copied().unwrap_or_default() == 0 {+ return false;+ }+ self.pending.insert(tab_id);+ true+ }++ fn finish(&mut self, tab_id: TabId, commit: bool) -> bool {+ if !commit {+ self.aborted.insert(tab_id);+ }+ let Some(depth) = self.depth.get_mut(&tab_id) else {+ return false;+ };+ *depth -= 1;+ if *depth != 0 {+ return false;+ }+ self.depth.remove(&tab_id);+ let pending = self.pending.remove(&tab_id);+ let aborted = self.aborted.remove(&tab_id);+ commit && !aborted && pending+ }+}++struct TabGeometryTransaction<'a> {+ mux: &'a Mux,+ tab_id: TabId,+ commit: bool,+}++impl TabGeometryTransaction<'_> {+ fn commit(&mut self) {+ self.commit = true;+ }+}++impl Drop for TabGeometryTransaction<'_> {+ fn drop(&mut self) {+ let publish = self+ .mux+ .tab_resize_notifications+ .lock()+ .finish(self.tab_id, self.commit);+ if publish {+ self.mux+ .notify_immediate(MuxNotification::TabResized(self.tab_id));+ }+ }+}+const BUFSIZE: usize = 1024 * 1024;/// This function applies parsed actions to the pane and notifies any@@ -684,6 +787,9 @@ impl Mux {clients: RwLock::new(HashMap::new()),client_registrations: RwLock::new(HashMap::new()),frontend_lease: Mutex::new(FrontendLeaseState::default()),+ tab_resize_notifications: Mutex::new(TabResizeNotificationState::default()),+ #[cfg(test)]+ frontend_geometry_failures: Mutex::new(std::collections::VecDeque::new()),palette_advisories: Mutex::new(PaletteAdvisoryState::default()),identity: RwLock::new(None),num_panes_by_workspace: RwLock::new(HashMap::new()),@@ -780,6 +886,60 @@ impl Mux {Ok(())}+ fn access_state_locked(lease: &FrontendLeaseState) -> FrontendAccessState {+ FrontendAccessState {+ mode: lease.access_mode,+ owner: match lease.access_mode {+ FrontendAccessMode::TmuxLatest => None,+ FrontendAccessMode::Handoff => lease.handoff_owner.clone(),+ },+ generation: lease.access_generation,+ }+ }++ pub fn frontend_access_state(&self) -> FrontendAccessState {+ Self::access_state_locked(&self.frontend_lease.lock())+ }++ /// Install the mode loaded by the mux-server persistence layer. This is+ /// intentionally one-shot so a configuration reload cannot overwrite a+ /// mode selected while this server process is running.+ pub fn initialize_frontend_access_mode(&self, mode: FrontendAccessMode) {+ let mut lease = self.frontend_lease.lock();+ if lease.access_initialized {+ return;+ }+ lease.access_mode = mode;+ lease.access_initialized = true;+ }++ pub fn frontend_access_mode_is_initialized(&self) -> bool {+ self.frontend_lease.lock().access_initialized+ }++ pub fn client_has_frontend_access(&self, client_id: &ClientId) -> bool {+ let lease = self.frontend_lease.lock();+ match lease.access_mode {+ FrontendAccessMode::TmuxLatest => true,+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),+ }+ }++ /// Check the server-wide interaction gate for one live transport. This+ /// does not claim anything: chrome actions such as closing a pane must be+ /// rejected for B's opaque followers, but must not silently take A's+ /// layout lease just because they originated outside the terminal area.+ pub fn registered_client_has_frontend_access(+ &self,+ client_id: &ClientId,+ registration: ClientRegistrationId,+ ) -> Option<bool> {+ if self.client_registrations.read().get(client_id) != Some(®istration) {+ return None;+ }+ Some(self.client_has_frontend_access(client_id))+ }+fn viewport_state(&self, tab_id: TabId) -> Option<FrontendViewportState> {let tab = self.get_tab(tab_id)?;let lease = self.frontend_lease.lock();@@ -790,6 +950,7 @@ impl Mux {canonical_size: tab.get_size(),view: state.view.clone(),generation: state.generation,+ access: Self::access_state_locked(&lease),})}@@ -802,12 +963,22 @@ impl Mux {pub fn set_client_view(&self, client_id: &ClientId, tab_id: TabId, view: FrontendView) -> bool {let changed = {let mut lease = self.frontend_lease.lock();- let Some(state) = lease.tabs.get_mut(&tab_id) else {- return false;+ let may_publish = match lease.access_mode {+ FrontendAccessMode::TmuxLatest => {+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.owner.as_ref())+ == Some(client_id)+ }+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),};- if state.owner.as_ref() != Some(client_id) {+ if !may_publish {return false;}+ let Some(state) = lease.tabs.get_mut(&tab_id) else {+ return false;+ };if state.view.as_ref() == Some(&view) {false} else {@@ -822,8 +993,9 @@ impl Mux {}/// Record one renderer's desired viewport for one tab. A passive resize- /// never steals ownership. The first renderer establishes an owner; an- /// existing owner applies its changed viewport immediately.+ /// never steals an established owner. The first renderer after server+ /// startup seeds B's global handoff owner; after that owner disconnects,+ /// passive reports remain blocked until an explicit claim.pub fn set_client_viewport(&self,client_id: &ClientId,@@ -831,23 +1003,48 @@ impl Mux {viewport: FrontendViewport,) -> anyhow::Result<FrontendViewportState> {self.validate_frontend_viewport(tab_id, &viewport)?;- let (should_apply, should_publish) = {+ let (should_apply, should_publish, access_changed) = {let mut lease = self.frontend_lease.lock();+ let mut access_changed = false;+ if lease.access_mode == FrontendAccessMode::Handoff+ && lease.handoff_owner.is_none()+ && !lease.handoff_ever_owned+ {+ lease.handoff_owner = Some(client_id.clone());+ lease.handoff_ever_owned = true;+ access_changed = true;+ }+ let mode = lease.access_mode;+ let handoff_owner = lease.handoff_owner.clone();let state = lease.tabs.entry(tab_id).or_default();let viewport_changed = state.viewports.get(client_id) != Some(&viewport);if viewport_changed {state.viewports.insert(client_id.clone(), viewport.clone());}- let owner_changed = state.owner.is_none();+ let can_drive = match mode {+ FrontendAccessMode::TmuxLatest => {+ if state.owner.is_none() {+ state.owner = Some(client_id.clone());+ }+ state.owner.as_ref() == Some(client_id)+ }+ FrontendAccessMode::Handoff => handoff_owner.as_ref() == Some(client_id),+ };+ let owner_changed = can_drive && state.owner.as_ref() != Some(client_id);if owner_changed {state.owner = Some(client_id.clone());+ state.view = None;}- let should_apply =- state.owner.as_ref() == Some(client_id) && (owner_changed || viewport_changed);- (should_apply, should_apply)+ let should_apply = can_drive && (owner_changed || viewport_changed || access_changed);+ (should_apply, should_apply, access_changed)};if should_apply {- self.apply_frontend_viewport(tab_id, &viewport)?;+ if let Err(err) = self.apply_frontend_viewport(tab_id, &viewport) {+ return Err(self.fail_closed_frontend_geometry(tab_id, None, err));+ }+ }+ if access_changed {+ self.publish_frontend_access_state();}if should_publish {self.publish_frontend_viewport_state(tab_id);@@ -876,30 +1073,40 @@ impl Mux {}pub fn client_owns_frontend_lease(&self, client_id: &ClientId, tab_id: TabId) -> bool {- self.frontend_lease- .lock()- .tabs- .get(&tab_id)- .and_then(|state| state.owner.as_ref())- == Some(client_id)+ let lease = self.frontend_lease.lock();+ match lease.access_mode {+ FrontendAccessMode::TmuxLatest => {+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.owner.as_ref())+ == Some(client_id)+ }+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),+ }}pub fn current_identity_owns_frontend_lease(&self, tab_id: TabId) -> bool {match self.active_identity() {Some(identity) => self.client_owns_frontend_lease(&identity, tab_id),- None => self- .frontend_lease- .lock()- .tabs- .get(&tab_id)- .and_then(|state| state.owner.as_ref())- .is_none(),+ None => {+ let lease = self.frontend_lease.lock();+ match lease.access_mode {+ FrontendAccessMode::Handoff => lease.handoff_owner.is_none(),+ FrontendAccessMode::TmuxLatest => lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.owner.as_ref())+ .is_none(),+ }+ }}}- /// Claim the viewport for a real user interaction. Clients without a- /// viewport (for example `thinkterm cli send-text`) update idle accounting- /// but cannot become geometry owners.+ /// Account for an input PDU and enforce B's global input gate. In A, input+ /// is allowed for every renderer and the most recently advertised local+ /// geometry is used as a compatibility fallback; interactive frontends use+ /// the explicit geometry-bearing claim before forwarding the input.pub fn registered_client_had_tab_input(&self,client_id: &ClientId,@@ -912,22 +1119,39 @@ impl Mux {}drop(registrations);self.client_had_input(client_id);-- if let Err(err) = self.claim_frontend_viewport(client_id, tab_id) {- log::error!("failed to apply claimed viewport for tab {tab_id}: {err:#}");+ let (mode, handoff_owner, viewport) = {+ let lease = self.frontend_lease.lock();+ (+ lease.access_mode,+ lease.handoff_owner.clone(),+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.viewports.get(client_id).cloned()),+ )+ };+ match mode {+ FrontendAccessMode::Handoff => handoff_owner.as_ref() == Some(client_id),+ FrontendAccessMode::TmuxLatest => {+ if let Some(viewport) = viewport {+ if let Err(err) = self.claim_frontend_viewport(client_id, tab_id, viewport) {+ log::error!("failed to apply claimed viewport for tab {tab_id}: {err:#}");+ }+ }+ true+ }}- true}- /// Explicit renderer claim used by UI-only interactions such as pane- /// resize. The transport must still be current and must already have- /// advertised a viewport; geometry is taken only from that server-held- /// advertisement.+ /// Explicit renderer claim used by terminal-area interaction and pane+ /// layout changes. Geometry is supplied in this request and applied in the+ /// same main-thread operation as the owner change.pub fn claim_registered_client_viewport(&self,client_id: &ClientId,registration: ClientRegistrationId,tab_id: TabId,+ viewport: FrontendViewport,) -> anyhow::Result<Option<FrontendViewportState>> {let registrations = self.client_registrations.read();if registrations.get(client_id) != Some(®istration) {@@ -935,8 +1159,7 @@ impl Mux {}drop(registrations);self.client_had_input(client_id);- self.claim_frontend_viewport(client_id, tab_id)?- .ok_or_else(|| anyhow!("client has not advertised a viewport for tab {tab_id}"))+ self.claim_frontend_viewport(client_id, tab_id, viewport).map(Some)}@@ -944,39 +1167,196 @@ impl Mux {&self,client_id: &ClientId,tab_id: TabId,- ) -> anyhow::Result<Option<FrontendViewportState>> {- let (viewport, already_owned) = {+ viewport: FrontendViewport,+ ) -> anyhow::Result<FrontendViewportState> {+ self.validate_frontend_viewport(tab_id, &viewport)?;+ let unchanged = {let lease = self.frontend_lease.lock();- let Some(state) = lease.tabs.get(&tab_id) else {- return Ok(None);- };- let Some(viewport) = state.viewports.get(client_id).cloned() else {- return Ok(None);+ let effective_owner = match lease.access_mode {+ FrontendAccessMode::TmuxLatest => {+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.owner.as_ref())+ == Some(client_id)+ }+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),};- (viewport, state.owner.as_ref() == Some(client_id))+ effective_owner+ && lease.tabs.get(&tab_id).is_some_and(|state| {+ state.owner.as_ref() == Some(client_id)+ && state.viewports.get(client_id) == Some(&viewport)+ })};- if already_owned {- return Ok(self.viewport_state(tab_id));+ if unchanged {+ return self+ .viewport_state(tab_id)+ .ok_or_else(|| anyhow!("viewport state for tab {tab_id} disappeared"));}-- self.apply_frontend_viewport(tab_id, &viewport)?;- {+ let (access_changed, mut affected_tabs) = {let mut lease = self.frontend_lease.lock();- let Some(state) = lease.tabs.get_mut(&tab_id) else {- return Ok(None);- };- if !state.viewports.contains_key(client_id) {- return Ok(None);+ let mode = lease.access_mode;+ let mut access_changed = false;+ let mut affected_tabs = vec![tab_id];+ if mode == FrontendAccessMode::Handoff {+ access_changed = lease.handoff_owner.as_ref() != Some(client_id);+ lease.handoff_owner = Some(client_id.clone());+ lease.handoff_ever_owned = true;+ if access_changed {+ for (affected_tab_id, state) in &mut lease.tabs {+ if state.view.take().is_some() && *affected_tab_id != tab_id {+ affected_tabs.push(*affected_tab_id);+ }+ }+ }}+ let state = lease.tabs.entry(tab_id).or_default();+ state.viewports.insert(client_id.clone(), viewport.clone());state.owner = Some(client_id.clone());- // The view belonged to whoever was driving. Carrying it across a- // handover would leave the new owner's followers pinned to a- // scrollback position nobody chose; the new owner publishes its own- // on its next frame.state.view = None;+ (access_changed, affected_tabs)+ };+ if access_changed {+ self.publish_frontend_access_state();+ }+ // Commit and publish B's new owner before Tab::resize can emit a+ // synchronous TabResized notification. Any observer reacting to the+ // new geometry must already mask the prior owner.+ if let Err(err) = self.apply_frontend_viewport(tab_id, &viewport) {+ return Err(self.fail_closed_frontend_geometry(tab_id, None, err));+ }+ affected_tabs.sort_unstable();+ affected_tabs.dedup();+ for affected_tab_id in affected_tabs {+ self.publish_frontend_viewport_state(affected_tab_id);+ }+ self.viewport_state(tab_id)+ .ok_or_else(|| anyhow!("viewport state for tab {tab_id} disappeared"))+ }++ /// In-process GUI equivalent of the wire claim. The GUI identity is+ /// already registered with this mux, but there is no transport generation+ /// involved because the call never crosses a connection.+ pub fn claim_local_frontend_viewport(+ &self,+ client_id: &ClientId,+ tab_id: TabId,+ viewport: FrontendViewport,+ ) -> anyhow::Result<FrontendViewportState> {+ self.client_had_input(client_id);+ self.claim_frontend_viewport(client_id, tab_id, viewport)+ }++ /// Validate a mode transition without mutating state. The server uses this+ /// before atomically persisting the selected mode.+ pub fn validate_registered_frontend_access_mode_change(+ &self,+ client_id: &ClientId,+ registration: ClientRegistrationId,+ mode: FrontendAccessMode,+ tab_id: TabId,+ viewport: &FrontendViewport,+ ) -> anyhow::Result<()> {+ if self.client_registrations.read().get(client_id) != Some(®istration) {+ anyhow::bail!("client connection was superseded");+ }+ self.validate_frontend_access_mode_change(client_id, mode, tab_id, viewport)+ }++ pub fn validate_frontend_access_mode_change(+ &self,+ client_id: &ClientId,+ mode: FrontendAccessMode,+ tab_id: TabId,+ viewport: &FrontendViewport,+ ) -> anyhow::Result<()> {+ self.validate_frontend_viewport(tab_id, viewport)?;+ let lease = self.frontend_lease.lock();+ if lease.access_mode == mode {+ return Ok(());+ }+ let authorized = match lease.access_mode {+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),+ FrontendAccessMode::TmuxLatest => {+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.owner.as_ref())+ == Some(client_id)+ }+ };+ if !authorized {+ anyhow::bail!("only the current frontend owner may change access mode");+ }+ Ok(())+ }++ /// Commit a previously validated mode transition. The caller runs this on+ /// the mux main thread after persistence succeeds.+ pub fn set_registered_frontend_access_mode(+ &self,+ client_id: &ClientId,+ registration: ClientRegistrationId,+ mode: FrontendAccessMode,+ tab_id: TabId,+ viewport: FrontendViewport,+ ) -> anyhow::Result<FrontendAccessState> {+ if self.client_registrations.read().get(client_id) != Some(®istration) {+ anyhow::bail!("client connection was superseded");+ }+ self.set_frontend_access_mode(client_id, mode, tab_id, viewport)+ }++ pub fn set_frontend_access_mode(+ &self,+ client_id: &ClientId,+ mode: FrontendAccessMode,+ tab_id: TabId,+ viewport: FrontendViewport,+ ) -> anyhow::Result<FrontendAccessState> {+ self.validate_frontend_access_mode_change(client_id, mode, tab_id, &viewport)?;+ let prior_access = self.frontend_access_state();+ if prior_access.mode == mode {+ return Ok(self.frontend_access_state());+ }++ let affected_tabs = {+ let mut lease = self.frontend_lease.lock();+ lease.access_mode = mode;+ lease.access_initialized = true;+ match mode {+ FrontendAccessMode::TmuxLatest => {+ lease.handoff_owner = None;+ }+ FrontendAccessMode::Handoff => {+ lease.handoff_owner = Some(client_id.clone());+ lease.handoff_ever_owned = true;+ }+ }+ let mut affected = Vec::new();+ for (affected_tab_id, state) in &mut lease.tabs {+ if state.view.take().is_some() || *affected_tab_id == tab_id {+ affected.push(*affected_tab_id);+ }+ }+ let state = lease.tabs.entry(tab_id).or_default();+ state.viewports.insert(client_id.clone(), viewport.clone());+ state.owner = Some(client_id.clone());+ if !affected.contains(&tab_id) {+ affected.push(tab_id);+ }+ affected+ };+ self.publish_frontend_access_state();+ // As with a direct claim, mode/owner is authoritative before resize+ // notifications expose geometry from the newly selected frontend.+ if let Err(err) = self.apply_frontend_viewport(tab_id, &viewport) {+ return Err(self.fail_closed_frontend_geometry(tab_id, Some(prior_access.mode), err));+ }+ for affected_tab_id in affected_tabs {+ self.publish_frontend_viewport_state(affected_tab_id);}- self.publish_frontend_viewport_state(tab_id);- Ok(self.viewport_state(tab_id))+ Ok(self.frontend_access_state())}/// `None` means the transport generation is stale. `Some(false)` means a@@ -991,14 +1371,28 @@ impl Mux {return None;}let lease = self.frontend_lease.lock();- Some(match lease.tabs.get(&tab_id) {- None => true,- Some(state) => state.owner.as_ref() == Some(client_id),+ Some(match lease.access_mode {+ FrontendAccessMode::Handoff => lease.handoff_owner.as_ref() == Some(client_id),+ FrontendAccessMode::TmuxLatest => match lease.tabs.get(&tab_id) {+ None => true,+ Some(state) => state.owner.as_ref() == Some(client_id),+ },})}+ fn publish_frontend_access_state(&self) {+ let state = {+ let mut lease = self.frontend_lease.lock();+ let generation = lease.next_generation;+ lease.next_generation = lease.next_generation.saturating_add(1);+ lease.access_generation = generation;+ Self::access_state_locked(&lease)+ };+ self.notify(MuxNotification::FrontendAccessChanged(state));+ }+fn publish_frontend_viewport_state(&self, tab_id: TabId) {- let (generation, owner, view) = {+ let (generation, owner, view, access) = {let mut lease = self.frontend_lease.lock();let generation = lease.next_generation;lease.next_generation = lease.next_generation.saturating_add(1);@@ -1006,7 +1400,10 @@ impl Mux {return;};state.generation = generation;- (generation, state.owner.clone(), state.view.clone())+ let owner = state.owner.clone();+ let view = state.view.clone();+ let access = Self::access_state_locked(&lease);+ (generation, owner, view, access)};let Some(tab) = self.get_tab(tab_id) else {return;@@ -1018,6 +1415,7 @@ impl Mux {canonical_size: tab.get_size(),view,generation,+ access,},));}@@ -1030,32 +1428,111 @@ impl Mux {let tab = self.get_tab(tab_id).ok_or_else(|| anyhow!("no such tab {tab_id}"))?;- let size = viewport.size();- tab.resize(size);-- if let FrontendViewport::Native { panes, .. } = viewport {- for pane_viewport in panes {- let pane = self- .get_pane(pane_viewport.pane_id)- .ok_or_else(|| anyhow!("no such pane {}", pane_viewport.pane_id))?;- if !tab.contains_pane(pane_viewport.pane_id) {- anyhow::bail!("pane {} is not in tab {tab_id}", pane_viewport.pane_id);+ let mut transaction = self.begin_tab_geometry_transaction(tab_id);+ let result = (|| {+ let size = viewport.size();+ self.frontend_geometry_step("resizing the tab root")?;+ tab.resize(size);++ if let FrontendViewport::Native { panes, .. } = viewport {+ for pane_viewport in panes {+ let pane = self+ .get_pane(pane_viewport.pane_id)+ .ok_or_else(|| anyhow!("no such pane {}", pane_viewport.pane_id))?;+ if !tab.contains_pane(pane_viewport.pane_id) {+ anyhow::bail!("pane {} is not in tab {tab_id}", pane_viewport.pane_id);+ }+ self.frontend_geometry_step("resizing a native pane")?;+ pane.resize(pane_viewport.size)?;+ }+ if !panes.is_empty() {+ tab.rebuild_splits_sizes_from_contained_panes();}- pane.resize(pane_viewport.size)?;+ return Ok(());}- if !panes.is_empty() {- tab.rebuild_splits_sizes_from_contained_panes();++ for positioned in tab.iter_panes() {+ let target = pane_size_for_cell_grid(size, positioned.width, positioned.height);+ self.frontend_geometry_step("resizing a cell-grid pane")?;+ positioned.pane.resize(target)?;}- return Ok(());+ Ok(())+ })();+ if result.is_ok() {+ transaction.commit();}+ result+ }- for positioned in tab.iter_panes() {- let target = pane_size_for_cell_grid(size, positioned.width, positioned.height);- positioned.pane.resize(target)?;+ #[cfg(test)]+ fn frontend_geometry_step(&self, what: &str) -> anyhow::Result<()> {+ if self+ .frontend_geometry_failures+ .lock()+ .pop_front()+ .unwrap_or(false)+ {+ anyhow::bail!("injected frontend geometry failure while {what}");}Ok(())}+ #[cfg(not(test))]+ fn frontend_geometry_step(&self, _what: &str) -> anyhow::Result<()> {+ Ok(())+ }++ fn fail_closed_frontend_geometry(+ &self,+ tab_id: TabId,+ restore_mode: Option<FrontendAccessMode>,+ apply_error: anyhow::Error,+ ) -> anyhow::Error {+ let (mode, mut affected_tabs) = {+ let mut lease = self.frontend_lease.lock();+ if let Some(mode) = restore_mode {+ lease.access_mode = mode;+ lease.access_initialized = true;+ }+ let mode = lease.access_mode;+ let mut affected = Vec::new();+ match mode {+ FrontendAccessMode::Handoff => {+ lease.handoff_owner = None;+ lease.handoff_ever_owned = true;+ for (affected_tab_id, state) in &mut lease.tabs {+ state.owner = None;+ state.view = None;+ affected.push(*affected_tab_id);+ }+ }+ FrontendAccessMode::TmuxLatest => {+ lease.handoff_owner = None;+ let state = lease.tabs.entry(tab_id).or_default();+ state.owner = None;+ state.view = None;+ affected.push(tab_id);+ }+ }+ if !lease.tabs.contains_key(&tab_id) {+ lease.tabs.entry(tab_id).or_default();+ affected.push(tab_id);+ }+ (mode, affected)+ };++ affected_tabs.sort_unstable();+ affected_tabs.dedup();+ self.publish_frontend_access_state();+ for affected_tab_id in affected_tabs {+ self.publish_frontend_viewport_state(affected_tab_id);+ }+ self.notify(MuxNotification::TabResized(tab_id));+ anyhow!(+ "applying frontend geometry for tab {tab_id} failed; the {mode:?} lease was revoked: {apply_error:#}"+ )+ }+pub fn record_input_for_current_identity(&self) {let Some(ident) = self.active_identity() else {return;@@ -1064,8 +1541,20 @@ impl Mux {let Some((_domain, _window, tab_id, _pane)) = self.resolve_focused_pane(&ident) else {return;};- if let Err(err) = self.claim_frontend_viewport(&ident, tab_id) {- log::error!("failed to claim local frontend viewport for tab {tab_id}: {err:#}");+ let viewport = {+ let lease = self.frontend_lease.lock();+ if lease.access_mode != FrontendAccessMode::TmuxLatest {+ return;+ }+ lease+ .tabs+ .get(&tab_id)+ .and_then(|state| state.viewports.get(ident.as_ref()).cloned())+ };+ if let Some(viewport) = viewport {+ if let Err(err) = self.claim_frontend_viewport(&ident, tab_id, viewport) {+ log::error!("failed to claim local frontend viewport for tab {tab_id}: {err:#}");+ }}}@@ -1279,8 +1768,7 @@ impl Mux {self.clients.write().remove(client_id);registrations.remove(client_id);}- let clients = self.clients.read();- let affected = {+ let (affected, access_changed) = {let mut lease = self.frontend_lease.lock();let mut affected = Vec::new();for (tab_id, state) in &mut lease.tabs {@@ -1288,28 +1776,26 @@ impl Mux {if state.owner.as_ref() != Some(client_id) {continue;}- let replacement = clients- .values()- .filter(|info| state.viewports.contains_key(info.client_id.as_ref()))- .max_by_key(|info| info.last_input)- .map(|info| (*info.client_id).clone());- state.owner = replacement.clone();+ state.owner = None;state.view = None;- let viewport = replacement- .as_ref()- .and_then(|replacement| state.viewports.get(replacement).cloned());- affected.push((*tab_id, viewport));+ affected.push(*tab_id);}- affected+ let access_changed = lease.access_mode == FrontendAccessMode::Handoff+ && lease.handoff_owner.as_ref() == Some(client_id);+ if access_changed {+ // Do not select a surviving renderer automatically. Every+ // remaining device stays opaque until one explicitly clicks,+ // wheels or swipes the takeover surface.+ lease.handoff_owner = None;+ lease.handoff_ever_owned = true;+ }+ (affected, access_changed)};- drop(clients);- for (tab_id, viewport) in affected {- if let Some(viewport) = viewport {- if let Err(err) = self.apply_frontend_viewport(tab_id, &viewport) {- log::error!("failed to apply fallback viewport for tab {tab_id}: {err:#}");- }- }+ if access_changed {+ self.publish_frontend_access_state();+ }+ for tab_id in affected {self.publish_frontend_viewport_state(tab_id);}}@@ -1374,10 +1860,31 @@ impl Mux {}pub fn notify(&self, notification: MuxNotification) {+ match notification {+ MuxNotification::TabResized(tab_id) => {+ if self.tab_resize_notifications.lock().defer(tab_id) {+ return;+ }+ self.notify_immediate(MuxNotification::TabResized(tab_id));+ }+ other => self.notify_immediate(other),+ }+ }++ fn notify_immediate(&self, notification: MuxNotification) {let mut subscribers = self.subscribers.write();subscribers.retain(|_, notify| notify(notification.clone()));}+ fn begin_tab_geometry_transaction(&self, tab_id: TabId) -> TabGeometryTransaction<'_> {+ self.tab_resize_notifications.lock().begin(tab_id);+ TabGeometryTransaction {+ mux: self,+ tab_id,+ commit: false,+ }+ }+pub fn notify_from_any_thread(notification: MuxNotification) {if let Some(mux) = Mux::try_get() {if mux.is_main_thread() {@@ -2436,6 +2943,57 @@ impl wezterm_term::DownloadHandler for MuxDownloader {mod tests {use super::*;+ #[test]+ fn tab_geometry_transaction_coalesces_and_is_tab_scoped() {+ let mut state = TabResizeNotificationState::default();+ state.begin(10);+ state.begin(10);+ state.begin(11);++ assert!(state.defer(10));+ assert!(state.defer(10));+ assert!(state.defer(11));+ assert!(!state.finish(10, true), "nested scope is still open");+ assert!(state.finish(10, true), "tab 10 publishes exactly once");+ assert!(state.finish(11, true), "tab 11 is independent");+ assert!(!state.defer(10), "completed tabs are no longer deferred");+ }++ #[test]+ fn failed_tab_geometry_transaction_discards_partial_notification() {+ let mut state = TabResizeNotificationState::default();+ state.begin(12);+ state.begin(12);+ assert!(state.defer(12));+ assert!(!state.finish(12, false));+ assert!(!state.finish(12, true), "an inner abort poisons the batch");+ assert!(!state.pending.contains(&12));+ assert!(!state.depth.contains_key(&12));+ assert!(!state.aborted.contains(&12));+ }++ #[test]+ fn tab_geometry_transaction_publishes_one_final_notification() {+ let mux = Mux::new(None);+ let notifications = Arc::new(AtomicUsize::new(0));+ let observed = Arc::clone(¬ifications);+ mux.subscribe(move |notification| {+ if matches!(notification, MuxNotification::TabResized(21)) {+ observed.fetch_add(1, Ordering::Relaxed);+ }+ true+ });++ {+ let mut transaction = mux.begin_tab_geometry_transaction(21);+ mux.notify(MuxNotification::TabResized(21));+ mux.notify(MuxNotification::TabResized(21));+ assert_eq!(notifications.load(Ordering::Relaxed), 0);+ transaction.commit();+ }+ assert_eq!(notifications.load(Ordering::Relaxed), 1);+ }+fn client_id(id: usize) -> ClientId {ClientId {hostname: "test-host".to_string(),@@ -2447,6 +3005,95 @@ mod tests {}}+ fn frontend_test_size(cols: usize, rows: usize) -> TerminalSize {+ TerminalSize {+ cols,+ rows,+ pixel_width: cols * 8,+ pixel_height: rows * 16,+ dpi: 96,+ }+ }++ fn frontend_test_viewport(cols: usize, rows: usize) -> FrontendViewport {+ FrontendViewport::CellGrid {+ size: frontend_test_size(cols, rows),+ }+ }++ fn frontend_test_tab(mux: &Mux) -> TabId {+ let tab = Arc::new(Tab::new(&frontend_test_size(80, 24)));+ mux.add_tab_no_panes(&tab);+ tab.tab_id()+ }++ #[test]+ fn failed_first_handoff_geometry_revokes_the_automatic_owner() {+ let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::Handoff);+ let tab_id = frontend_test_tab(&mux);+ let client = client_id(201);+ mux.frontend_geometry_failures.lock().push_back(true);++ assert!(mux+ .set_client_viewport(&client, tab_id, frontend_test_viewport(120, 40))+ .is_err());+ let lease = mux.frontend_lease.lock();+ assert_eq!(lease.handoff_owner, None);+ assert!(lease.handoff_ever_owned);+ assert_eq!(lease.tabs[&tab_id].owner, None);+ }++ #[test]+ fn failed_handoff_claim_revokes_the_global_owner() {+ let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::Handoff);+ let tab_id = frontend_test_tab(&mux);+ let first = client_id(211);+ let second = client_id(212);+ {+ let mut lease = mux.frontend_lease.lock();+ lease.handoff_owner = Some(first.clone());+ lease.handoff_ever_owned = true;+ lease.tabs.entry(tab_id).or_default().owner = Some(first);+ }+ mux.frontend_geometry_failures.lock().push_back(true);++ assert!(mux+ .claim_frontend_viewport(&second, tab_id, frontend_test_viewport(120, 40))+ .is_err());+ let lease = mux.frontend_lease.lock();+ assert_eq!(lease.handoff_owner, None);+ assert_eq!(lease.tabs[&tab_id].owner, None);+ }++ #[test]+ fn failed_mode_geometry_restores_the_prior_mode_but_clears_ownership() {+ let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::Handoff);+ let tab_id = frontend_test_tab(&mux);+ let owner = client_id(221);+ {+ let mut lease = mux.frontend_lease.lock();+ lease.handoff_owner = Some(owner.clone());+ lease.handoff_ever_owned = true;+ lease.tabs.entry(tab_id).or_default().owner = Some(owner.clone());+ }+ mux.frontend_geometry_failures.lock().push_back(true);++ assert!(mux+ .set_frontend_access_mode(+ &owner,+ FrontendAccessMode::TmuxLatest,+ tab_id,+ frontend_test_viewport(120, 40),+ )+ .is_err());+ let access = mux.frontend_access_state();+ assert_eq!(access.mode, FrontendAccessMode::Handoff);+ assert_eq!(access.owner, None);+ }+fn palette(foreground: f32) -> ColorPalette {let mut palette = ColorPalette::default();palette.foreground = (foreground, foreground, foreground, 1.0).into();@@ -2544,6 +3191,7 @@ mod tests {#[test]fn frontend_ownership_is_scoped_per_tab() {let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::TmuxLatest);let first = Arc::new(client_id(31));let second = Arc::new(client_id(32));let mut lease = mux.frontend_lease.lock();@@ -2559,6 +3207,7 @@ mod tests {#[test]fn non_rendering_cli_input_does_not_steal_a_tab_viewport() {let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::TmuxLatest);let tui = Arc::new(client_id(62));let cli = Arc::new(client_id(63));mux.register_client(Arc::clone(&tui));@@ -2579,6 +3228,7 @@ mod tests {}}let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::TmuxLatest);let tab = Arc::new(Tab::new(&TerminalSize::default()));mux.add_tab_no_panes(&tab);let tab_40 = tab.tab_id();@@ -2626,7 +3276,7 @@ mod tests {}));- let _ = mux.claim_frontend_viewport(&second, tab_40);+ let _ = mux.claim_frontend_viewport(&second, tab_40, grid());assert_eq!(mux.frontend_lease.lock().tabs[&tab_40].view,None,@@ -2647,6 +3297,7 @@ mod tests {}let mux = Mux::new(None);+ mux.initialize_frontend_access_mode(FrontendAccessMode::TmuxLatest);let initial = size(132, 40);let tab = Arc::new(Tab::new(&initial));mux.add_tab_no_panes(&tab);@@ -2694,7 +3345,7 @@ mod tests {}#[test]- fn explicit_viewport_claim_uses_the_server_stored_advertisement() {+ fn explicit_viewport_claim_uses_request_geometry_atomically() {let mux = Mux::new(None);let initial = TerminalSize {cols: 120,@@ -2718,7 +3369,7 @@ mod tests {FrontendViewport::CellGrid { size: initial },).unwrap();- let smaller = TerminalSize {+ let advertised = TerminalSize {cols: 72,rows: 20,pixel_width: 576,@@ -2729,17 +3380,160 @@ mod tests {&second,second_registration,tab_id,- FrontendViewport::CellGrid { size: smaller },+ FrontendViewport::CellGrid { size: advertised },).unwrap();+ let claimed = TerminalSize {+ cols: 84,+ rows: 26,+ pixel_width: 672,+ pixel_height: 416,+ dpi: 96,+ };+let state = mux- .claim_registered_client_viewport(&second, second_registration, tab_id)+ .claim_registered_client_viewport(+ &second,+ second_registration,+ tab_id,+ FrontendViewport::CellGrid { size: claimed },+ ).unwrap().unwrap();assert_eq!(state.owner.as_ref(), Some(second.as_ref()));- assert_eq!(state.canonical_size, smaller);- assert_eq!(tab.get_size(), smaller);+ assert_eq!(state.access.owner.as_ref(), Some(second.as_ref()));+ assert_eq!(state.canonical_size, claimed);+ assert_eq!(tab.get_size(), claimed);+ let repeated = mux+ .claim_registered_client_viewport(+ &second,+ second_registration,+ tab_id,+ FrontendViewport::CellGrid { size: claimed },+ )+ .unwrap()+ .unwrap();+ assert_eq!(repeated.generation, state.generation);+ }++ #[test]+ fn handoff_disconnect_has_no_automatic_fallback() {+ let mux = Mux::new(None);+ let tab = Arc::new(Tab::new(&TerminalSize::default()));+ mux.add_tab_no_panes(&tab);+ let tab_id = tab.tab_id();+ let first = Arc::new(client_id(90));+ let second = Arc::new(client_id(91));+ let first_registration = mux.register_client(Arc::clone(&first));+ let second_registration = mux.register_client(Arc::clone(&second));+ let grid = FrontendViewport::CellGrid {+ size: TerminalSize::default(),+ };++ mux.set_registered_client_viewport(&first, first_registration, tab_id, grid.clone())+ .unwrap();+ mux.set_registered_client_viewport(&second, second_registration, tab_id, grid.clone())+ .unwrap();+ assert_eq!(+ mux.frontend_access_state().owner.as_ref(),+ Some(first.as_ref())+ );+ assert_eq!(+ mux.registered_client_has_frontend_access(&first, first_registration),+ Some(true)+ );+ assert_eq!(+ mux.registered_client_has_frontend_access(&second, second_registration),+ Some(false)+ );+ assert!(mux.registered_client_had_tab_input(&first, first_registration, tab_id));+ assert!(+ !mux.registered_client_had_tab_input(&second, second_registration, tab_id),+ "B must reject keyboard/mouse input from the opaque renderer"+ );++ mux.unregister_client(&first, first_registration);+ assert_eq!(+ mux.registered_client_has_frontend_access(&first, first_registration),+ None+ );+ assert_eq!(mux.frontend_access_state().owner, None);+ assert!(!mux.client_has_frontend_access(&second));++ // A passive redraw after the disconnect still must not acquire B.+ mux.set_registered_client_viewport(&second, second_registration, tab_id, grid.clone())+ .unwrap();+ assert_eq!(mux.frontend_access_state().owner, None);++ mux.claim_registered_client_viewport(&second, second_registration, tab_id, grid)+ .unwrap();+ assert_eq!(+ mux.frontend_access_state().owner.as_ref(),+ Some(second.as_ref())+ );+ }++ #[test]+ fn mode_changes_require_the_correct_current_owner() {+ let mux = Mux::new(None);+ let tab = Arc::new(Tab::new(&TerminalSize::default()));+ mux.add_tab_no_panes(&tab);+ let tab_id = tab.tab_id();+ let first = Arc::new(client_id(92));+ let second = Arc::new(client_id(93));+ let first_registration = mux.register_client(Arc::clone(&first));+ let second_registration = mux.register_client(Arc::clone(&second));+ let grid = FrontendViewport::CellGrid {+ size: TerminalSize::default(),+ };+ mux.set_registered_client_viewport(&first, first_registration, tab_id, grid.clone())+ .unwrap();+ mux.set_registered_client_viewport(&second, second_registration, tab_id, grid.clone())+ .unwrap();++ assert!(mux+ .set_registered_frontend_access_mode(+ &second,+ second_registration,+ FrontendAccessMode::TmuxLatest,+ tab_id,+ grid.clone(),+ )+ .is_err());+ mux.set_registered_frontend_access_mode(+ &first,+ first_registration,+ FrontendAccessMode::TmuxLatest,+ tab_id,+ grid.clone(),+ )+ .unwrap();++ // In A the active tab's layout owner, not an unrelated renderer, is+ // the one allowed to make itself B's global owner.+ mux.claim_registered_client_viewport(&second, second_registration, tab_id, grid.clone())+ .unwrap();+ assert!(mux+ .set_registered_frontend_access_mode(+ &first,+ first_registration,+ FrontendAccessMode::Handoff,+ tab_id,+ grid.clone(),+ )+ .is_err());+ let access = mux+ .set_registered_frontend_access_mode(+ &second,+ second_registration,+ FrontendAccessMode::Handoff,+ tab_id,+ grid,+ )+ .unwrap();+ assert_eq!(access.mode, FrontendAccessMode::Handoff);+ assert_eq!(access.owner.as_ref(), Some(second.as_ref()));}#[test]diff --git a/mux/src/tab.rs b/mux/src/tab.rsindex 7de759d9..128eb9a5 100644--- a/mux/src/tab.rs+++ b/mux/src/tab.rs@@ -1404,8 +1404,16 @@ impl TabInner {self.size_before_zoom = size;if let Some(pane) = self.get_active_pane() {pane.set_zoomed(true);- if let Err(err) = pane.resize(size) {- log::error!("failed to resize zoomed pane: {err:#}");+ // A remote mirror's frontend must subtract its own pane+ // chrome before sizing the PTY. Resizing it to the raw tab+ // size here races the frontend's complete viewport update+ // and briefly gives the zoomed pane too many rows/columns.+ // The geometry convergence following the zoom supplies the+ // authoritative frontend size.+ if !pane.is_remote_mirror() {+ if let Err(err) = pane.resize(size) {+ log::error!("failed to resize zoomed pane: {err:#}");+ }}self.zoomed.replace(pane);}@@ -3535,6 +3543,7 @@ mod test {struct FakePane {id: PaneId,size: Mutex<TerminalSize>,+ remote_mirror: bool,}impl FakePane {@@ -3542,6 +3551,15 @@ mod test {Arc::new(Self {id,size: Mutex::new(size),+ remote_mirror: false,+ })+ }++ fn remote_mirror(id: PaneId, size: TerminalSize) -> Arc<dyn Pane> {+ Arc::new(Self {+ id,+ size: Mutex::new(size),+ remote_mirror: true,})}}@@ -3641,6 +3659,9 @@ mod test {fn domain_id(&self) -> DomainId {1}+ fn is_remote_mirror(&self) -> bool {+ self.remote_mirror+ }fn is_mouse_grabbed(&self) -> bool {false}@@ -3668,15 +3689,16 @@ mod test {assert_eq!(80, panes[0].width);assert_eq!(24, panes[0].height);- assert!(tab- .compute_split_size(+ assert!(+ tab.compute_split_size(1,SplitRequest {direction: SplitDirection::Horizontal,..Default::default()})- .is_none());+ .is_none()+ );let horz_size = tab.compute_split_size(@@ -3920,6 +3942,30 @@ mod test {);}+ #[test]+ fn zoom_does_not_raw_resize_a_remote_mirror() {+ let _mux = install_mux();+ let tab_size = test_size();+ let pane_size = TerminalSize {+ rows: 11,+ cols: 39,+ pixel_width: 390,+ pixel_height: 275,+ dpi: 96,+ };+ let tab = Tab::new(&tab_size);+ let pane = FakePane::remote_mirror(1, pane_size);+ tab.assign_pane(&pane);++ tab.toggle_zoom();++ let dimensions = pane.get_dimensions();+ assert_eq!(dimensions.cols, pane_size.cols);+ assert_eq!(dimensions.viewport_rows, pane_size.rows);+ assert_eq!(tab.iter_panes()[0].width, tab_size.cols);+ assert_eq!(tab.iter_panes()[0].height, tab_size.rows);+ }+#[test]fn pane_stack_add_switch_and_remove() {let _mux = install_mux();@@ -4094,9 +4140,10 @@ mod test {size: SplitSize::Cells(1000),};let target_index = tab.pane_index_for_pane(1).unwrap();- assert!(tab- .split_and_insert(target_index, request, Arc::clone(&removed))- .is_err());+ assert!(+ tab.split_and_insert(target_index, request, Arc::clone(&removed))+ .is_err()+ );tab.rehome_orphan_pane(&removed);assert_eq!(tab.count_panes(), Some(2));@@ -4239,14 +4286,15 @@ mod test {mux.add_tab_no_panes(&target_tab);mux.add_pane(&target).unwrap();- assert!(mux- .move_pane_to_split(+ assert!(+ mux.move_pane_to_split(src.pane_id(),target_tab.tab_id(),target.pane_id(),SplitRequest::default(),)- .is_err());+ .is_err()+ );assert!(mux.get_tab(src_tab.tab_id()).is_some());assert!(src_tab.pane_index_for_pane(src.pane_id()).is_some());diff --git a/termwiz/src/render/terminfo.rs b/termwiz/src/render/terminfo.rsindex 0e63a3ea..ac6cb18e 100644--- a/termwiz/src/render/terminfo.rs+++ b/termwiz/src/render/terminfo.rs@@ -158,11 +158,20 @@ impl TerminfoRenderer {match (has_true_color, attr.foreground()) {(true, ColorAttribute::TrueColorWithPaletteFallback(tc, _))| (true, ColorAttribute::TrueColorWithDefaultFallback(tc)) => {- write!(- out,- "{}",- CSI::Sgr(Sgr::Foreground(ColorSpec::TrueColor(tc)))- )?;+ let (red, green, blue, alpha) = tc.to_srgb_u8();+ if alpha == 255 {+ // The semicolon form is the de-facto truecolor+ // sequence emitted by applications such as btop.+ // A number of otherwise truecolor-capable terminal+ // emulators still mishandle the ISO colon form.+ write!(out, "\x1b[38;2;{red};{green};{blue}m")?;+ } else {+ write!(+ out,+ "{}",+ CSI::Sgr(Sgr::Foreground(ColorSpec::TrueColor(tc)))+ )?;+ }}(false, ColorAttribute::TrueColorWithDefaultFallback(_))| (_, ColorAttribute::Default) => {@@ -194,11 +203,16 @@ impl TerminfoRenderer {match (has_true_color, attr.background()) {(true, ColorAttribute::TrueColorWithPaletteFallback(tc, _))| (true, ColorAttribute::TrueColorWithDefaultFallback(tc)) => {- write!(- out,- "{}",- CSI::Sgr(Sgr::Background(ColorSpec::TrueColor(tc)))- )?;+ let (red, green, blue, alpha) = tc.to_srgb_u8();+ if alpha == 255 {+ write!(out, "\x1b[48;2;{red};{green};{blue}m")?;+ } else {+ write!(+ out,+ "{}",+ CSI::Sgr(Sgr::Background(ColorSpec::TrueColor(tc)))+ )?;+ }}(false, ColorAttribute::TrueColorWithDefaultFallback(_))| (_, ColorAttribute::Default) => {@@ -1260,6 +1274,8 @@ mod test {]).unwrap();+ assert_eq!(out.write.buf, b"\x1b[38;2;255;128;64mA");+let result = out.parse();assert_eq!(result,@@ -1283,6 +1299,8 @@ mod test {]).unwrap();+ assert_eq!(out.write.buf, b"\x1b[38;2;255;128;64mA");+let result = out.parse();assert_eq!(result,@@ -1294,4 +1312,18 @@ mod test {]);}++ #[test]+ fn truecolor_background_uses_compatible_semicolon_form() {+ let mut out = FakeTerm::new(xterm_terminfo());+ out.render(&[+ Change::Attribute(AttributeChange::Background(+ ColorSpec::TrueColor((12, 34, 56).into()).into(),+ )),+ Change::Text("A".into()),+ ])+ .unwrap();++ assert_eq!(out.write.buf, b"\x1b[48;2;12;34;56mA");+ }}diff --git a/thinkterm-tui/src/action.rs b/thinkterm-tui/src/action.rsindex a8f2e74a..f3fda20a 100644--- a/thinkterm-tui/src/action.rs+++ b/thinkterm-tui/src/action.rs@@ -39,6 +39,8 @@ pub enum DestructiveAction {#[derive(Clone, Debug, PartialEq, Eq)]pub enum Action {None,+ ClaimFrontendAccess,+ SetFrontendAccessMode(codec::FrontendAccessMode),Detach,ToggleSidebar,ToggleHelp,diff --git a/thinkterm-tui/src/lib.rs b/thinkterm-tui/src/lib.rsindex 965c0121..40c5a542 100644--- a/thinkterm-tui/src/lib.rs+++ b/thinkterm-tui/src/lib.rs@@ -43,7 +43,7 @@ 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};+use wezterm_client::domain::{ClientDomain, ClientDomainConfig, RemoteFrontendGate};use wezterm_client::pane::ClientPane;use wezterm_term::input::{MouseButton, MouseEvent, MouseEventKind};use wezterm_term::TerminalSize;@@ -78,6 +78,48 @@ const RESIZE_REDRAW_WINDOW: Duration = Duration::from_millis(1500);/// Pace of those extra draws. Fast enough to look immediate, slow enough that/// the prefetch throttle refills between attempts.const RESIZE_REDRAW_INTERVAL: Duration = Duration::from_millis(60);+const TAKEOVER_RESYNC_RETRY_DELAY: Duration = Duration::from_millis(250);++#[derive(Default)]+struct TakeoverEpochs {+ pending: HashMap<(String, TabId), u64>,+ next: u64,+}++impl TakeoverEpochs {+ fn begin(&mut self, domain_name: &str, tab_id: TabId) -> u64 {+ self.next = self.next.wrapping_add(1).max(1);+ let epoch = self.next;+ self.pending+ .insert((domain_name.to_string(), tab_id), epoch);+ epoch+ }++ fn contains(&self, domain_name: &str, tab_id: TabId) -> bool {+ self.pending+ .contains_key(&(domain_name.to_string(), tab_id))+ }++ fn finish(&mut self, domain_name: &str, tab_id: TabId, epoch: u64) -> bool {+ let key = (domain_name.to_string(), tab_id);+ if self.pending.get(&key) != Some(&epoch) {+ return false;+ }+ self.pending.remove(&key);+ true+ }+}++fn effective_frontend_gate(+ takeover_pending: bool,+ remote_gate: RemoteFrontendGate,+) -> RemoteFrontendGate {+ if takeover_pending {+ RemoteFrontendGate::Syncing+ } else {+ remote_gate+ }+}#[derive(Debug, Clone)]pub struct TuiOptions {@@ -614,9 +656,10 @@ struct TuiState {/// 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)>>,- /// A deliberate frontend layout change (such as hiding the sidebar)- /// should make this renderer's newly advertised grid authoritative.- claim_viewport_after_layout: bool,+ /// 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,+ takeover_epochs: TakeoverEpochs,/// When the panes were last asked for new content, so the loop keeps asking/// even while nothing local has changed.last_pane_poll: Instant,@@ -650,6 +693,7 @@ struct TuiState {settings: TuiConfig,settings_path: PathBuf,state_path: PathBuf,+ animation_epoch: Instant,}#[derive(Clone, Debug)]@@ -715,7 +759,8 @@ impl TuiState {layout: ViewLayout::default(),last_mouse_buttons: MouseButtons::NONE,last_viewports: HashMap::new(),- claim_viewport_after_layout: false,+ handoff_consumed_press: false,+ takeover_epochs: TakeoverEpochs::default(),last_pane_poll: Instant::now(),shared_view: None,shared_view_at: None,@@ -732,6 +777,7 @@ impl TuiState {settings,settings_path,state_path,+ animation_epoch: Instant::now(),};sync_connection_statuses(&mut state);state@@ -774,16 +820,67 @@ impl TuiState {domain.owns_remote_viewport(tab.tab_id()) != Some(false)}+ fn active_frontend_access(&self) -> Option<codec::FrontendAccessState> {+ let (_, domain, _, _) = self.active_tab()?;+ domain.remote_access_state()+ }++ fn frontend_gate(&self) -> RemoteFrontendGate {+ let Some((domain_name, domain, _, remote_tab_id)) = self.active_tab() else {+ return RemoteFrontendGate::Visible;+ };+ effective_frontend_gate(+ self.takeover_epochs.contains(&domain_name, remote_tab_id),+ domain.remote_frontend_gate(),+ )+ }++ fn frontend_surface_blocked(&self) -> bool {+ self.frontend_gate().obscures_terminal()+ }++ fn frontend_takeover_claimable(&self) -> bool {+ self.frontend_gate().is_claimable()+ }++ fn frontend_overlay_message(&self) -> Option<(String, String)> {+ self.frontend_gate().overlay_message()+ }++ fn shared_grid_is_visible(&self) -> bool {+ self.active_frontend_access()+ .is_some_and(|state| state.mode == codec::FrontendAccessMode::TmuxLatest)+ && !self.owns_active_viewport()+ }+fn viewport_status(&self) -> Option<String> {let (_, domain, tab, _) = self.active_tab()?;+ let access = domain.remote_access_state()?;let state = domain.remote_viewport_state(tab.tab_id())?;- if domain.owns_remote_viewport(tab.tab_id()) == Some(false) {- Some(format!(- "VIEW {}×{} · input to take control",- state.canonical_size.cols, state.canonical_size.rows- ))- } else {- None+ match access.mode {+ codec::FrontendAccessMode::TmuxLatest => {+ if domain.owns_remote_viewport(tab.tab_id()) == Some(false) {+ Some(format!(+ "A SHARED · VIEW {}×{}",+ state.canonical_size.cols, state.canonical_size.rows+ ))+ } else {+ Some("A SHARED".to_string())+ }+ }+ codec::FrontendAccessMode::Handoff => {+ if domain.has_remote_access() == Some(true) {+ Some("B ACTIVE".to_string())+ } else {+ let owner = access+ .owner+ .as_ref()+ .map(|owner| owner.hostname.as_str())+ .filter(|hostname| !hostname.trim().is_empty())+ .unwrap_or("other");+ Some(format!("B VIEW · {owner}"))+ }+ }}}@@ -915,6 +1012,12 @@ async fn run_terminal(if state.last_pane_poll.elapsed() >= PANE_POLL_INTERVAL {poll_panes(&state);state.last_pane_poll = Instant::now();+ // The blocked surface is the only TUI view with ambient motion.+ // Piggyback on the existing pane poll instead of adding another+ // timer; normal terminal rendering stays event driven.+ if state.frontend_surface_blocked() {+ state.dirty = true;+ }}if state.share_view_pending && share_view_is_due(&state) {@@ -925,6 +1028,11 @@ async fn run_terminal(let active = state.active_tab();let local_tab = active.as_ref().map(|(_, _, tab, _)| Arc::clone(tab));let viewport_status = state.viewport_status();+ let frontend_gate = state.frontend_gate();+ let handoff_message = frontend_gate.overlay_message();+ let handoff_animation =+ render::HandoffAnimationFrame::at(state.animation_epoch.elapsed());+ let shared_grid = state.shared_grid_is_visible();let mut rendered = render::RenderResult::default();let mut next_layout = ViewLayout::default();state.ui.begin_frame();@@ -938,6 +1046,9 @@ async fn run_terminal(local_tab.as_ref(),&next_layout,viewport_status.as_deref(),+ handoff_message.as_ref(),+ handoff_animation,+ shared_grid,&state.settings,);})?;@@ -1296,28 +1407,6 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(}push_pane_sizes(state, &domain, local_tab_id, screen);share_view_if_changed(state, &domain, local_tab_id).await;-- if state.claim_viewport_after_layout {- state.claim_viewport_after_layout = false;- match domain.claim_client_viewport(local_tab_id).await {- Ok(viewport) => {- // Deliberately no pane push here. `state.layout` still- // describes the tab at the size the *other* renderer left it,- // and pushing those rectangles immediately after adopting a new- // tab size hands the server the old geometry back — the claim- // undoing itself. Resizing the tab dirties the frame, and the- // next one pushes rectangles that match.- adopt_local_tab_size(- local_tab_id,- local_tab_size(&domain, local_tab_id, size, viewport.canonical_size),- );- }- Err(err) => {- state.ui.status = format!("Viewport control: {err}");- state.dirty = true;- }- }- }}/// Ask every pane on screen whether anything changed.@@ -1561,23 +1650,113 @@ async fn dispatch_actions(state: &mut TuiState) {async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {let (domain_name, domain, tab, remote_tab_id) =state.active_tab().context("no live tab selected")?;+ if !matches!(+ domain.remote_frontend_gate(),+ RemoteFrontendGate::Visible | RemoteFrontendGate::Claimable { .. }+ ) {+ anyhow::bail!("terminal connection is not ready for takeover");+ }let local_tab_id = tab.tab_id();- if !state+ if domain.owns_remote_viewport(local_tab_id) == Some(true) {+ return Ok(tab);+ }+ let size = state.last_viewports- .contains_key(&(domain_name, remote_tab_id))+ .get(&(domain_name.clone(), remote_tab_id))+ .and_then(|entry| *entry)+ .map(|(size, _)| size)+ .context("viewport is not ready; retry after the terminal redraws")?;+ 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 })+ .await{- anyhow::bail!("viewport is not ready; retry after the terminal redraws");- }- domain.claim_client_viewport(local_tab_id).await?;+ Ok(claimed) => claimed,+ Err(err) => {+ state+ .takeover_epochs+ .finish(&domain_name, remote_tab_id, epoch);+ return Err(err);+ }+ };if domain.owns_remote_viewport(local_tab_id) != Some(true) {+ state+ .takeover_epochs+ .finish(&domain_name, remote_tab_id, epoch);anyhow::bail!("the server did not grant viewport ownership");}- Ok(tab)++ adopt_local_tab_size(local_tab_id, claimed.canonical_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);+ let final_tab = Mux::get().get_tab(final_local_tab_id).unwrap_or(tab);+ if let Err(err) = resync {+ log::warn!(+ "resyncing {domain_name} after TUI viewport takeover: {err:#}; using acknowledged geometry"+ );+ schedule_takeover_resync(domain_name.clone(), Arc::clone(&domain));+ }+ state+ .takeover_epochs+ .finish(&domain_name, remote_tab_id, epoch);+ for pane in &state.layout.panes {+ state.ui.set_scroll_offset(pane.pane_id, 0);+ }+ state.shared_view = None;+ state.followed_view = None;+ Ok(final_tab)+}++fn schedule_takeover_resync(domain_name: String, domain: Arc<ClientDomain>) {+ promise::spawn::spawn(async move {+ smol::Timer::after(TAKEOVER_RESYNC_RETRY_DELAY).await;+ if let Err(err) = domain.resync().await {+ log::warn!("retrying {domain_name} topology after TUI takeover: {err:#}");+ }+ wake_terminal();+ Ok::<(), anyhow::Error>(())+ })+ .detach();+}++async fn set_active_frontend_access_mode(+ state: &mut TuiState,+ mode: codec::FrontendAccessMode,+) -> Result<()> {+ 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)+ .context("viewport is not ready; retry after the terminal redraws")?;+ domain+ .set_frontend_access_mode(local_tab_id, mode, ClientViewport::CellGrid { size })+ .await?;+ for pane in &state.layout.panes {+ state.ui.set_scroll_offset(pane.pane_id, 0);+ }+ state.shared_view = None;+ state.followed_view = None;+ state.clear_selected_viewport_cache();+ Ok(())}async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {match action {Action::None => {}+ Action::ClaimFrontendAccess => {+ claim_active_viewport(state).await?;+ }+ Action::SetFrontendAccessMode(mode) => {+ set_active_frontend_access_mode(state, mode).await?;+ }Action::Detach => state.ui.exit = true,Action::ToggleSidebar => {state.ui.sidebar_visible = !state.ui.sidebar_visible;@@ -1592,7 +1771,6 @@ async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {save_tui_settings(state)?;}state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}Action::ToggleHelp => {state.ui.mode = if state.ui.mode == AppMode::Help {@@ -1643,21 +1821,27 @@ async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {}}Action::FocusPane(direction) => {+ claim_active_viewport(state).await?;if let Some((_, _, tab, _)) = state.active_tab() {tab.activate_pane_direction(direction);}}Action::FocusPaneId(pane_id) => {+ claim_active_viewport(state).await?;if let (Some((_, _, tab, _)), Some(pane)) = (state.active_tab(), state.pane(pane_id)) {tab.set_active_pane(&pane);}}- Action::CyclePane(delta) => cycle_pane(state, delta),+ Action::CyclePane(delta) => {+ claim_active_viewport(state).await?;+ cycle_pane(state, delta);+ }Action::NewTab => spawn_tab_for_selected_thread(state).await?,Action::RenameTab => begin_rename_tab(state),Action::NewPaneInStack(pane_id) => new_pane_in_stack(state, pane_id).await?,Action::SplitPane(axis) => split_active_pane(state, axis).await?,Action::ToggleZoom => {+ claim_active_viewport(state).await?;if let Some((_, _, tab, _)) = state.active_tab() {tab.toggle_zoom();}@@ -1678,8 +1862,14 @@ async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {state.ui.copy = None;state.ui.mode = AppMode::Terminal;}- Action::ScrollPane { pane_id, lines } => scroll_pane(state, pane_id, lines),- Action::ScrollToBottom { pane_id } => state.ui.set_scroll_offset(pane_id, 0),+ Action::ScrollPane { pane_id, lines } => {+ claim_active_viewport(state).await?;+ scroll_pane(state, pane_id, lines);+ }+ Action::ScrollToBottom { pane_id } => {+ claim_active_viewport(state).await?;+ state.ui.set_scroll_offset(pane_id, 0);+ }Action::CopySelection => copy_selection(state)?,Action::PasteClipboard => paste_clipboard(state)?,Action::BeginSearch { backwards } => begin_search(state, backwards),@@ -1807,7 +1997,6 @@ fn adjust_setting(state: &mut TuiState, index: usize, delta: isize) -> Result<()state.ui.sidebar_visible = !state.ui.sidebar_visible;state.settings.sidebar_visible = state.ui.sidebar_visible;state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}2 => {state.settings.pane_nav_bar = !state.settings.pane_nav_bar;@@ -1815,19 +2004,16 @@ fn adjust_setting(state: &mut TuiState, index: usize, delta: isize) -> Result<()// All three of these hand columns and rows between the chrome and// the grid, so the server has to be told the pane changed size.state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}3 => {state.settings.pane_borders = !state.settings.pane_borders;state.ui.pane_borders = state.settings.pane_borders;state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}4 => {state.settings.pane_scrollbars = !state.settings.pane_scrollbars;state.ui.pane_scrollbars = state.settings.pane_scrollbars;state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}5 => state.settings.mouse = !state.settings.mouse,6 => state.settings.copy_on_select = !state.settings.copy_on_select,@@ -1841,7 +2027,6 @@ fn adjust_setting(state: &mut TuiState, index: usize, delta: isize) -> Result<()};state.ui.touch_targets = state.settings.touch_targets;state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}8 => {state.settings.scroll_lines =@@ -1866,7 +2051,6 @@ async fn select_thread(state: &mut TuiState, key: &ThreadKey) -> Result<()> {if state.layout.class == ViewClass::Narrow && state.ui.sidebar_visible {state.ui.sidebar_visible = false;state.clear_selected_viewport_cache();- state.claim_viewport_after_layout = true;}mark_thread_seen(state, key).await?;ensure_selected_thread_live(state, false, None).await@@ -3203,12 +3387,33 @@ fn handle_key(event: KeyEvent, state: &mut TuiState) {return;}AppMode::Prefix => {+ if state.frontend_surface_blocked() {+ state.ui.mode = AppMode::Terminal;+ state.ui.status = state+ .frontend_overlay_message()+ .map(|(_, hint)| hint)+ .unwrap_or_default();+ state.dirty = true;+ return;+ }handle_prefix_key(key, modifiers, state);return;}AppMode::Terminal => {}}+ if state.frontend_surface_blocked() {+ // B deliberately does not let the keyboard steal control: there is no+ // safe way to distinguish a takeover gesture from text intended for+ // the still-hidden terminal.+ state.ui.status = state+ .frontend_overlay_message()+ .map(|(_, hint)| hint)+ .unwrap_or_default();+ state.dirty = true;+ return;+ }+if is_prefix {state.ui.mode = AppMode::Prefix;state.ui.status.clear();@@ -3720,6 +3925,10 @@ fn open_context_menu(state: &mut TuiState, x: u16, y: u16, target: Option<HitTar}fn open_main_menu(state: &mut TuiState, x: u16, y: u16) {+ let current_mode = state+ .active_frontend_access()+ .map(|state| state.mode)+ .unwrap_or(codec::FrontendAccessMode::Handoff);state.ui.context_menu = Some(ContextMenuState {anchor: (x, y),selected: 0,@@ -3730,6 +3939,22 @@ fn open_main_menu(state: &mut TuiState, x: u16, y: u16) {menu_entry("Copy Mode", Action::EnterCopyMode),menu_entry("Paste", Action::PasteClipboard),menu_entry("Connections", Action::OpenConnections),+ menu_entry(+ if current_mode == codec::FrontendAccessMode::TmuxLatest {+ "✓ A · Shared (tmux-like)"+ } else {+ "A · Shared (tmux-like)"+ },+ Action::SetFrontendAccessMode(codec::FrontendAccessMode::TmuxLatest),+ ),+ menu_entry(+ if current_mode == codec::FrontendAccessMode::Handoff {+ "✓ B · Handoff (exclusive)"+ } else {+ "B · Handoff (exclusive)"+ },+ Action::SetFrontendAccessMode(codec::FrontendAccessMode::Handoff),+ ),menu_entry("TUI Settings", Action::OpenSettings),menu_entry("Toggle Sidebar", Action::ToggleSidebar),menu_entry("Help", Action::ToggleHelp),@@ -3816,18 +4041,14 @@ fn handle_mouse(event: TermwizMouseEvent, state: &mut TuiState) {let wheel =current.contains(MouseButtons::VERT_WHEEL) || current.contains(MouseButtons::HORZ_WHEEL);- // Before any of the branches below, every one of which returns early.- //- // Touching a renderer is the plainest statement that it is the one being- // looked at, and the server only hands the viewport over on input it can- // see — a click or a scroll on a pane that has not asked for mouse- // reporting never leaves this process. Hanging this off the left-click- // branch alone was not enough: the wheel is handled and returned several- // branches earlier, so scrolling, which is most of what a phone does, never- // took the viewport at all. Motion is excluded on purpose; a pointer- // crossing the window is not a statement about anything.- if (left_pressed || right_pressed || middle_pressed || wheel) && !state.owns_active_viewport() {- state.claim_viewport_after_layout = true;+ let pointer_release = !current+ .intersects(MouseButtons::LEFT | MouseButtons::RIGHT | MouseButtons::MIDDLE)+ && prior.intersects(MouseButtons::LEFT | MouseButtons::RIGHT | MouseButtons::MIDDLE);+ if state.handoff_consumed_press && pointer_release {+ state.handoff_consumed_press = false;+ state.last_mouse_buttons = current;+ state.dirty = true;+ return;}if modal_mouse_input(state, x, y, left_pressed) {@@ -3836,6 +4057,21 @@ fn handle_mouse(event: TermwizMouseEvent, state: &mut TuiState) {return;}+ let terminal_surface = state.layout.content.contains((x, y).into());+ let takeover_gesture = left_pressed || right_pressed || middle_pressed || wheel;+ if state.ui.mode == AppMode::Terminal && terminal_surface && state.frontend_surface_blocked() {+ if takeover_gesture && state.frontend_takeover_claimable() {+ state.handoff_consumed_press = left_pressed || right_pressed || middle_pressed;+ state.queue(Action::ClaimFrontendAccess);+ }+ state.last_mouse_buttons = current;+ state.dirty = true;+ return;+ }+ if state.ui.mode == AppMode::Terminal && terminal_surface && takeover_gesture {+ state.queue(Action::ClaimFrontendAccess);+ }+if let Some(pane_id) = state.forwarded_mouse_pane {forward_mouse_to_pane(event, x, y, Some(pane_id), state);if first_button(¤t).is_none() {@@ -4036,10 +4272,6 @@ fn handle_mouse(event: TermwizMouseEvent, state: &mut TuiState) {Some(DragState::SidebarResize) => {state.ui.sidebar_width = x.saturating_sub(state.layout.screen.x).clamp(18, 36);state.clear_selected_viewport_cache();- // Dragging the divider is as deliberate as toggling the sidebar- // away, so it earns the same authority over the grid; without- // this the terminal keeps whichever width another client chose.- state.claim_viewport_after_layout = true;}Some(DragState::TreeNode { .. }) => {}Some(DragState::SplitResize {@@ -4475,6 +4707,36 @@ fn mouse_transition(prior: &MouseButtons, current: &MouseButtons) -> (MouseEventmod tests {use super::*;+ #[test]+ fn takeover_epochs_are_scoped_to_domain_and_top_level_tab() {+ let mut epochs = TakeoverEpochs::default();+ let first = epochs.begin("devbox", 7);+ let second = epochs.begin("devbox", 8);++ assert!(epochs.contains("devbox", 7));+ assert!(epochs.contains("devbox", 8));+ assert!(!epochs.finish("devbox", 7, first.wrapping_add(10)));+ assert!(epochs.contains("devbox", 7));+ assert!(epochs.finish("devbox", 7, first));+ assert!(!epochs.contains("devbox", 7));+ assert!(epochs.contains("devbox", 8));+ assert!(epochs.finish("devbox", 8, second));+ }++ #[test]+ fn takeover_pending_forces_the_tui_gate_to_syncing() {+ let claimable = RemoteFrontendGate::Claimable { owner: None };+ assert_eq!(+ effective_frontend_gate(true, claimable.clone()),+ RemoteFrontendGate::Syncing+ );+ assert_eq!(effective_frontend_gate(false, claimable.clone()), claimable);+ assert_eq!(+ effective_frontend_gate(true, RemoteFrontendGate::Visible),+ RemoteFrontendGate::Syncing+ );+ }+fn model_for_reorder() -> AppModel {let mut model = AppModel::default();model.apply_snapshot(@@ -4700,6 +4962,11 @@ mod tests {canonical_size: TerminalSize::default(),view: None,generation: 1,+ access: mux::FrontendAccessState {+ mode: mux::FrontendAccessMode::Handoff,+ owner: None,+ generation: 1,+ },})));}diff --git a/thinkterm-tui/src/render.rs b/thinkterm-tui/src/render.rsindex 4d80822a..5cf42620 100644--- a/thinkterm-tui/src/render.rs+++ b/thinkterm-tui/src/render.rs@@ -22,6 +22,26 @@ pub struct RenderResult {pub active_pane: Option<PaneId>,}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct HandoffAnimationFrame {+ eyes_closed: bool,+}++impl Default for HandoffAnimationFrame {+ fn default() -> Self {+ Self { eyes_closed: false }+ }+}++impl HandoffAnimationFrame {+ pub fn at(elapsed: std::time::Duration) -> Self {+ let millis = elapsed.as_millis() as u64;+ Self {+ eyes_closed: millis % 5_000 >= 4_750,+ }+ }+}+/// Rendering is intentionally read-only. Selection normalization and geometry/// are completed before this function is called, so a draw can never change/// what the next mouse event means.@@ -32,6 +52,9 @@ pub fn render(local_tab: Option<&Arc<Tab>>,view: &ViewLayout,viewport_status: Option<&str>,+ handoff_message: Option<&(String, String)>,+ handoff_animation: HandoffAnimationFrame,+ shared_grid: bool,settings: &TuiConfig,) -> RenderResult {let mut result = RenderResult {@@ -51,8 +74,13 @@ pub fn render(render_tabs(frame, view);render_status(frame, model, ui, view, viewport_status);- if let Some(tab) = local_tab {+ if let Some((title, hint)) = handoff_message {+ render_handoff(frame, view.content, title, hint, handoff_animation);+ } else if let Some(tab) = local_tab {result.active_pane = tab.get_active_pane().map(|pane| pane.pane_id());+ if shared_grid {+ render_shared_grid(frame, view.content);+ }render_panes(frame, tab, ui, view);} else {let message = match model.selected_row() {@@ -67,6 +95,63 @@ pub fn render(result}+fn render_handoff(+ frame: &mut Frame<'_>,+ area: Rect,+ title: &str,+ hint: &str,+ animation: HandoffAnimationFrame,+) {+ frame.render_widget(Clear, area);+ fill(frame, area, " ", chrome());+ if area.width == 0 || area.height == 0 {+ return;+ }+ let show_eyes = area.width >= 12 && area.height >= 5;+ let group_height = if show_eyes { 4 } else { 2 };+ let start_y = area.y + area.height.saturating_sub(group_height) / 2;+ if show_eyes {+ let eyes = if animation.eyes_closed {+ "─ ─"+ } else {+ "• •"+ };+ render_center(+ frame,+ Rect::new(area.x, start_y, area.width, 1),+ eyes,+ chrome_accent_text(),+ );+ }+ let title_y = start_y + if show_eyes { 2 } else { 0 };+ render_center(+ frame,+ Rect::new(area.x, title_y, area.width, 1),+ title,+ chrome_bold(),+ );+ if title_y + 1 < area.bottom() {+ render_center(+ frame,+ Rect::new(area.x, title_y + 1, area.width, 1),+ hint,+ chrome_dim(),+ );+ }+}++fn render_shared_grid(frame: &mut Frame<'_>, area: Rect) {+ for y in area.y..area.bottom() {+ for x in area.x..area.right() {+ if (x + y) % 2 == 0 {+ frame.buffer_mut()[(x, y)]+ .set_symbol("·")+ .set_style(chrome_dim());+ }+ }+ }+}+fn render_sidebar(frame: &mut Frame<'_>, view: &ViewLayout) {let Some(sidebar) = view.sidebar else {return;@@ -558,12 +643,17 @@ fn render_status(format!(" {} on {}… ", pending.label, pending.domain_name)} else if !ui.status.is_empty() {format!(" {} ", ui.status)- } else if let Some(viewport) = viewport_status {- format!(" {viewport} ")} else {format!(" r{} · #{} ", model.tree_revision(), model.generation())};- let reserve_right = if model.attention_count() > 0 { 18 } else { 8 };+ let base_right = if model.attention_count() > 0 { 18 } else { 8 };+ let access_marker = viewport_status.map(|status| format!(" {status} "));+ let access_width = access_marker+ .as_deref()+ .map(|marker| unicode_column_width(marker, None).min(28) as u16)+ .unwrap_or(0)+ .min(view.status.width.saturating_sub(base_right));+ let reserve_right = base_right + access_width;let message_width = unicode_column_width(&message, None).min(view.status.width.saturating_sub(reserve_right) as usize)as u16;@@ -579,6 +669,23 @@ fn render_status(draw_text(frame, rect, &message, chrome_dim());}+ if let (Some(marker), width) = (access_marker.as_deref(), access_width) {+ if width > 0 {+ let rect = Rect::new(+ view.status.right().saturating_sub(base_right + width),+ view.status.y,+ width,+ 1,+ );+ draw_text(+ frame,+ rect,+ marker,+ chrome_accent_text().add_modifier(Modifier::BOLD),+ );+ }+ }+if model.attention_count() > 0 && view.status.width >= 18 {let text = format!(" ! {} ", model.attention_count());let rect = Rect::new(view.status.right() - 17, view.status.y, 9, 1);@@ -1139,6 +1246,80 @@ mod tests {assert_eq!(chrome_selected().bg, Some(Color::Rgb(137, 180, 250)));}+ #[test]+ fn handoff_overlay_clears_previously_rendered_terminal_cells() {+ let _guard = THEME_TEST_LOCK.lock().unwrap();+ use ratatui::backend::TestBackend;+ use ratatui::Terminal;++ let backend = TestBackend::new(44, 6);+ let mut terminal = Terminal::new(backend).unwrap();+ terminal+ .draw(|frame| {+ let area = frame.area();+ fill(frame, area, "S", chrome());+ render_handoff(+ frame,+ area,+ "Terminal is being used on devbox",+ "Click or scroll to continue",+ HandoffAnimationFrame::default(),+ );+ })+ .unwrap();++ let buffer = terminal.backend().buffer();+ let rendered = buffer+ .content+ .iter()+ .map(|cell| cell.symbol())+ .collect::<String>();+ assert!(!rendered.contains('S'));+ assert!(rendered.contains("Terminal is being used on devbox"));+ assert!(rendered.contains("Click or scroll to continue"));+ }++ #[test]+ fn roomy_handoff_overlay_draws_centered_eyes() {+ let _guard = THEME_TEST_LOCK.lock().unwrap();+ use ratatui::backend::TestBackend;+ use ratatui::Terminal;++ let backend = TestBackend::new(50, 12);+ let mut terminal = Terminal::new(backend).unwrap();+ terminal+ .draw(|frame| {+ render_handoff(+ frame,+ frame.area(),+ "Terminal is being used on devbox",+ "Click or scroll to continue",+ HandoffAnimationFrame::default(),+ );+ })+ .unwrap();++ let rendered = terminal+ .backend()+ .buffer()+ .content+ .iter()+ .map(|cell| cell.symbol())+ .collect::<String>();+ assert!(rendered.contains("• •"));+ assert!(!rendered.contains('╭'));+ assert!(!rendered.contains(">_"));+ }++ #[test]+ fn handoff_animation_blinks_the_eyes_briefly() {+ let ordinary = HandoffAnimationFrame::at(std::time::Duration::from_millis(750));+ assert!(!ordinary.eyes_closed);++ let blink = HandoffAnimationFrame::at(std::time::Duration::from_millis(4_800));+ assert!(blink.eyes_closed);+ }+/// A program's `ESC[31m` has to reach the host terminal as "red", not as/// whatever RGB some palette happens to map index 1 to. Resolving it here/// is what let a red logo arrive in the default foreground.diff --git a/wezterm-client/src/client.rs b/wezterm-client/src/client.rsindex 701fa9d6..cccf96dc 100644--- a/wezterm-client/src/client.rs+++ b/wezterm-client/src/client.rs@@ -9,7 +9,7 @@ use filedescriptor::FileDescriptor;use futures::FutureExt;use mux::client::ClientId;use mux::connui::ConnectionUI;-use mux::domain::DomainId;+use mux::domain::{Domain, DomainId};use mux::pane::PaneId;use mux::ssh::ssh_connect_with_ui_and_password;use mux::Mux;@@ -19,7 +19,7 @@ use portable_pty::Child;use smol::channel::{bounded, unbounded, Receiver, Sender};use smol::prelude::*;use smol::{block_on, Async};-use std::collections::HashMap;+use std::collections::{HashMap, VecDeque};use std::io::{Read, Write};use std::marker::Unpin;use std::net::TcpStream;@@ -30,7 +30,7 @@ use std::os::unix::process::CommandExt;#[cfg(windows)]use std::os::windows::io::{AsRawSocket, AsSocket, BorrowedSocket, RawSocket};use std::path::{Path, PathBuf};-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};+use std::sync::atomic::{AtomicU64, AtomicU8, Ordering};use std::sync::mpsc::channel;use std::sync::{Arc, RwLock};use std::thread;@@ -52,6 +52,19 @@ enum ReaderMessage {SendPdu {pdu: Pdu,promise: Sender<anyhow::Result<Pdu>>,+ registration_required: bool,+ },+ /// `SetClientId` was acknowledged for this connection generation. Only+ /// now may ordinary RPCs queued during reconnect reach the new session.+ RegistrationComplete {+ connection_generation: u64,+ },+ /// Tear down a generation whose transport connected but whose topology+ /// could not be restored. The normal reconnect loop will make a fresh+ /// transport and repeat the complete bootstrap.+ AbortGeneration {+ connection_generation: u64,+ reason: String,},Readable,/// The connection has been idle for a while: send a keepalive ping,@@ -59,6 +72,104 @@ enum ReaderMessage {KeepaliveTick,}+struct RegistrationBarrier<T> {+ complete: bool,+ deferred: VecDeque<T>,+}++impl<T> RegistrationBarrier<T> {+ fn new() -> Self {+ Self {+ complete: false,+ deferred: VecDeque::new(),+ }+ }++ fn submit(&mut self, item: T, registration_required: bool) -> Option<T> {+ if registration_required && !self.complete {+ self.deferred.push_back(item);+ None+ } else {+ Some(item)+ }+ }++ fn complete(&mut self) -> VecDeque<T> {+ self.complete = true;+ std::mem::take(&mut self.deferred)+ }++ fn drain(&mut self) -> VecDeque<T> {+ std::mem::take(&mut self.deferred)+ }+}++struct PduRegistrationBarrier {+ inner: RegistrationBarrier<(Pdu, Sender<anyhow::Result<Pdu>>)>,+}++impl PduRegistrationBarrier {+ fn new() -> Self {+ Self {+ inner: RegistrationBarrier::new(),+ }+ }++ fn submit(+ &mut self,+ item: (Pdu, Sender<anyhow::Result<Pdu>>),+ registration_required: bool,+ ) -> Option<(Pdu, Sender<anyhow::Result<Pdu>>)> {+ self.inner.submit(item, registration_required)+ }++ fn complete(&mut self) -> VecDeque<(Pdu, Sender<anyhow::Result<Pdu>>)> {+ self.inner.complete()+ }++ fn is_complete(&self) -> bool {+ self.inner.complete+ }++ fn fail_deferred(&mut self, reason: &str) {+ for (_, promise) in self.inner.drain() {+ let _ = promise.try_send(Err(anyhow!(reason.to_string())));+ }+ }+}++impl Drop for PduRegistrationBarrier {+ fn drop(&mut self) {+ self.fail_deferred("reconnect generation ended before mux client registration completed");+ }+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+#[repr(u8)]+pub enum ClientConnectionPhase {+ Connecting = 0,+ Registering = 1,+ Syncing = 2,+ Ready = 3,+ Reconnecting = 4,+ Suspended = 5,+ Detached = 6,+}++impl ClientConnectionPhase {+ fn from_u8(value: u8) -> Self {+ match value {+ 0 => Self::Connecting,+ 1 => Self::Registering,+ 2 => Self::Syncing,+ 3 => Self::Ready,+ 4 => Self::Reconnecting,+ 5 => Self::Suspended,+ _ => Self::Detached,+ }+ }+}+#[derive(Clone)]pub struct Client {sender: Sender<ReaderMessage>,@@ -67,16 +178,10 @@ pub struct Client {client_domain_config: ClientDomainConfig,pub is_reconnectable: bool,pub is_local: bool,- /// True from the moment the transport dies until a reconnect succeeds- /// (or retries are suspended). Pane-level tardiness only trips after- /// something is SENT on the pane, so it misses idle disconnects; this- /// is the authoritative connection-health signal for GUI indicators.- is_reconnecting: Arc<AtomicBool>,- /// True once automatic reconnection has failed continuously for the- /// give-up window: the retry loop is parked (nothing is torn down)- /// until resume_reconnect() is called, e.g. from a GUI Reconnect- /// button.- reconnect_suspended: Arc<AtomicBool>,+ /// Authoritative lifecycle of the current transport generation. A socket+ /// becoming writable is not Ready: the mux identity and topology must be+ /// restored first.+ connection_phase: Arc<AtomicU8>,resume_reconnect_tx: std::sync::mpsc::Sender<()>,remote_server_id: Arc<RwLock<Option<String>>>,/// Process-unique identity of the currently attached transport. A@@ -86,12 +191,26 @@ pub struct Client {}impl Client {+ pub fn connection_phase(&self) -> ClientConnectionPhase {+ ClientConnectionPhase::from_u8(self.connection_phase.load(Ordering::Acquire))+ }++ fn set_connection_phase(&self, phase: ClientConnectionPhase) {+ self.connection_phase.store(phase as u8, Ordering::Release);+ crate::domain::wake_thinkterm_frontend();+ }+pub fn is_reconnecting(&self) -> bool {- self.is_reconnecting.load(Ordering::Relaxed)+ matches!(+ self.connection_phase(),+ ClientConnectionPhase::Registering+ | ClientConnectionPhase::Syncing+ | ClientConnectionPhase::Reconnecting+ )}pub fn reconnect_is_suspended(&self) -> bool {- self.reconnect_suspended.load(Ordering::Relaxed)+ self.connection_phase() == ClientConnectionPhase::Suspended}/// Wake a parked reconnect loop for another round of retries.@@ -106,6 +225,29 @@ impl Client {pub fn connection_generation(&self) -> u64 {self.connection_generation.load(Ordering::Acquire)}++ pub(crate) fn mark_ready(&self) {+ self.set_connection_phase(ClientConnectionPhase::Ready);+ }++ fn mark_registration_complete(&self) -> anyhow::Result<()> {+ let connection_generation = self.connection_generation();+ self.sender+ .try_send(ReaderMessage::RegistrationComplete {+ connection_generation,+ })+ .map_err(|_| ChannelSendError)+ .context("marking mux client registration complete")?;+ self.set_connection_phase(ClientConnectionPhase::Syncing);+ Ok(())+ }++ pub(crate) fn abort_connection_generation(&self, connection_generation: u64, reason: String) {+ let _ = self.sender.try_send(ReaderMessage::AbortGeneration {+ connection_generation,+ reason,+ });+ }}#[derive(Error, Debug, Clone, PartialEq, Eq)]@@ -160,9 +302,15 @@ macro_rules! rpc {};}-fn process_unilateral_inner(pane_id: PaneId, local_domain_id: DomainId, decoded: DecodedPdu) {+fn process_unilateral_inner(+ pane_id: PaneId,+ local_domain_id: DomainId,+ connection_generation: u64,+ decoded: DecodedPdu,+) {promise::spawn::spawn(async move {- process_unilateral_inner_async(pane_id, local_domain_id, decoded).await?;+ process_unilateral_inner_async(pane_id, local_domain_id, connection_generation, decoded)+ .await?;Ok::<(), anyhow::Error>(())}).detach();@@ -171,6 +319,7 @@ fn process_unilateral_inner(pane_id: PaneId, local_domain_id: DomainId, decoded:async fn process_unilateral_inner_async(pane_id: PaneId,local_domain_id: DomainId,+ connection_generation: u64,decoded: DecodedPdu,) -> anyhow::Result<()> {let mux = match Mux::try_get() {@@ -187,6 +336,9 @@ async fn process_unilateral_inner_async(let client_domain = client_domain.downcast_ref::<ClientDomain>().ok_or_else(|| anyhow!("domain {} is not a ClientDomain instance", local_domain_id))?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }// If we get a push for a pane that we don't yet know about,// it means that some other client has manipulated the mux@@ -196,6 +348,9 @@ async fn process_unilateral_inner_async(None => {log::debug!("got {decoded:?}, pane not found locally, resync");client_domain.resync().await?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }client_domain.remote_to_local_pane_id(pane_id).ok_or_else(|| {@@ -209,6 +364,9 @@ async fn process_unilateral_inner_async(None => {log::debug!("got {decoded:?}, but local pane {local_pane_id} no longer exists; resync");client_domain.resync().await?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }let local_pane_id =client_domain@@ -274,6 +432,9 @@ fn process_unilateral(.ok_or_else(|| {anyhow!("domain {} is not a ClientDomain instance", local_domain_id)})?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }let local_window_id = client_domain.remote_to_local_window_id(window_id)@@ -302,6 +463,9 @@ fn process_unilateral(.ok_or_else(|| {anyhow!("domain {} is not a ClientDomain instance", local_domain_id)})?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }client_domain.process_remote_window_title_change(window_id, title);anyhow::Result::<()>::Ok(())@@ -317,6 +481,15 @@ fn process_unilateral(let new_workspace = new_workspace.to_string();promise::spawn::spawn_into_main_thread(async move {let mux = Mux::try_get().ok_or_else(|| anyhow!("no more mux"))?;+ let domain = mux+ .get_domain(local_domain_id)+ .ok_or_else(|| anyhow!("no such domain {}", local_domain_id))?;+ let domain = domain.downcast_ref::<ClientDomain>().ok_or_else(|| {+ anyhow!("domain {} is not a ClientDomain instance", local_domain_id)+ })?;+ if domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }log::debug!("got a rename {old_workspace} -> {new_workspace}");mux.rename_workspace(&old_workspace, &new_workspace);anyhow::Result::<()>::Ok(())@@ -338,6 +511,9 @@ fn process_unilateral(.ok_or_else(|| {anyhow!("domain {} is not a ClientDomain instance", local_domain_id)})?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }client_domain.process_remote_tab_title_change(tab_id, title);anyhow::Result::<()>::Ok(())@@ -357,6 +533,12 @@ fn process_unilateral(let domain = mux.get_domain(local_domain_id).ok_or_else(|| anyhow!("no such domain {}", local_domain_id))?;+ let domain = domain+ .downcast_ref::<ClientDomain>()+ .ok_or_else(|| anyhow!("domain {} is not a ClientDomain", local_domain_id))?;+ if domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }crate::domain::deliver_thinkterm_tree(domain.domain_name(), state.tree);anyhow::Result::<()>::Ok(())})@@ -372,6 +554,12 @@ fn process_unilateral(let domain = mux.get_domain(local_domain_id).ok_or_else(|| anyhow!("no such domain {}", local_domain_id))?;+ let domain = domain+ .downcast_ref::<ClientDomain>()+ .ok_or_else(|| anyhow!("domain {} is not a ClientDomain", local_domain_id))?;+ if domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }crate::domain::deliver_thinkterm_session(domain.domain_name(),connection_generation,@@ -403,6 +591,27 @@ fn process_unilateral(.detach();return Ok(());}+ Pdu::FrontendAccessState(_) => {+ let Pdu::FrontendAccessState(state) = decoded.pdu else {+ unreachable!("matched FrontendAccessState above");+ };+ promise::spawn::spawn_into_main_thread(async move {+ let mux = Mux::try_get().ok_or_else(|| anyhow!("no more mux"))?;+ let domain = mux+ .get_domain(local_domain_id)+ .ok_or_else(|| anyhow!("no such domain {}", local_domain_id))?;+ let domain = domain+ .downcast_ref::<ClientDomain>()+ .ok_or_else(|| anyhow!("domain {} is not a ClientDomain", local_domain_id))?;+ if domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }+ domain.process_remote_access_state(state);+ anyhow::Result::<()>::Ok(())+ })+ .detach();+ return Ok(());+ }Pdu::TabResized(_) | Pdu::TabAddedToWindow(_) => {log::trace!("resync due to {:?}", decoded.pdu);promise::spawn::spawn_into_main_thread(async move {@@ -416,6 +625,9 @@ fn process_unilateral(.ok_or_else(|| {anyhow!("domain {} is not a ClientDomain instance", local_domain_id)})?;+ if client_domain.connection_generation() != Some(connection_generation) {+ return Ok(());+ }client_domain.resync().await})@@ -428,7 +640,7 @@ fn process_unilateral(if let Some(pane_id) = decoded.pdu.pane_id() {promise::spawn::spawn_into_main_thread(async move {- process_unilateral_inner(pane_id, local_domain_id, decoded)+ process_unilateral_inner(pane_id, local_domain_id, connection_generation, decoded)}).detach();} else {@@ -464,6 +676,8 @@ async fn client_thread_async(rx: &mut Receiver<ReaderMessage>,) -> anyhow::Result<()> {let mut next_serial = 1u64;+ let mut registration = PduRegistrationBarrier::new();+ let mut deferred_unilateral = VecDeque::<DecodedPdu>::new();struct Promises {map: HashMap<u64, Sender<anyhow::Result<Pdu>>>,@@ -507,7 +721,16 @@ async fn client_thread_async(};match smol::future::or(smol::future::or(rx_msg, wait_for_read), keepalive).await {- Ok(ReaderMessage::SendPdu { pdu, promise }) => {+ Ok(ReaderMessage::SendPdu {+ pdu,+ promise,+ registration_required,+ }) => {+ let Some((pdu, promise)) =+ registration.submit((pdu, promise), registration_required)+ else {+ continue;+ };let serial = next_serial;next_serial += 1;promises.map.insert(serial, promise);@@ -517,6 +740,48 @@ async fn client_thread_async(.context("encoding a PDU to send to the server")?;stream.flush().await.context("flushing PDU to server")?;}+ Ok(ReaderMessage::RegistrationComplete {+ connection_generation: completed_generation,+ }) => {+ if completed_generation != connection_generation {+ log::debug!(+ "ignoring registration completion for generation {completed_generation}; \+ current generation is {connection_generation}"+ );+ continue;+ }+ while let Some(decoded) = deferred_unilateral.pop_front() {+ process_unilateral(local_domain_id, connection_generation, decoded)+ .context("processing unilateral PDU buffered during registration")?;+ }+ for (pdu, promise) in registration.complete() {+ let serial = next_serial;+ next_serial += 1;+ promises.map.insert(serial, promise);+ pdu.encode_async(&mut stream, serial)+ .await+ .context("encoding a deferred PDU after client registration")?;+ }+ stream+ .flush()+ .await+ .context("flushing deferred PDUs after client registration")?;+ }+ Ok(ReaderMessage::AbortGeneration {+ connection_generation: aborted_generation,+ reason,+ }) => {+ if aborted_generation != connection_generation {+ log::debug!(+ "ignoring abort for generation {aborted_generation}; \+ current generation is {connection_generation}: {reason}"+ );+ continue;+ }+ promises.fail_all(&reason);+ registration.fail_deferred(&reason);+ anyhow::bail!("reattach failed for generation {connection_generation}: {reason}");+ }Ok(ReaderMessage::KeepaliveTick) => {if let Some((serial, sent)) = pending_ping.take() {let reason = format!(@@ -548,12 +813,16 @@ async fn client_thread_async(if pending_ping.map_or(false, |(serial, _)| serial == decoded.serial) {pending_ping = None;} else if decoded.serial == 0 {- process_unilateral(local_domain_id, connection_generation, decoded)- .context("processing unilateral PDU from server")- .map_err(|e| {- log::error!("process_unilateral: {:?}", e);- e- })?;+ if registration.is_complete() {+ process_unilateral(local_domain_id, connection_generation, decoded)+ .context("processing unilateral PDU from server")+ .map_err(|e| {+ log::error!("process_unilateral: {:?}", e);+ e+ })?;+ } else {+ deferred_unilateral.push_back(decoded);+ }} else if let Some(promise) = promises.map.remove(&decoded.serial) {if promise.try_send(Ok(decoded.pdu)).is_err() {return Err(NotReconnectableError::ClientWasDestroyed.into());@@ -1209,10 +1478,8 @@ impl Client {let is_local = reconnectable.is_local();let (sender, mut receiver) = unbounded();let client_id = ClientId::new();- let is_reconnecting = Arc::new(AtomicBool::new(false));- let reconnecting_flag = Arc::clone(&is_reconnecting);- let reconnect_suspended = Arc::new(AtomicBool::new(false));- let suspended_flag = Arc::clone(&reconnect_suspended);+ let connection_phase = Arc::new(AtomicU8::new(ClientConnectionPhase::Registering as u8));+ let reader_connection_phase = Arc::clone(&connection_phase);let (resume_reconnect_tx, resume_reconnect_rx) = channel::<()>();let remote_server_id = Arc::new(RwLock::new(None));let connection_generation = Arc::new(AtomicU64::new(0));@@ -1242,10 +1509,44 @@ impl Client {// that moves it off screen rebuilds it where the user is now.let mut windowed_ui: Option<(ConnectionUI, String)> = None;+ let mut pending_reattach_ui: Option<ConnectionUI> = None;'client: loop {let session_started = std::time::Instant::now();let generation = NEXT_CONNECTION_GENERATION.fetch_add(1, Ordering::AcqRel);reader_connection_generation.store(generation, Ordering::Release);+ if let (Some(reattach_ui), Some(local_domain_id)) =+ (pending_reattach_ui.take(), local_domain_id)+ {+ let phase = Arc::clone(&reader_connection_phase);+ promise::spawn::spawn_into_main_thread(async move {+ match ClientDomain::reattach(+ local_domain_id,+ generation,+ reattach_ui.clone(),+ )+ .await+ {+ Ok(()) => {+ phase.store(ClientConnectionPhase::Ready as u8, Ordering::Release);+ log::info!("Reconnected and restored generation {generation}");+ reattach_ui.close();+ crate::domain::wake_thinkterm_frontend();+ }+ Err(err) => {+ log::error!("reattach failed for generation {generation}: {err:#}");+ if let Ok(inner) =+ ClientDomain::get_client_inner_for_domain(local_domain_id)+ {+ inner.client.abort_connection_generation(+ generation,+ format!("{err:#}"),+ );+ }+ }+ }+ })+ .detach();+ }if let Err(e) = client_thread(&mut reconnectable,local_domain_id,@@ -1274,7 +1575,9 @@ impl Client {break;}- reconnecting_flag.store(true, Ordering::Relaxed);+ reader_connection_phase+ .store(ClientConnectionPhase::Reconnecting as u8, Ordering::Release);+ crate::domain::wake_thinkterm_frontend();if session_started.elapsed() >= SHORT_SESSION {// The previous connection genuinely worked; restart@@ -1404,15 +1707,12 @@ impl Client {let no_auto_start = short_sessions < 2;match reconnectable.connect(initial, &mut ui, no_auto_start) {Ok(_) => {- log::error!("Reconnected!");- reconnecting_flag.store(false, Ordering::Relaxed);- let reattach_ui = ui.clone();- promise::spawn::spawn_into_main_thread(async move {- ClientDomain::reattach(local_domain_id, reattach_ui)- .await- .ok();- })- .detach();+ log::info!("Transport reconnected; restoring mux session");+ reader_connection_phase.store(+ ClientConnectionPhase::Registering as u8,+ Ordering::Release,+ );+ pending_reattach_ui = Some(ui.clone());crate::domain::wake_thinkterm_frontend();break;}@@ -1430,12 +1730,17 @@ impl Client {if let Some((ui, _)) = windowed_ui.take() {ui.close();}- reconnecting_flag.store(false, Ordering::Relaxed);- suspended_flag.store(true, Ordering::Relaxed);+ reader_connection_phase.store(+ ClientConnectionPhase::Suspended as u8,+ Ordering::Release,+ );+ crate::domain::wake_thinkterm_frontend();match resume_reconnect_rx.recv() {Ok(()) => {- suspended_flag.store(false, Ordering::Relaxed);- reconnecting_flag.store(true, Ordering::Relaxed);+ reader_connection_phase.store(+ ClientConnectionPhase::Reconnecting as u8,+ Ordering::Release,+ );outage_started = std::time::Instant::now();backoff = BASE_INTERVAL;short_sessions = 0;@@ -1462,8 +1767,7 @@ impl Client {// Whatever ended the loop (cancelled by user, not// reconnectable), don't leave the reconnect tab behind. The// domain detaches below, so we are no longer "reconnecting".- reconnecting_flag.store(false, Ordering::Relaxed);- suspended_flag.store(false, Ordering::Relaxed);+ reader_connection_phase.store(ClientConnectionPhase::Detached as u8, Ordering::Release);if let Some((ui, _)) = windowed_ui.take() {ui.close();}@@ -1498,8 +1802,7 @@ impl Client {is_local,client_id,client_domain_config,- is_reconnecting,- reconnect_suspended,+ connection_phase,resume_reconnect_tx,remote_server_id,connection_generation,@@ -1515,28 +1818,37 @@ impl Client {ui: &ConnectionUI,) -> anyhow::Result<GetCodecVersionResponse> {match self- .get_codec_version(GetCodecVersion {})+ .send_bootstrap_pdu(Pdu::GetCodecVersion(GetCodecVersion {})).or(async {smol::Timer::after(Duration::from_secs(60)).await;Err(Timeout).context("Timeout")}).await{- Ok(info) if info.codec_vers == CODEC_VERSION => {+ Ok(Pdu::GetCodecVersionResponse(info)) if info.codec_vers == CODEC_VERSION => {log::trace!("Server version is {} (codec version {})",info.version_string,info.codec_vers);- self.set_client_id(SetClientId {- client_id: self.client_id.clone(),- is_proxy: false,- })- .await?;+ match self+ .send_bootstrap_pdu(Pdu::SetClientId(SetClientId {+ client_id: self.client_id.clone(),+ is_proxy: false,+ }))+ .await?+ {+ Pdu::UnitResponse(_) => {}+ Pdu::ErrorResponse(err) => anyhow::bail!(err.reason),+ response => anyhow::bail!(+ "unexpected SetClientId response during bootstrap: {response:?}"+ ),+ }*self.remote_server_id.write().unwrap() = Some(info.server_id.clone());+ self.mark_registration_complete()?;Ok(info)}- Ok(info) => {+ Ok(Pdu::GetCodecVersionResponse(info)) => {let err = IncompatibleVersionError {version: info.version_string,codec_vers: info.codec_vers,@@ -1545,6 +1857,10 @@ impl Client {log::error!("{:?}", err);return Err(err.into());}+ Ok(Pdu::ErrorResponse(err)) => anyhow::bail!(err.reason),+ Ok(response) => {+ anyhow::bail!("unexpected GetCodecVersion response during bootstrap: {response:?}")+ }Err(err) => {log::trace!("{:?}", err);let msg = if err.root_cause().is::<Timeout>() {@@ -1668,10 +1984,27 @@ impl Client {}pub async fn send_pdu(&self, pdu: Pdu) -> anyhow::Result<Pdu> {+ self.send_pdu_with_registration_requirement(pdu, true).await+ }++ async fn send_bootstrap_pdu(&self, pdu: Pdu) -> anyhow::Result<Pdu> {+ self.send_pdu_with_registration_requirement(pdu, false)+ .await+ }++ async fn send_pdu_with_registration_requirement(+ &self,+ pdu: Pdu,+ registration_required: bool,+ ) -> anyhow::Result<Pdu> {log::trace!("send_pdu {}", pdu.pdu_name());let (promise, rx) = bounded(1);self.sender- .send(ReaderMessage::SendPdu { pdu, promise })+ .send(ReaderMessage::SendPdu {+ pdu,+ promise,+ registration_required,+ }).await.map_err(|_| ChannelSendError).context("send_pdu send")?;@@ -1744,6 +2077,11 @@ impl Client {ClaimClientViewport,ClientViewportState);+ rpc!(+ set_frontend_access_mode,+ SetFrontendAccessMode,+ FrontendAccessState+ );rpc!(write_to_pane, WriteToPane, UnitResponse);rpc!(send_paste, SendPaste, UnitResponse);rpc!(key_down, SendKeyDown, UnitResponse);@@ -1790,7 +2128,24 @@ impl Client {#[cfg(test)]mod tests {- use super::Reconnectable;+ use super::{Reconnectable, RegistrationBarrier};++ #[test]+ fn registration_barrier_sends_bootstrap_before_deferred_rpcs() {+ let mut barrier = RegistrationBarrier::new();+ assert_eq!(barrier.submit("palette", true), None);+ assert_eq!(barrier.submit("viewport", true), None);+ assert_eq!(+ barrier.submit("GetCodecVersion", false),+ Some("GetCodecVersion")+ );+ assert_eq!(barrier.submit("SetClientId", false), Some("SetClientId"));+ assert_eq!(+ barrier.complete().into_iter().collect::<Vec<_>>(),+ vec!["palette", "viewport"]+ );+ assert_eq!(barrier.submit("focus", true), Some("focus"));+ }#[test]fn remote_mux_command_uses_configured_path() {diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rsindex 751f9d09..caf5cb1d 100644--- a/wezterm-client/src/domain.rs+++ b/wezterm-client/src/domain.rs@@ -1,4 +1,4 @@-use crate::client::Client;+use crate::client::{Client, ClientConnectionPhase};use crate::pane::ClientPane;use anyhow::{anyhow, bail, Context};use async_trait::async_trait;@@ -17,6 +17,125 @@ use std::collections::{HashMap, HashSet};use std::sync::{Arc, Mutex};use wezterm_term::TerminalSize;+fn accepts_generation(prior: Option<u64>, incoming: u64) -> bool {+ prior.is_none_or(|prior| incoming > prior)+}++fn remote_owner_matches_client(+ owner: Option<&mux::client::ClientId>,+ client_id: &mux::client::ClientId,+) -> bool {+ owner.is_some_and(|owner| owner.same_logical_client(client_id))+}++fn owns_remote_viewport_from_states(+ client_id: &mux::client::ClientId,+ access: Option<&codec::FrontendAccessState>,+ viewport: Option<&codec::ClientViewportState>,+) -> Option<bool> {+ let access = access?;+ match access.mode {+ // Handoff is connection-wide. A claim made while another tab is+ // active does not publish a fresh viewport snapshot for every tab, so+ // consulting `viewport.access` here can leave those tabs believing an+ // old owner indefinitely.+ codec::FrontendAccessMode::Handoff => Some(remote_owner_matches_client(+ access.owner.as_ref(),+ client_id,+ )),+ // Collaborative mode deliberately keeps one layout owner per tab.+ codec::FrontendAccessMode::TmuxLatest => {+ viewport.map(|state| remote_owner_matches_client(state.owner.as_ref(), client_id))+ }+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum RemoteFrontendGate {+ Visible,+ Claimable {+ owner: Option<mux::client::ClientId>,+ },+ Connecting,+ Reconnecting,+ Offline,+ Syncing,+}++impl RemoteFrontendGate {+ pub fn obscures_terminal(&self) -> bool {+ !matches!(self, Self::Visible)+ }++ pub fn is_claimable(&self) -> bool {+ matches!(self, Self::Claimable { .. })+ }++ pub fn overlay_message(&self) -> Option<(String, String)> {+ match self {+ Self::Visible => None,+ Self::Claimable { owner: Some(owner) } => {+ let hostname = owner.hostname.trim();+ let title = if hostname.is_empty() {+ "Terminal is being used on another device".to_string()+ } else {+ format!("Terminal is being used on {hostname}")+ };+ Some((title, "Click or scroll to continue".to_string()))+ }+ Self::Claimable { owner: None } => Some((+ "Terminal is available".to_string(),+ "Click or scroll to take control".to_string(),+ )),+ Self::Connecting => Some((+ "Connecting to terminal…".to_string(),+ "Please wait".to_string(),+ )),+ Self::Reconnecting => Some((+ "Connection lost — Reconnecting…".to_string(),+ "Terminal will resume automatically".to_string(),+ )),+ Self::Offline => Some((+ "Connection offline".to_string(),+ "Reconnect from the sidebar".to_string(),+ )),+ Self::Syncing => Some((+ "Restoring terminal state…".to_string(),+ "Please wait".to_string(),+ )),+ }+ }+}++fn remote_frontend_gate_from_state(+ phase: ClientConnectionPhase,+ access: Option<&codec::FrontendAccessState>,+ client_id: &mux::client::ClientId,+) -> RemoteFrontendGate {+ match phase {+ ClientConnectionPhase::Connecting => RemoteFrontendGate::Connecting,+ ClientConnectionPhase::Registering | ClientConnectionPhase::Reconnecting => {+ RemoteFrontendGate::Reconnecting+ }+ ClientConnectionPhase::Syncing => RemoteFrontendGate::Syncing,+ ClientConnectionPhase::Suspended | ClientConnectionPhase::Detached => {+ RemoteFrontendGate::Offline+ }+ ClientConnectionPhase::Ready => match access {+ None => RemoteFrontendGate::Syncing,+ Some(access) if access.mode == codec::FrontendAccessMode::TmuxLatest => {+ RemoteFrontendGate::Visible+ }+ Some(access) if remote_owner_matches_client(access.owner.as_ref(), client_id) => {+ RemoteFrontendGate::Visible+ }+ Some(access) => RemoteFrontendGate::Claimable {+ owner: access.owner.clone(),+ },+ },+ }+}+pub struct ClientInner {pub client: Client,pub local_domain_id: DomainId,@@ -27,6 +146,14 @@ pub struct ClientInner {remote_to_local_pane: Mutex<HashMap<PaneId, PaneId>>,/// Authoritative per-remote-tab viewport ownership pushed by the server.remote_viewports: Mutex<HashMap<TabId, codec::ClientViewportState>>,+ /// Connection-wide A/B mode and exclusive handoff owner.+ remote_access: Mutex<Option<codec::FrontendAccessState>>,+ /// 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>>,+ /// 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<()>>>>,/// Remote pane-stack id -> stable local pane-stack id. Remote and local/// stack ids live in different id spaces; translating (rather than/// adopting) avoids collisions with locally-created stacks while keeping@@ -111,6 +238,19 @@ fn remote_move_pane_id(}impl ClientInner {+ fn remote_owner_is_self(&self, owner: Option<&mux::client::ClientId>) -> bool {+ remote_owner_matches_client(owner, &self.client.client_id)+ }++ pub fn remote_frontend_gate(&self) -> RemoteFrontendGate {+ let access = self.remote_access_state();+ remote_frontend_gate_from_state(+ self.client.connection_phase(),+ access.as_ref(),+ &self.client.client_id,+ )+ }+fn remote_to_local_window(&self, remote_window_id: WindowId) -> Option<WindowId> {let map = self.remote_to_local_window.lock().unwrap();map.get(&remote_window_id).cloned()@@ -278,10 +418,10 @@ impl ClientInner {fn update_remote_viewport(&self, state: codec::ClientViewportState) -> bool {let mut states = self.remote_viewports.lock().unwrap();- if states- .get(&state.tab_id)- .is_some_and(|prior| prior.generation > state.generation)- {+ if !accepts_generation(+ states.get(&state.tab_id).map(|prior| prior.generation),+ state.generation,+ ) {return false;}states.insert(state.tab_id, state);@@ -300,12 +440,132 @@ impl ClientInner {}pub fn owns_remote_viewport(&self, remote_tab_id: TabId) -> Option<bool> {- let state = self.remote_viewport_state(remote_tab_id)?;- Some(state.owner.as_ref() == Some(&self.client.client_id))+ let access = self.remote_access_state();+ let viewport = self.remote_viewport_state(remote_tab_id);+ owns_remote_viewport_from_states(&self.client.client_id, access.as_ref(), viewport.as_ref())}- fn clear_remote_viewports(&self) {+ /// Drop connection-scoped state before registering a new transport+ /// generation. Keep the latest locally-rendered geometry: replaying it+ /// after SetClientId is how the new live session obtains authoritative+ /// access/owner state without claiming ownership or waiting for an+ /// incidental GUI resize.+ fn begin_remote_generation(&self) {self.remote_viewports.lock().unwrap().clear();+ *self.remote_access.lock().unwrap() = None;+ self.frontend_claim_locks.lock().unwrap().clear();+ }++ fn reported_viewports_for_live_tabs(&self) -> Vec<(TabId, codec::ClientViewport)> {+ let live_tabs: HashSet<TabId> = self+ .remote_to_local_tab+ .lock()+ .unwrap()+ .keys()+ .copied()+ .collect();+ let mut reported = self.reported_viewports.lock().unwrap();+ reported.retain(|tab_id, _| live_tabs.contains(tab_id));+ reported+ .iter()+ .map(|(tab_id, viewport)| (*tab_id, viewport.clone()))+ .collect()+ }++ fn update_remote_access(&self, state: codec::FrontendAccessState) -> bool {+ let mut prior = self.remote_access.lock().unwrap();+ if !accepts_generation(+ prior.as_ref().map(|prior| prior.generation),+ state.generation,+ ) {+ return false;+ }+ *prior = Some(state);+ true+ }++ pub fn remote_access_state(&self) -> Option<codec::FrontendAccessState> {+ self.remote_access.lock().unwrap().clone()+ }++ pub fn has_remote_access(&self) -> Option<bool> {+ let state = self.remote_access_state()?;+ Some(match state.mode {+ codec::FrontendAccessMode::TmuxLatest => true,+ codec::FrontendAccessMode::Handoff => self.remote_owner_is_self(state.owner.as_ref()),+ })+ }++ fn remember_reported_viewport(&self, tab_id: TabId, viewport: codec::ClientViewport) {+ self.reported_viewports+ .lock()+ .unwrap()+ .insert(tab_id, viewport);+ }++ fn claim_lock(&self, tab_id: TabId) -> Arc<futures::lock::Mutex<()>> {+ self.frontend_claim_locks+ .lock()+ .unwrap()+ .entry(tab_id)+ .or_insert_with(|| Arc::new(futures::lock::Mutex::new(())))+ .clone()+ }++ /// Return false only for B's opaque non-owner state. In A, serialize an+ /// atomic claim before forwarding the terminal input.+ pub(crate) async fn prepare_remote_tab_input(+ &self,+ remote_tab_id: TabId,+ ) -> anyhow::Result<bool> {+ if self.remote_frontend_gate().obscures_terminal() {+ return Ok(false);+ }+ let Some(access) = self.remote_access_state() else {+ return Ok(false);+ };+ match access.mode {+ codec::FrontendAccessMode::Handoff => {+ return Ok(self.remote_owner_is_self(access.owner.as_ref()));+ }+ codec::FrontendAccessMode::TmuxLatest => {}+ }+ if self+ .remote_viewport_state(remote_tab_id)+ .is_some_and(|state| self.remote_owner_is_self(state.owner.as_ref()))+ {+ return Ok(true);+ }+ let lock = self.claim_lock(remote_tab_id);+ let _guard = lock.lock().await;+ if self+ .remote_viewport_state(remote_tab_id)+ .is_some_and(|state| self.remote_owner_is_self(state.owner.as_ref()))+ {+ return Ok(true);+ }+ let viewport = self+ .reported_viewports+ .lock()+ .unwrap()+ .get(&remote_tab_id)+ .cloned()+ .ok_or_else(|| anyhow!("viewport for remote tab {remote_tab_id} is not ready"))?;+ let state = self+ .client+ .claim_client_viewport(codec::ClaimClientViewport {+ tab_id: remote_tab_id,+ viewport,+ })+ .await?;+ let owns = self.remote_owner_is_self(state.owner.as_ref());+ self.update_remote_access(state.access.clone());+ self.update_remote_viewport(state);+ Ok(owns)+ }++ pub(crate) fn remote_tab_input_is_blocked(&self) -> bool {+ self.remote_frontend_gate().obscures_terminal()}pub fn is_local(&self) -> bool {@@ -384,6 +644,9 @@ impl ClientInner {remote_to_local_tab: Mutex::new(HashMap::new()),remote_to_local_pane: Mutex::new(HashMap::new()),remote_viewports: Mutex::new(HashMap::new()),+ remote_access: Mutex::new(None),+ reported_viewports: 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),@@ -761,10 +1024,47 @@ impl ClientDomain {inner.owns_remote_viewport(remote_tab_id)}+ pub fn remote_access_state(&self) -> Option<codec::FrontendAccessState> {+ self.inner()?.remote_access_state()+ }++ pub fn has_remote_access(&self) -> Option<bool> {+ self.inner()?.has_remote_access()+ }++ pub fn remote_frontend_gate(&self) -> RemoteFrontendGate {+ if self.is_attaching() {+ return RemoteFrontendGate::Connecting;+ }+ self.inner()+ .map(|inner| inner.remote_frontend_gate())+ .unwrap_or(RemoteFrontendGate::Offline)+ }++ pub fn process_remote_access_state(&self, state: codec::FrontendAccessState) {+ let Some(inner) = self.inner() else {+ return;+ };+ if !inner.update_remote_access(state.clone()) {+ return;+ }+ Mux::get().notify(MuxNotification::FrontendAccessChanged(+ mux::FrontendAccessState {+ mode: match state.mode {+ codec::FrontendAccessMode::TmuxLatest => mux::FrontendAccessMode::TmuxLatest,+ codec::FrontendAccessMode::Handoff => mux::FrontendAccessMode::Handoff,+ },+ owner: state.owner,+ generation: state.generation,+ },+ ));+ }+pub fn process_remote_viewport_state(&self, state: codec::ClientViewportState) {let Some(inner) = self.inner() else {return;};+ self.process_remote_access_state(state.access.clone());if !inner.update_remote_viewport(state.clone()) {return;}@@ -782,6 +1082,16 @@ impl ClientDomain {.collect(),}),generation: state.generation,+ access: mux::FrontendAccessState {+ mode: match state.access.mode {+ codec::FrontendAccessMode::TmuxLatest => {+ mux::FrontendAccessMode::TmuxLatest+ }+ codec::FrontendAccessMode::Handoff => mux::FrontendAccessMode::Handoff,+ },+ owner: state.access.owner,+ generation: state.access.generation,+ },},));}@@ -811,10 +1121,25 @@ impl ClientDomain {////// This is the funnel every automatic reconnect passes through, so it has/// to do everything a first attach does and not only re-pull the panes.- pub async fn reattach(domain_id: DomainId, ui: ConnectionUI) -> anyhow::Result<()> {+ pub async fn reattach(+ domain_id: DomainId,+ connection_generation: u64,+ ui: ConnectionUI,+ ) -> anyhow::Result<()> {let inner = Self::get_client_inner_for_domain(domain_id)?;- inner.clear_remote_viewports();- let domain = Mux::get().get_domain(domain_id);+ if inner.client.connection_generation() != connection_generation {+ bail!("generation {connection_generation} was superseded before reattach began");+ }+ 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?;+ if inner.client.connection_generation() != connection_generation {+ bail!("generation {connection_generation} was superseded during registration");+ }// A reconnect begins a new connection generation. The revision// baseline, any old connection-scoped presentation overlay, and the@@ -824,30 +1149,55 @@ impl ClientDomain {// overtakes it, is measured against this connection; a push that beats// the announcement is at worst dropped as stale and put right by that// same fetch.- if let Some(domain) = &domain {- deliver_thinkterm_connected(domain.domain_name(), inner.client.connection_generation());- }+ deliver_thinkterm_connected(domain.domain_name(), connection_generation);let panes = inner.client.list_panes().await?;- Self::process_pane_list(inner, panes, None, true)?;+ 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. Remote edits are rejected- // while reconnecting; there is deliberately no client queue to flush.- if let Some(client) = domain- .as_ref()- .and_then(|domain| domain.downcast_ref::<ClientDomain>())+ // whatever it held when the link dropped. Ordinary RPCs remain behind+ // the registration barrier until SetClientId has been acknowledged.+ let client = domain+ .downcast_ref::<ClientDomain>()+ .ok_or_else(|| anyhow!("domain {domain_id} changed type during reattach"))?;++ // SetClientId deliberately does not restore ownership. Re-advertise+ // the exact geometry this frontend rendered before the outage so the+ // server can return current access state for the new live session.+ // SetClientViewport is non-claiming: if another device took over while+ // we were offline, it remains the owner.+ for (remote_tab_id, viewport) in inner.reported_viewports_for_live_tabs() {+ let state = inner+ .client+ .set_client_viewport(codec::SetClientViewport {+ tab_id: remote_tab_id,+ viewport,+ })+ .await+ .with_context(|| {+ format!("restoring viewport and access state for remote tab {remote_tab_id}")+ })?;+ client.process_remote_viewport_state(state);+ }+ if !inner.remote_to_local_tab.lock().unwrap().is_empty()+ && inner.remote_access_state().is_none(){- if let Err(err) = client.fetch_thinkterm_tree().await {- log::warn!(- "failed to fetch the ThinkTerm tree after reconnecting to {}: {err:#}",- client.config.name()- );- }+ bail!(+ "the reconnected mux session did not return frontend access state; \+ refusing to mark generation {connection_generation} ready"+ );}- ui.close();+ 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(())}@@ -944,19 +1294,11 @@ impl ClientDomain {Ok(response)}- /// Report the viewport for a locally mirrored tab to the frontend mux.- pub async fn set_client_viewport(+ fn translate_client_viewport(&self,- local_tab_id: TabId,viewport: codec::ClientViewport,- ) -> anyhow::Result<codec::ClientViewportState> {- let inner = self- .inner()- .ok_or_else(|| anyhow!("domain is not attached"))?;- let remote_tab_id = inner- .local_to_remote_tab(local_tab_id)- .ok_or_else(|| anyhow!("tab {local_tab_id} has no remote mapping"))?;- let viewport = match viewport {+ ) -> anyhow::Result<codec::ClientViewport> {+ Ok(match viewport {codec::ClientViewport::CellGrid { size } => codec::ClientViewport::CellGrid { size },codec::ClientViewport::Native { size, panes } => {let mut remote_panes = Vec::with_capacity(panes.len());@@ -981,7 +1323,23 @@ impl ClientDomain {panes: remote_panes,}}- };+ })+ }++ /// Report the viewport for a locally mirrored tab to the frontend mux.+ pub async fn set_client_viewport(+ &self,+ local_tab_id: TabId,+ viewport: codec::ClientViewport,+ ) -> anyhow::Result<codec::ClientViewportState> {+ let inner = self+ .inner()+ .ok_or_else(|| anyhow!("domain is not attached"))?;+ let remote_tab_id = inner+ .local_to_remote_tab(local_tab_id)+ .ok_or_else(|| anyhow!("tab {local_tab_id} has no remote mapping"))?;+ let viewport = self.translate_client_viewport(viewport)?;+ let reported = viewport.clone();let state = inner.client.set_client_viewport(codec::SetClientViewport {@@ -989,6 +1347,7 @@ impl ClientDomain {viewport,}).await?;+ inner.remember_reported_viewport(remote_tab_id, reported);self.process_remote_viewport_state(state.clone());Ok(state)}@@ -1020,12 +1379,12 @@ impl ClientDomain {Ok(())}- /// Claim a previously advertised viewport after a real frontend-only- /// interaction (for example, dragging a split). The server chooses the- /// owner and geometry and returns the authoritative result.+ /// Atomically claim the current access/layout lease and install the exact+ /// geometry used for the interaction.pub async fn claim_client_viewport(&self,local_tab_id: TabId,+ viewport: codec::ClientViewport,) -> anyhow::Result<codec::ClientViewportState> {let inner = self.inner()@@ -1033,16 +1392,47 @@ impl ClientDomain {let remote_tab_id = inner.local_to_remote_tab(local_tab_id).ok_or_else(|| anyhow!("tab {local_tab_id} has no remote mapping"))?;+ let viewport = self.translate_client_viewport(viewport)?;+ let reported = viewport.clone();let state = inner.client.claim_client_viewport(codec::ClaimClientViewport {tab_id: remote_tab_id,+ viewport,}).await?;+ inner.remember_reported_viewport(remote_tab_id, reported);self.process_remote_viewport_state(state.clone());Ok(state)}+ pub async fn set_frontend_access_mode(+ &self,+ local_tab_id: TabId,+ mode: codec::FrontendAccessMode,+ viewport: codec::ClientViewport,+ ) -> anyhow::Result<codec::FrontendAccessState> {+ let inner = self+ .inner()+ .ok_or_else(|| anyhow!("domain is not attached"))?;+ let remote_tab_id = inner+ .local_to_remote_tab(local_tab_id)+ .ok_or_else(|| anyhow!("tab {local_tab_id} has no remote mapping"))?;+ let viewport = self.translate_client_viewport(viewport)?;+ let reported = viewport.clone();+ let state = inner+ .client+ .set_frontend_access_mode(codec::SetFrontendAccessMode {+ mode,+ tab_id: remote_tab_id,+ viewport,+ })+ .await?;+ inner.remember_reported_viewport(remote_tab_id, reported);+ self.process_remote_access_state(state.clone());+ Ok(state)+ }+pub fn process_remote_window_title_change(&self, remote_window_id: WindowId, title: String) {if let Some(inner) = self.inner() {if let Some(local_window_id) = inner.remote_to_local_window(remote_window_id) {@@ -1389,7 +1779,187 @@ impl ClientDomain {#[cfg(test)]mod tests {- use super::remote_move_pane_id;+ use super::{+ accepts_generation, owns_remote_viewport_from_states, remote_frontend_gate_from_state,+ remote_move_pane_id, RemoteFrontendGate,+ };+ use crate::client::ClientConnectionPhase;++ fn client_id(hostname: &str, id: usize) -> mux::client::ClientId {+ mux::client::ClientId {+ hostname: hostname.to_string(),+ username: "test-user".to_string(),+ pid: 42,+ epoch: 123,+ id,+ ssh_auth_sock: None,+ }+ }++ fn access(+ mode: codec::FrontendAccessMode,+ owner: Option<mux::client::ClientId>,+ generation: u64,+ ) -> codec::FrontendAccessState {+ codec::FrontendAccessState {+ mode,+ owner,+ generation,+ }+ }++ fn viewport(+ tab_id: mux::tab::TabId,+ owner: Option<mux::client::ClientId>,+ access: codec::FrontendAccessState,+ ) -> codec::ClientViewportState {+ codec::ClientViewportState {+ tab_id,+ owner,+ canonical_size: wezterm_term::TerminalSize {+ rows: 24,+ cols: 80,+ pixel_width: 0,+ pixel_height: 0,+ dpi: 96,+ },+ view: None,+ generation: 1,+ access,+ }+ }++ #[test]+ fn equal_or_older_frontend_generations_are_ignored() {+ assert!(accepts_generation(None, 0));+ assert!(accepts_generation(Some(9), 10));+ assert!(!accepts_generation(Some(9), 9));+ assert!(!accepts_generation(Some(9), 8));+ }++ #[test]+ fn handoff_ownership_uses_latest_connection_state_across_tabs() {+ let mac = client_id("mac", 1);+ let vm = client_id("vm", 2);+ let stale_tab = viewport(+ 7,+ Some(mac.clone()),+ access(codec::FrontendAccessMode::Handoff, Some(mac.clone()), 1),+ );++ // The VM claimed globally while another tab was active. This tab's+ // viewport snapshot is stale, but it must immediately become blocked.+ let vm_owns = access(codec::FrontendAccessMode::Handoff, Some(vm.clone()), 2);+ assert_eq!(+ owns_remote_viewport_from_states(&mac, Some(&vm_owns), Some(&stale_tab)),+ Some(false)+ );++ // After the Mac claims its currently selected tab, it must immediately+ // use its full local size even before that tab receives another lease+ // publication.+ let mac_owns = access(codec::FrontendAccessMode::Handoff, Some(mac.clone()), 3);+ assert_eq!(+ owns_remote_viewport_from_states(&mac, Some(&mac_owns), Some(&stale_tab)),+ Some(true)+ );+ assert_eq!(+ owns_remote_viewport_from_states(&mac, Some(&mac_owns), None),+ Some(true)+ );+ }++ #[test]+ fn collaborative_ownership_remains_per_tab() {+ let mac = client_id("mac", 1);+ let vm = client_id("vm", 2);+ let shared = access(codec::FrontendAccessMode::TmuxLatest, Some(vm.clone()), 4);+ let mac_tab = viewport(7, Some(mac.clone()), shared.clone());+ let vm_tab = viewport(8, Some(vm), shared.clone());++ assert_eq!(+ owns_remote_viewport_from_states(&mac, Some(&shared), Some(&mac_tab)),+ Some(true)+ );+ assert_eq!(+ owns_remote_viewport_from_states(&mac, Some(&shared), Some(&vm_tab)),+ Some(false)+ );+ }++ #[test]+ fn frontend_gate_separates_connection_health_from_handoff_ownership() {+ let mac = client_id("mac", 1);+ let vm = client_id("vm", 2);+ let mac_owns = access(codec::FrontendAccessMode::Handoff, Some(mac.clone()), 1);+ let vm_owns = access(codec::FrontendAccessMode::Handoff, Some(vm.clone()), 2);+ let unowned = access(codec::FrontendAccessMode::Handoff, None, 3);+ let shared = access(codec::FrontendAccessMode::TmuxLatest, Some(vm), 4);++ assert_eq!(+ remote_frontend_gate_from_state(ClientConnectionPhase::Ready, Some(&mac_owns), &mac,),+ RemoteFrontendGate::Visible+ );+ assert_eq!(+ remote_frontend_gate_from_state(ClientConnectionPhase::Ready, Some(&vm_owns), &mac,),+ RemoteFrontendGate::Claimable {+ owner: vm_owns.owner.clone(),+ }+ );+ assert_eq!(+ remote_frontend_gate_from_state(ClientConnectionPhase::Ready, Some(&unowned), &mac,),+ RemoteFrontendGate::Claimable { owner: None }+ );+ assert_eq!(+ remote_frontend_gate_from_state(ClientConnectionPhase::Ready, Some(&shared), &mac,),+ RemoteFrontendGate::Visible+ );+ assert_eq!(+ remote_frontend_gate_from_state(ClientConnectionPhase::Ready, None, &mac),+ RemoteFrontendGate::Syncing+ );++ for (phase, expected) in [+ (+ ClientConnectionPhase::Connecting,+ RemoteFrontendGate::Connecting,+ ),+ (+ ClientConnectionPhase::Registering,+ RemoteFrontendGate::Reconnecting,+ ),+ (+ ClientConnectionPhase::Reconnecting,+ RemoteFrontendGate::Reconnecting,+ ),+ (ClientConnectionPhase::Syncing, RemoteFrontendGate::Syncing),+ (+ ClientConnectionPhase::Suspended,+ RemoteFrontendGate::Offline,+ ),+ (ClientConnectionPhase::Detached, RemoteFrontendGate::Offline),+ ] {+ assert_eq!(+ remote_frontend_gate_from_state(phase, Some(&vm_owns), &mac),+ expected+ );+ }++ assert_eq!(+ RemoteFrontendGate::Reconnecting.overlay_message(),+ Some((+ "Connection lost — Reconnecting…".to_string(),+ "Terminal will resume automatically".to_string(),+ ))+ );+ assert_eq!(+ RemoteFrontendGate::Claimable { owner: None }.overlay_message(),+ Some((+ "Terminal is available".to_string(),+ "Click or scroll to take control".to_string(),+ ))+ );+ }#[test]fn remote_move_uses_the_remote_source_id() {@@ -1456,6 +2026,10 @@ impl Domain for ClientDomain {.downcast_ref::<ClientPane>().ok_or_else(|| anyhow!("pane_id {} is not a ClientPane", base_pane_id))?;+ if !inner.prepare_remote_tab_input(pane.remote_tab_id()).await? {+ bail!("terminal is being operated on another device");+ }+let result = inner.client.spawn_pane_in_stack(codec::SpawnPaneInStack {@@ -1540,6 +2114,10 @@ impl Domain for ClientDomain {);}+ if !inner.prepare_remote_tab_input(target_remote_tab_id).await? {+ bail!("terminal is being operated on another device");+ }+// This feature is restricted to one top-level tab. Apply the// already-validated move locally before the network round-trip so// dropping the drag preview does not reveal the old layout for one@@ -1585,6 +2163,10 @@ impl Domain for ClientDomain {.downcast_ref::<ClientPane>().ok_or_else(|| anyhow!("pane_id {} is not a ClientPane", pane_id))?;+ if !inner.prepare_remote_tab_input(pane.remote_tab_id()).await? {+ bail!("terminal is being operated on another device");+ }+let remote_window_id =window_id.and_then(|local_window| self.local_to_remote_window_id(local_window));@@ -1704,6 +2286,10 @@ impl Domain for ClientDomain {let target_remote_pane_id = pane.remote_pane_id();let target_remote_tab_id = pane.remote_tab_id();+ if !inner.prepare_remote_tab_input(target_remote_tab_id).await? {+ bail!("terminal is being operated on another device");+ }+let (command, command_dir, move_pane_id, moved_local_pane, source_tab_id) = match source {SplitSource::Spawn {command,@@ -1996,6 +2582,10 @@ impl ClientDomain {);}+ if let Some(inner) = self.inner() {+ inner.client.mark_ready();+ }+ui.output_str("Attached!\n");drop(activity);ui.close();diff --git a/wezterm-client/src/pane/clientpane.rs b/wezterm-client/src/pane/clientpane.rsindex b8419bd4..27e456f7 100644--- a/wezterm-client/src/pane/clientpane.rs+++ b/wezterm-client/src/pane/clientpane.rs@@ -179,7 +179,7 @@ pub struct ClientPane {client: Arc<ClientInner>,local_pane_id: PaneId,pub remote_pane_id: PaneId,- remote_tab_id: AtomicUsize,+ remote_tab_id: Arc<AtomicUsize>,pub renderable: Mutex<RenderableState>,configured_palette: Arc<Mutex<ColorPalette>>,/// Delivery state for the palette advisory: what we want the server to@@ -307,14 +307,17 @@ impl ClientPane {alt_screen: bool,) -> Self {let local_pane_id = alloc_pane_id();+ let remote_tab_id = Arc::new(AtomicUsize::new(remote_tab_id));let writer = PaneWriter {client: Arc::clone(client),remote_pane_id,+ remote_tab_id: Arc::clone(&remote_tab_id),};let mouse = Arc::new(Mutex::new(MouseState::new(remote_pane_id,- client.client.clone(),+ Arc::clone(client),+ Arc::clone(&remote_tab_id),)));let fetch_limiter =@@ -364,7 +367,7 @@ impl ClientPane {mouse,remote_pane_id,local_pane_id,- remote_tab_id: AtomicUsize::new(remote_tab_id),+ remote_tab_id,application_palette: Mutex::new(false),renderable: Mutex::new(render),writer: Mutex::new(writer),@@ -542,6 +545,18 @@ impl ClientPane {self.client.owns_remote_viewport(self.remote_tab_id())}+ pub fn remote_access_state(&self) -> Option<codec::FrontendAccessState> {+ self.client.remote_access_state()+ }++ pub fn has_remote_access(&self) -> Option<bool> {+ self.client.has_remote_access()+ }++ pub fn remote_frontend_gate(&self) -> crate::domain::RemoteFrontendGate {+ self.client.remote_frontend_gate()+ }+pub(crate) fn set_remote_tab_id(&self, remote_tab_id: TabId) {self.remote_tab_id.store(remote_tab_id, Ordering::Relaxed);}@@ -555,17 +570,27 @@ impl ClientPane {/// this, the next resync would flip the local stack back to the server's/// stale active pane.pub fn activate_in_stack_on_server(&self) {+ if self.client.remote_tab_input_is_blocked() {+ return;+ }let client = Arc::clone(&self.client);let remote_pane_id = self.remote_pane_id;+ let remote_tab_id = self.remote_tab_id();promise::spawn::spawn(async move {- if let Err(err) = client- .client- .activate_pane_in_stack(codec::ActivatePaneInStack {- pane_id: remote_pane_id,- })- .await- {- log::error!("remote stack activation failed: {err:#}");+ match client.prepare_remote_tab_input(remote_tab_id).await {+ Ok(true) => {+ if let Err(err) = client+ .client+ .activate_pane_in_stack(codec::ActivatePaneInStack {+ pane_id: remote_pane_id,+ })+ .await+ {+ log::error!("remote stack activation failed: {err:#}");+ }+ }+ Ok(false) => {}+ Err(err) => log::error!("remote stack activation claim failed: {err:#}"),}}).detach();@@ -581,10 +606,53 @@ impl ClientPane {*self.ignore_next_kill.lock() = true;}+ /// Adopt geometry that is carried by a complete frontend viewport RPC.+ ///+ /// The GUI has already computed the tab root and every split pane from a+ /// single layout pass. Updating the local render surface here makes that+ /// geometry visible atomically with the viewport request, while recording+ /// the requested size prevents the normal `Pane::resize` path from+ /// following up with a duplicate per-pane Resize RPC.+ pub fn adopt_frontend_geometry(&self, size: TerminalSize) -> bool {+ *self.requested_size.lock() = Some(size);+ let render = self.renderable.lock();+ let mut inner = render.inner.borrow_mut();+ let changed = inner.apply_local_resize(size);+ if changed {+ inner.update_last_send();+ }+ changed+ }++ /// Forget a geometry adoption when the complete viewport RPC failed.+ /// A later authoritative resync can then establish the server's actual+ /// dimensions instead of having the failed request remain a dedupe key.+ pub fn forget_frontend_geometry(&self, size: TerminalSize) {+ let mut requested = self.requested_size.lock();+ if requested.as_ref() == Some(&size) {+ requested.take();+ }+ }++ /// Prime and verify the remote render snapshot for an optimistically+ /// adopted frontend size. GUI takeover uses this while its opaque mask is+ /// still present, so a full-screen application cannot expose its old grid+ /// or incremental redraw after the ownership RPC completes.+ pub fn prime_frontend_geometry(&self, size: TerminalSize) -> bool {+ self.renderable.lock().prime_frontend_geometry(size)+ }+/// End the remote pane and wait for the mux server to acknowledge it./// Destructive compound workflows use this instead of `Pane::kill`, whose/// fire-and-forget task can lose a race with detaching the last window.pub async fn kill_remote_and_wait(&self) -> anyhow::Result<()> {+ if !self+ .client+ .prepare_remote_tab_input(self.remote_tab_id())+ .await?+ {+ anyhow::bail!("terminal is being operated on another device");+ }self.client.client.kill_pane(KillPane {@@ -673,9 +741,13 @@ impl Pane for ClientPane {}fn send_paste(&self, text: &str) -> anyhow::Result<()> {+ if self.client.remote_tab_input_is_blocked() {+ return Ok(());+ }Mux::get().record_input_for_current_identity();let client = Arc::clone(&self.client);let remote_pane_id = self.remote_pane_id;+ let remote_tab_id = self.remote_tab_id();self.renderable.lock().inner@@ -684,13 +756,16 @@ impl Pane for ClientPane {let data = text.to_owned();promise::spawn::spawn(async move {- client- .client- .send_paste(SendPaste {- pane_id: remote_pane_id,- data,- })- .await+ if client.prepare_remote_tab_input(remote_tab_id).await? {+ client+ .client+ .send_paste(SendPaste {+ pane_id: remote_pane_id,+ data,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())}).detach();self.renderable.lock().inner.borrow_mut().update_last_send();@@ -709,6 +784,9 @@ impl Pane for ClientPane {}fn set_zoomed(&self, zoomed: bool) {+ if self.client.remote_tab_input_is_blocked() {+ return;+ }let render = self.renderable.lock();let mut inner = render.inner.borrow_mut();let client = Arc::clone(&self.client);@@ -717,14 +795,17 @@ impl Pane for ClientPane {// Invalidate any cached rows on a resizeinner.make_all_stale();promise::spawn::spawn(async move {- client- .client- .set_zoomed(SetPaneZoomed {- containing_tab_id: remote_tab_id,- pane_id: remote_pane_id,- zoomed,- })- .await+ if client.prepare_remote_tab_input(remote_tab_id).await? {+ client+ .client+ .set_zoomed(SetPaneZoomed {+ containing_tab_id: remote_tab_id,+ pane_id: remote_pane_id,+ zoomed,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())}).detach();inner.update_last_send();@@ -816,6 +897,9 @@ impl Pane for ClientPane {}fn key_down(&self, key: KeyCode, mods: KeyModifiers) -> anyhow::Result<()> {+ if self.client.remote_tab_input_is_blocked() {+ return Ok(());+ }Mux::get().record_input_for_current_identity();let input_serial;{@@ -827,18 +911,22 @@ impl Pane for ClientPane {}let client = Arc::clone(&self.client);let remote_pane_id = self.remote_pane_id;+ let remote_tab_id = self.remote_tab_id();promise::spawn::spawn(async move {- client- .client- .key_down(SendKeyDown {- pane_id: remote_pane_id,- event: KeyEvent {- key,- modifiers: mods,- },- input_serial,- })- .await+ if client.prepare_remote_tab_input(remote_tab_id).await? {+ client+ .client+ .key_down(SendKeyDown {+ pane_id: remote_pane_id,+ event: KeyEvent {+ key,+ modifiers: mods,+ },+ input_serial,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())}).detach();self.renderable.lock().inner.borrow_mut().update_last_send();@@ -856,8 +944,12 @@ impl Pane for ClientPane {*ignore = false;return;}+ if self.client.remote_tab_input_is_blocked() {+ return;+ }let client = Arc::clone(&self.client);let remote_pane_id = self.remote_pane_id;+ let remote_tab_id = self.remote_tab_id();let local_domain_id = self.client.local_domain_id;// We only want to ask the server to kill the pane if the user@@ -879,18 +971,24 @@ impl Pane for ClientPane {if send_kill {promise::spawn::spawn(async move {- client- .client- .kill_pane(KillPane {- pane_id: remote_pane_id,- })- .await+ if client.prepare_remote_tab_input(remote_tab_id).await? {+ client+ .client+ .kill_pane(KillPane {+ pane_id: remote_pane_id,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())}).detach();}}fn mouse_event(&self, event: MouseEvent) -> anyhow::Result<()> {+ if self.client.remote_tab_input_is_blocked() {+ return Ok(());+ }Mux::get().record_input_for_current_identity();self.mouse.lock().append(event);if MouseState::next(Arc::clone(&self.mouse)) {@@ -943,21 +1041,31 @@ impl Pane for ClientPane {}fn erase_scrollback(&self, erase_mode: ScrollbackEraseMode) {+ if self.client.remote_tab_input_is_blocked() {+ return;+ }let client = Arc::clone(&self.client);let remote_pane_id = self.remote_pane_id;+ let remote_tab_id = self.remote_tab_id();promise::spawn::spawn(async move {- client- .client- .erase_scrollback(EraseScrollbackRequest {- pane_id: remote_pane_id,- erase_mode,- })- .await+ if client.prepare_remote_tab_input(remote_tab_id).await? {+ client+ .client+ .erase_scrollback(EraseScrollbackRequest {+ pane_id: remote_pane_id,+ erase_mode,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())}).detach();}fn advise_focus(&self) {+ if self.client.remote_tab_input_is_blocked() {+ return;+ }let mut focused_pane = self.client.focused_remote_pane_id.lock().unwrap();if *focused_pane != Some(self.remote_pane_id) {focused_pane.replace(self.remote_pane_id);@@ -1045,14 +1153,28 @@ impl Pane for ClientPane {struct PaneWriter {client: Arc<ClientInner>,remote_pane_id: TabId,+ remote_tab_id: Arc<AtomicUsize>,}impl std::io::Write for PaneWriter {fn write(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {- promise::spawn::block_on(self.client.client.write_to_pane(WriteToPane {- pane_id: self.remote_pane_id,- data: data.to_vec(),- }))+ if self.client.remote_tab_input_is_blocked() {+ return Ok(data.len());+ }+ let remote_tab_id = self.remote_tab_id.load(Ordering::Relaxed);+ let payload = data.to_vec();+ promise::spawn::block_on(async {+ if self.client.prepare_remote_tab_input(remote_tab_id).await? {+ self.client+ .client+ .write_to_pane(WriteToPane {+ pane_id: self.remote_pane_id,+ data: payload,+ })+ .await?;+ }+ Ok::<(), anyhow::Error>(())+ }).map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("{}", e)))?;Ok(data.len())}diff --git a/wezterm-client/src/pane/mousestate.rs b/wezterm-client/src/pane/mousestate.rsindex f190bb89..147d6655 100644--- a/wezterm-client/src/pane/mousestate.rs+++ b/wezterm-client/src/pane/mousestate.rs@@ -1,24 +1,30 @@-use crate::client::Client;+use crate::domain::ClientInner;use codec::*;use mux::tab::TabId;use parking_lot::Mutex;use std::collections::VecDeque;-use std::sync::atomic::{AtomicBool, Ordering};+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};use std::sync::Arc;use wezterm_term::{MouseButton, MouseEvent, MouseEventKind};pub struct MouseState {pending: AtomicBool,queue: VecDeque<MouseEvent>,- client: Client,+ client: Arc<ClientInner>,remote_pane_id: TabId,+ remote_tab_id: Arc<AtomicUsize>,}impl MouseState {- pub fn new(remote_pane_id: TabId, client: Client) -> Self {+ pub fn new(+ remote_pane_id: TabId,+ client: Arc<ClientInner>,+ remote_tab_id: Arc<AtomicUsize>,+ ) -> Self {Self {remote_pane_id,client,+ remote_tab_id,pending: AtomicBool::new(false),queue: VecDeque::new(),}@@ -92,15 +98,23 @@ impl MouseState {let state = Arc::clone(&state);mouse.pending.store(true, Ordering::SeqCst);let remote_pane_id = mouse.remote_pane_id;+ let remote_tab_id = mouse.remote_tab_id.load(Ordering::Relaxed);promise::spawn::spawn(async move {- client- .mouse_event(SendMouseEvent {- pane_id: remote_pane_id,- event,- })+ if client+ .prepare_remote_tab_input(remote_tab_id).await- .ok();+ .unwrap_or(false)+ {+ client+ .client+ .mouse_event(SendMouseEvent {+ pane_id: remote_pane_id,+ event,+ })+ .await+ .ok();+ }let mouse = state.lock();mouse.pending.store(false, Ordering::SeqCst);diff --git a/wezterm-client/src/pane/renderable.rs b/wezterm-client/src/pane/renderable.rsindex 91a4744e..6757c877 100644--- a/wezterm-client/src/pane/renderable.rs+++ b/wezterm-client/src/pane/renderable.rs@@ -87,6 +87,17 @@ fn render_geometry_changed(current: RenderableDimensions, next: RenderableDimens|| current.dpi != next.dpi}+fn render_dimensions_match_terminal_size(+ dimensions: RenderableDimensions,+ size: wezterm_term::TerminalSize,+) -> bool {+ dimensions.cols == size.cols+ && dimensions.viewport_rows == size.rows+ && dimensions.pixel_width == size.pixel_width+ && dimensions.pixel_height == size.pixel_height+ && dimensions.dpi == size.dpi+}+fn fetch_token_is_current(token: FetchToken, epoch: u64) -> bool {token.epoch == epoch}@@ -102,6 +113,11 @@ pub struct RenderableInner {cursor_position: StableCursorPosition,pub dimensions: RenderableDimensions,+ /// The dimensions most recently confirmed by the remote pane. A GUI+ /// takeover may resize its local surface optimistically; keeping the+ /// server value separate lets it remain masked until a post-resize render+ /// snapshot has actually arrived.+ server_dimensions: RenderableDimensions,lines: LruCache<StableRowIndex, LineEntry>,line_cache_epoch: u64,@@ -144,6 +160,7 @@ impl RenderableInner {poll_interval: BASE_POLL_INTERVAL,cursor_position: StableCursorPosition::default(),dimensions,+ server_dimensions: dimensions,lines: LruCache::new(NonZeroUsize::new(configuration().scrollback_lines.max(128)).unwrap(),),@@ -389,6 +406,7 @@ impl RenderableInner {{self.cursor_position = delta.cursor_position;}+ self.server_dimensions = delta.dimensions;if render_geometry_changed(self.dimensions, delta.dimensions) {let preserve_lines = self.dimensions.cols == delta.dimensions.cols;self.dimensions = delta.dimensions;@@ -949,6 +967,34 @@ impl RenderableState {pub fn get_dimensions(&self) -> RenderableDimensions {self.inner.borrow().dimensions}++ /// Drive a render poll and populate every currently visible line while a+ /// takeover overlay is still opaque. Returns true only after the server+ /// has confirmed `size` and none of those rows is stale or in flight.+ pub(crate) fn prime_frontend_geometry(&self, size: wezterm_term::TerminalSize) -> bool {+ let mut visible = {+ let mut inner = self.inner.borrow_mut();+ let now = Instant::now();+ inner.poll_interval = BASE_POLL_INTERVAL;+ inner.last_poll = now.checked_sub(BASE_POLL_INTERVAL).unwrap_or(now);+ if let Err(err) = inner.poll() {+ log::trace!("polling takeover geometry: {err:#}");+ }+ let top = inner.dimensions.physical_top;+ top..top.saturating_add(size.rows as StableRowIndex)+ };++ // This both returns any retained rows and schedules missing/stale+ // rows. Fetch completion emits PaneOutput and drives another overlay+ // frame, where the readiness check below can finally pass.+ let _ = self.get_lines(visible.clone());++ let mut inner = self.inner.borrow_mut();+ if !render_dimensions_match_terminal_size(inner.server_dimensions, size) {+ return false;+ }+ visible.all(|row| matches!(inner.lines.get(&row), Some(LineEntry::Line(_))))+ }}#[cfg(test)]@@ -1020,6 +1066,30 @@ mod test {assert!(render_geometry_changed(current, new_dpi));}+ #[test]+ fn server_geometry_confirmation_requires_the_complete_terminal_size() {+ let expected = wezterm_term::TerminalSize {+ rows: 40,+ cols: 120,+ pixel_width: 1200,+ pixel_height: 800,+ dpi: 144,+ };+ let confirmed = dimensions(120, 40, 144);+ assert!(render_dimensions_match_terminal_size(confirmed, expected));++ let mut stale_rows = confirmed;+ stale_rows.viewport_rows = 24;+ assert!(!render_dimensions_match_terminal_size(stale_rows, expected));++ let mut stale_pixels = confirmed;+ stale_pixels.pixel_height = 768;+ assert!(!render_dimensions_match_terminal_size(+ stale_pixels,+ expected+ ));+ }+#[test]fn fetch_token_from_prior_epoch_is_not_current() {let token = FetchToken {diff --git a/wezterm-gui/src/frontend.rs b/wezterm-gui/src/frontend.rsindex 06d47d8e..12163efd 100644--- a/wezterm-gui/src/frontend.rs+++ b/wezterm-gui/src/frontend.rs@@ -132,6 +132,7 @@ impl GuiFrontEnd {MuxNotification::ThinkTermTreeChanged => {}MuxNotification::ThinkTermSessionChanged => {}MuxNotification::FrontendLeaseChanged(_) => {}+ MuxNotification::FrontendAccessChanged(_) => {}MuxNotification::TabAddedToWindow { .. } => {}MuxNotification::PaneRemoved(_) => {}MuxNotification::WindowInvalidated(_) => {}diff --git a/wezterm-gui/src/spawn.rs b/wezterm-gui/src/spawn.rsindex 03553284..74eae091 100644--- a/wezterm-gui/src/spawn.rs+++ b/wezterm-gui/src/spawn.rs@@ -43,6 +43,7 @@ pub fn spawn_command_impl(action(tw);}if let Some(reason) = layout_mutation_reason {+ tw.sync_active_tab_geometry_now();tw.persist_workspace_layout_after_mutation(reason);}},diff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rsindex 22e36b3e..8ad52a8e 100644--- a/wezterm-gui/src/termwindow/mod.rs+++ b/wezterm-gui/src/termwindow/mod.rs@@ -350,6 +350,7 @@ pub(crate) enum NoteEditorCommand {#[derive(Clone, Debug)]pub(crate) enum ContextMenuApplicationAction {Note(NoteEditorCommand),+ SetFrontendAccessMode(codec::FrontendAccessMode),/// Notification bell entry: jump to a thread, switching Space first when/// it lives elsewhere, and acknowledge its unseen work.ActivateWorkspaceThread {@@ -1269,6 +1270,38 @@ enum EventState {InProgressWithQueued(Option<PaneId>),}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum FrontendGeometryPhase {+ Previewing { epoch: u64 },+ Committing { epoch: u64 },+ TakeoverSyncing { epoch: u64 },+}++impl FrontendGeometryPhase {+ pub(crate) fn epoch(self) -> u64 {+ match self {+ Self::Previewing { epoch }+ | Self::Committing { epoch }+ | Self::TakeoverSyncing { epoch } => epoch,+ }+ }++ pub(crate) fn obscures_terminal(self) -> bool {+ matches!(self, Self::TakeoverSyncing { .. })+ }++ pub(crate) fn is_in_flight(self) -> bool {+ matches!(self, Self::Committing { .. } | Self::TakeoverSyncing { .. })+ }+}++#[derive(Debug, Clone)]+pub(crate) struct FrontendGeometryConfirmation {+ pub(crate) epoch: u64,+ pub(crate) panes: Vec<(PaneId, TerminalSize)>,+ pub(crate) ready_since: Option<Instant>,+}+pub struct TermWindow {pub window: Option<Window>,pub config: ConfigHandle,@@ -1285,6 +1318,20 @@ pub struct TermWindow {pending_scale_changes: LinkedList<resize::ScaleChange>,/// Terminal dimensionsterminal_size: TerminalSize,+ /// Per-tab preview and submission state. Current-owner geometry commits+ /// remain visible; only a real takeover or unknown initial owner obscures+ /// the terminal until the matching epoch is acknowledged.+ frontend_geometry_phases: HashMap<TabId, FrontendGeometryPhase>,+ /// A takeover RPC acknowledges PTY resize before the remote application+ /// 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>,+ frontend_geometry_resync_after_epoch: HashSet<TabId>,+ next_frontend_geometry_epoch: u64,+ frontend_viewport_report_pending: Arc<AtomicBool>,+ /// A blocked press is consumed even if the takeover round-trip completes+ /// before its matching release arrives.+ frontend_handoff_consumed_press: bool,pub mux_window_id: MuxWindowId,pub mux_window_id_for_subscriptions: Arc<Mutex<MuxWindowId>>,pub render_metrics: RenderMetrics,@@ -2020,6 +2067,12 @@ impl TermWindow {crate::workspace_threads::space_note_vault(&active_space_id).is_some();let myself = Self {+ frontend_geometry_phases: HashMap::new(),+ frontend_geometry_confirmations: HashMap::new(),+ frontend_geometry_resync_after_epoch: HashSet::new(),+ next_frontend_geometry_epoch: 1,+ frontend_viewport_report_pending: Arc::new(AtomicBool::new(false)),+ frontend_handoff_consumed_press: false,created: Instant::now(),connection_name,last_fps_check_time: Instant::now(),@@ -2406,6 +2459,14 @@ impl TermWindow {myself.sync_current_workspace_thread();}myself.maybe_show_onboarding();+ // The mux window can predate this native window, so no+ // TabAddedToWindow notification is guaranteed after the GUI has+ // subscribed. Converge the already-active tab before the first+ // visible frame; an unknown remote owner enters the opaque+ // takeover epoch here rather than exposing its saved/TUI grid.+ if !myself.content_view_foreground() {+ myself.resize_mux_tabs_to_current_terminal_size();+ }window.show();myself.subscribe_to_pane_updates();myself.emit_window_event("window-config-reloaded", None);@@ -2915,47 +2976,55 @@ impl TermWindow {tab_id,} => {let mux = Mux::get();- let mut size = self.terminal_size;if let Some(tab) = mux.get_tab(tab_id) {- // If we attached to a remote domain and loaded in- // a tab async, we need to fixup its size, either- // by resizing it or resizes ourselves.- // The strategy here is to adjust both by taking- // the maximal size in both horizontal and vertical- // dimensions and applying that. In practice that- // means that a new local client will resize larger- // to adjust to the size of an existing client.- let tab_size = tab.get_size();- size.rows = size.rows.max(tab_size.rows);- size.cols = size.cols.max(tab_size.cols);-- if size.rows != self.terminal_size.rows- || size.cols != self.terminal_size.cols- || size.pixel_width != self.terminal_size.pixel_width- || size.pixel_height != self.terminal_size.pixel_height- {- self.set_window_size(size, window)?;- } else if tab_size != self.terminal_size {- // A tab that arrived via a mux resync carries the- // server's size (its pane dims, which sit below the- // window size by the pane nav bar reservation).- // The window geometry is authoritative locally:- // impose it so that the first activation doesn't- // subtract the nav bar from an already-reduced- // size. Tab::resize no-ops when sizes agree.- tab.resize(self.terminal_size);+ let is_remote_thinkterm_tab = tab.get_active_pane().is_some_and(|pane| {+ pane.downcast_ref::<wezterm_client::pane::ClientPane>()+ .is_some()+ }) && mux+ .get_window(self.mux_window_id)+ .is_some_and(|mux_window| {+ let workspace = mux_window.get_workspace();+ crate::workspace_threads::is_thread_workspace_name(workspace)+ || crate::workspace_threads::workspace_has_thread_binding(+ workspace,+ )+ });++ if is_remote_thinkterm_tab {+ // Bind this notification to its own tab. A+ // background remote tab keeps the server's+ // canonical geometry; only the tab currently being+ // drawn is converged to this GUI.+ if mux+ .get_active_tab_for_window(self.mux_window_id)+ .is_some_and(|active| active.tab_id() == tab_id)+ {+ self.stage_workspace_thread_font_scales();+ self.sync_active_tab_geometry_now();+ }+ } else {+ // Preserve upstream behavior for ordinary WezTerm+ // domains. ThinkTerm thread tabs deliberately do+ // not enlarge the OS window to a remote renderer's+ // historical rows/cols.+ let mut size = self.terminal_size;+ let tab_size = tab.get_size();+ size.rows = size.rows.max(tab_size.rows);+ size.cols = size.cols.max(tab_size.cols);++ if size.rows != self.terminal_size.rows+ || size.cols != self.terminal_size.cols+ || size.pixel_width != self.terminal_size.pixel_width+ || size.pixel_height != self.terminal_size.pixel_height+ {+ self.set_window_size(size, window)?;+ } else if tab_size != self.terminal_size {+ tab.resize(self.terminal_size);+ }+ self.stage_workspace_thread_font_scales();+ self.force_sync_active_mux_tab_pane_sizes();}}- // Tabs arriving via a mux resync (switch-back re-fold,- // reattach) get their persisted per-pane font scales- // re-applied; the adopt-time application ran before- // these panes existed.- self.stage_workspace_thread_font_scales();- // Remote panes are skipped by Tab::resize. A tab can arrive- // while the connection content view suppresses paint-time- // pane sync, so impose the final font-scaled GUI geometry- // exactly once.- self.force_sync_active_mux_tab_pane_sizes();self.persist_workspace_layout_after_mutation("tab added");}MuxNotification::PaneOutput(pane_id) => {@@ -2990,6 +3059,13 @@ impl TermWindow {window.invalidate();}}+ MuxNotification::FrontendAccessChanged(_) => {+ if self.owns_frontend_viewport() {+ self.resize_mux_tabs_to_current_terminal_size();+ }+ self.update_title_post_status();+ window.invalidate();+ }MuxNotification::PaneFocused(pane_id) => {// Also handled by clientpaneself.refresh_thread_work_for_pane(pane_id);@@ -3098,6 +3174,7 @@ impl TermWindow {// Space-switch reflow can settle now since there is no other// window to protect from the resize.self.consume_pending_sidebar_reflow();+ self.sync_active_tab_geometry_now();return;}@@ -3431,6 +3508,10 @@ impl TermWindow {return true;}}+ MuxNotification::FrontendAccessChanged(_) => {+ // Connection-wide: every window may need to replace terminal+ // contents with (or remove) the opaque handoff surface.+ }MuxNotification::Alert {alert: Alert::ToastNotification { .. },..@@ -4722,21 +4803,46 @@ impl TermWindow {}};- if let Some(state) = Mux::get()- .get_active_tab_for_window(self.mux_window_id)- .and_then(|tab| tab.get_active_pane())- .and_then(|pane| {- pane.downcast_ref::<wezterm_client::pane::ClientPane>()- .and_then(|pane| {- pane.remote_viewport_state()- .filter(|_| pane.owns_remote_viewport() == Some(false))- })- })- {- title.push_str(&format!(- " · VIEW {}×{} · input to take control",- state.canonical_size.cols, state.canonical_size.rows- ));+ if let Some(access) = self.active_frontend_access_state() {+ match access.mode {+ mux::FrontendAccessMode::TmuxLatest => {+ title.push_str(" · A SHARED");+ if let Some(state) = self+ .active_remote_frontend_viewport_state()+ .filter(|_| !self.owns_frontend_viewport())+ {+ title.push_str(&format!(+ " · VIEW {}×{}",+ state.canonical_size.cols, state.canonical_size.rows+ ));+ }+ }+ mux::FrontendAccessMode::Handoff => match self.frontend_terminal_gate() {+ wezterm_client::domain::RemoteFrontendGate::Visible => {+ title.push_str(" · B ACTIVE");+ }+ wezterm_client::domain::RemoteFrontendGate::Claimable { owner } => {+ let owner = owner+ .as_ref()+ .map(|owner| owner.hostname.as_str())+ .filter(|hostname| !hostname.trim().is_empty())+ .unwrap_or("available");+ title.push_str(&format!(" · B VIEW on {owner} · click to continue"));+ }+ wezterm_client::domain::RemoteFrontendGate::Connecting => {+ title.push_str(" · CONNECTING");+ }+ wezterm_client::domain::RemoteFrontendGate::Reconnecting => {+ title.push_str(" · RECONNECTING");+ }+ wezterm_client::domain::RemoteFrontendGate::Offline => {+ title.push_str(" · OFFLINE");+ }+ wezterm_client::domain::RemoteFrontendGate::Syncing => {+ title.push_str(" · SYNCING");+ }+ },+ }}if let Some(window) = self.window.as_ref() {@@ -4871,6 +4977,10 @@ impl TermWindow {self.update_title();self.update_scrollbar();+ // A discrete top-level tab switch must converge before its first+ // paint; it is not part of the 120ms continuous-window-resize+ // debounce. This never claims a passive tab.+ self.sync_active_tab_geometry_now();self.persist_workspace_layout_after_mutation("active tab changed");}Ok(())@@ -6314,6 +6424,9 @@ impl TermWindow {}}AdjustPaneSize(direction, amount) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,@@ -6324,10 +6437,15 @@ impl TermWindow {if self.tab_state(tab_id).overlay.is_none() {tab.adjust_pane_size(*direction, *amount);+ self.preview_active_tab_geometry_now();+ self.sync_active_tab_geometry_now();self.persist_workspace_layout_after_mutation("pane size adjusted");}}ActivatePaneByIndex(index) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,@@ -6337,6 +6455,7 @@ impl TermWindow {let tab_id = tab.tab_id();if self.tab_state(tab_id).overlay.is_none() {+ self.claim_frontend_viewport_for_interaction();let panes = tab.iter_panes();if panes.iter().position(|p| p.index == *index).is_some() {tab.set_active_idx(*index);@@ -6344,6 +6463,9 @@ impl TermWindow {}}ActivatePaneDirection(direction) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,@@ -6353,24 +6475,39 @@ impl TermWindow {let tab_id = tab.tab_id();if self.tab_state(tab_id).overlay.is_none() {+ self.claim_frontend_viewport_for_interaction();tab.activate_pane_direction(*direction);}}TogglePaneZoomState => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,None => return Ok(PerformAssignmentResult::Handled),};+ self.claim_frontend_viewport_for_interaction();tab.toggle_zoom();+ // Zoom changes which panes occupy the tab root. Remote+ // mirrors are deliberately skipped by Tab::resize, so adopt+ // every resulting pane surface and publish one complete+ // viewport instead of waiting for a later window resize.+ self.sync_active_tab_geometry_now();}SetPaneZoomState(zoomed) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,None => return Ok(PerformAssignmentResult::Handled),};+ self.claim_frontend_viewport_for_interaction();tab.set_zoomed(*zoomed);+ self.sync_active_tab_geometry_now();}SwitchWorkspaceRelative(delta) => {let mux = Mux::get();@@ -6477,6 +6614,9 @@ impl TermWindow {// NOP here; handled by the overlay directly}RotatePanes(direction) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }let mux = Mux::get();let tab = match mux.get_active_tab_for_window(self.mux_window_id) {Some(tab) => tab,@@ -6486,9 +6626,14 @@ impl TermWindow {RotationDirection::Clockwise => tab.rotate_clockwise(),RotationDirection::CounterClockwise => tab.rotate_counter_clockwise(),}+ self.preview_active_tab_geometry_now();+ self.sync_active_tab_geometry_now();self.persist_workspace_layout_after_mutation("panes rotated");}SplitPane(split) => {+ if self.frontend_surface_blocked() {+ return Ok(PerformAssignmentResult::Handled);+ }log::trace!("SplitPane {:?}", split);self.restore_collapsed_panes_for_active_tab();self.spawn_command(@@ -6576,35 +6721,26 @@ impl TermWindow {}}- pub(crate) fn reapply_collapsed_panes_for_window(&mut self) {+ /// Reapply collapse state only to the tab whose geometry is being+ /// converged. Background tabs retain the server's canonical split tree+ /// until they are activated or explicitly claimed.+ pub(crate) fn reapply_collapsed_panes_for_tab(&mut self, tab_id: TabId) {if self.collapsed_pane_layouts.is_empty() {return;}- let mux = Mux::get();- let Some(window) = mux.get_window(self.mux_window_id) else {- self.collapsed_pane_layouts.clear();+ let Some(tab) = Mux::get().get_tab(tab_id) else {return;};-let min_cells = self.collapsed_pane_min_cells();let layouts: Vec<_> = self.collapsed_pane_layouts.values().copied().collect();for layout in layouts {- let mut found_stack = false;- for tab in window.iter() {- let contains_stack = tab- .iter_panes_ignoring_zoom()- .into_iter()- .any(|pane| pane.pane_stack_id == layout.pane_stack_id);- if contains_stack {- found_stack = true;- tab.reapply_collapsed_pane(layout, min_cells);- break;- }- }-- if !found_stack {- self.collapsed_pane_layouts.remove(&layout.pane_stack_id);+ let contains_stack = tab+ .iter_panes_ignoring_zoom()+ .into_iter()+ .any(|pane| pane.pane_stack_id == layout.pane_stack_id);+ if contains_stack {+ tab.reapply_collapsed_pane(layout, min_cells);}}}diff --git a/wezterm-gui/src/termwindow/mouseevent.rs b/wezterm-gui/src/termwindow/mouseevent.rsindex 55b9a4a6..db8f328f 100644--- a/wezterm-gui/src/termwindow/mouseevent.rs+++ b/wezterm-gui/src/termwindow/mouseevent.rs@@ -1221,6 +1221,53 @@ impl super::TermWindow {log::trace!("{:?}", event);let pane = self.get_active_pane_or_overlay();+ if self.frontend_handoff_consumed_press && matches!(event.kind, WMEK::Release(_)) {+ self.frontend_handoff_consumed_press = false;+ return;+ }++ // Hit-test first. Tab bar, sidebars, menus and OS chrome stay usable+ // without silently taking a terminal away from another device.+ let area = self.content_view_area();+ let point_is_in_terminal_area = !self.content_view_foreground()+ && (event.coords.x as f32) >= area.min_x()+ && (event.coords.x as f32) < area.max_x()+ && (event.coords.y as f32) >= area.min_y()+ && (event.coords.y as f32) < area.max_y();+ let terminal_ui_item = self.resolve_ui_item(&event).is_some_and(|item| {+ matches!(+ item.item_type,+ UIItemType::PaneNav { .. }+ | UIItemType::AboveScrollThumb+ | UIItemType::ScrollThumb+ | UIItemType::BelowScrollThumb+ | UIItemType::Split(_)+ )+ });+ let terminal_surface = point_is_in_terminal_area+ && (self.resolve_ui_item(&event).is_none() || terminal_ui_item);+ let takeover_gesture = matches!(+ event.kind,+ WMEK::Press(_) | WMEK::VertWheel(_) | WMEK::HorzWheel(_)+ );++ if terminal_surface && self.frontend_surface_blocked() {+ if takeover_gesture && self.frontend_takeover_claimable() {+ self.frontend_handoff_consumed_press = matches!(event.kind, WMEK::Press(_));+ self.claim_frontend_viewport_for_interaction();+ context.invalidate();+ }+ // The opaque handoff surface consumes the triggering gesture and+ // all pointer traffic while blocked; nothing leaks to the pane.+ return;+ }+ if terminal_surface && takeover_gesture {+ // In shared mode this updates the per-tab layout owner. The event+ // itself may continue; ClientPane serializes forwarded input behind+ // the same geometry-bearing claim.+ self.claim_frontend_viewport_for_interaction();+ }+self.current_mouse_event.replace(event.clone());if self.consume_context_menu_suppressed_release(&event) {@@ -1358,6 +1405,7 @@ impl super::TermWindow {.as_ref().is_some_and(|(item, _)| matches!(item.item_type, UIItemType::Split(_))){+ self.sync_active_tab_geometry_now();self.persist_workspace_layout_after_mutation("split drag released");}if completed_drag.as_ref().is_some_and(|(item, _)| {@@ -1677,6 +1725,7 @@ impl super::TermWindow {if delta != 0 {tab.resize_split_by(split.index, delta);+ self.preview_active_tab_geometry_now();if let Some(split) = tab.iter_splits().into_iter().nth(split.index) {item.item_type = UIItemType::Split(split);context.invalidate();@@ -2608,6 +2657,9 @@ impl super::TermWindow {if let Some(tab) = Mux::get().get_tab(dest_tab_id) {tab.set_active_pane(&moved);}+ if term_window.active_tab_is(dest_tab_id) {+ term_window.sync_active_tab_geometry_now();+ }if term_window.current_mux_workspace() == workspace {term_window.persist_workspace_layout_after_mutation("pane tab drop move",@@ -2687,6 +2739,9 @@ impl super::TermWindow {// pane.tab.set_active_pane(&moved);}+ if term_window.active_tab_is(dest_tab_id) {+ term_window.sync_active_tab_geometry_now();+ }if term_window.current_mux_workspace() == workspace {term_window.persist_workspace_layout_after_mutation("pane tab drop split",@@ -5973,10 +6028,12 @@ impl super::TermWindow {self.spawn_pane_nav_tab(pane_id, pane_index);}PaneNavAction::ToggleZoom => {+ self.claim_frontend_viewport_for_interaction();if let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) {tab.set_active_idx(pane_index);tab.toggle_zoom();}+ self.sync_active_tab_geometry_now();}PaneNavAction::ToggleCollapse => {if let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) {@@ -6026,6 +6083,7 @@ impl super::TermWindow {}}}+ self.sync_active_tab_geometry_now();}PaneNavAction::SplitRight | PaneNavAction::SplitDown => {if let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) {@@ -6102,6 +6160,7 @@ impl super::TermWindow {window.window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ term_window.sync_active_tab_geometry_now();term_window.update_title();if let Some(window) = term_window.window.as_ref() {window.invalidate();@@ -6515,7 +6574,7 @@ impl super::TermWindow {}}- fn terminal_context_menu_items(&self) -> Vec<ContextMenuItem> {+ fn terminal_context_menu_items(&mut self) -> Vec<ContextMenuItem> {fn split_item(label: String,icon: ContextMenuIcon,@@ -6533,7 +6592,8 @@ impl super::TermWindow {)}- vec![+ self.begin_context_menu_application_actions();+ let mut items = vec![ContextMenuItem::item_with_icon(crate::i18n::tr("menu-copy"),ContextMenuIcon::Copy,@@ -6571,7 +6631,48 @@ impl super::TermWindow {ContextMenuIcon::Refresh,KeyAssignment::ResetTerminal,),- ]+ ];+ let current_mode = self+ .active_frontend_access_state()+ .map(|state| state.mode)+ .unwrap_or(mux::FrontendAccessMode::Handoff);+ let modes = [+ (+ "A · Shared (tmux-like)",+ codec::FrontendAccessMode::TmuxLatest,+ mux::FrontendAccessMode::TmuxLatest,+ ),+ (+ "B · Handoff (exclusive)",+ codec::FrontendAccessMode::Handoff,+ mux::FrontendAccessMode::Handoff,+ ),+ ];+ let children = modes+ .iter()+ .copied()+ .map(|(label, codec_mode, mux_mode)| {+ self.context_menu_application_item_with_icon(+ label,+ if current_mode == mux_mode {+ ContextMenuIcon::Check+ } else {+ ContextMenuIcon::Terminal+ },+ crate::termwindow::ContextMenuApplicationAction::SetFrontendAccessMode(+ codec_mode,+ ),+ true,+ )+ })+ .collect();+ items.push(ContextMenuItem::Separator);+ items.push(ContextMenuItem::submenu_with_icon(+ "Frontend access",+ ContextMenuIcon::Terminal,+ children,+ ));+ items}fn right_sidebar_note_context_menu_items(@@ -7043,7 +7144,8 @@ impl super::TermWindow {&& matches!(event.kind, WMEK::Release(MousePress::Right))&& !pane.is_mouse_grabbed(){- self.show_term_context_menu(context, event.coords, self.terminal_context_menu_items());+ let items = self.terminal_context_menu_items();+ self.show_term_context_menu(context, event.coords, items);return;}diff --git a/wezterm-gui/src/termwindow/render/mod.rs b/wezterm-gui/src/termwindow/render/mod.rsindex 91745098..15ba5f1e 100644--- a/wezterm-gui/src/termwindow/render/mod.rs+++ b/wezterm-gui/src/termwindow/render/mod.rs@@ -67,6 +67,11 @@ pub struct LineQuadCacheKey {pub font_identity: u64,pub top_pixel_y: NotNan<f32>,pub left_pixel_x: NotNan<f32>,+ /// The same terminal line can be painted at a different width while a+ /// split divider is being dragged. Keep that geometry in the key so the+ /// old, wider GPU quads can never be replayed across the new divider.+ pub render_cols: usize,+ pub render_pixel_width: usize,pub phys_line_idx: usize,pub pane_id: PaneId,pub pane_is_active: bool,@@ -1022,3 +1027,37 @@ fn same_hyperlink(a: Option<&Arc<Hyperlink>>, b: Option<&Arc<Hyperlink>>) -> boo_ => false,}}++#[cfg(test)]+mod line_quad_cache_tests {+ use super::*;++ fn key(render_cols: usize, render_pixel_width: usize) -> LineQuadCacheKey {+ LineQuadCacheKey {+ config_generation: 0,+ shape_generation: 0,+ quad_generation: 0,+ composing: None,+ selection: 0..0,+ shape_hash: [0; 16],+ font_identity: 0,+ top_pixel_y: NotNan::new(0.0).unwrap(),+ left_pixel_x: NotNan::new(0.0).unwrap(),+ render_cols,+ render_pixel_width,+ phys_line_idx: 0,+ pane_id: 1,+ pane_is_active: true,+ cursor: None,+ reverse_video: false,+ password_input: false,+ }+ }++ #[test]+ fn divider_resize_cannot_reuse_line_quads_from_the_old_pane_width() {+ let wide = key(120, 1_200);+ assert_ne!(wide, key(80, 800));+ assert_ne!(wide, key(120, 1_000));+ }+}diff --git a/wezterm-gui/src/termwindow/render/paint.rs b/wezterm-gui/src/termwindow/render/paint.rsindex 5dfdf926..997dfe5a 100644--- a/wezterm-gui/src/termwindow/render/paint.rs+++ b/wezterm-gui/src/termwindow/render/paint.rs@@ -17,6 +17,163 @@ pub enum AllowImage {}impl crate::TermWindow {+ fn paint_frontend_handoff_overlay(+ &mut self,+ layers: &mut TripleLayerQuadAllocator<'_>,+ ) -> anyhow::Result<bool> {+ let gate = self.frontend_terminal_gate();+ let Some((title, hint)) = gate.overlay_message() else {+ return Ok(false);+ };+ let now = Instant::now();+ let animation_ms = self.created.elapsed().as_millis() as u64;+ let eyes_closed = animation_ms % 5_000 >= 4_750;+ // Reuse the renderer's existing animation wakeup. Once the overlay is+ // gone no next frame is requested, so an ordinary terminal remains+ // fully draw-on-demand.+ self.update_next_frame_time(Some(now + Duration::from_millis(125)));+ let area = self.content_view_area();+ let palette = UiPalette::for_appearance(crate::native_settings::effective_appearance());+ self.filled_rectangle(layers, 0, area, palette.window_bg)+ .context("frontend handoff opaque background")?;++ let font_size = crate::native_settings::home_font_size(&crate::native_settings::load());+ let title_font = self.fonts.title_font_with_size(font_size + 2.0)?;+ let hint_font = self.fonts.title_font_with_size(font_size)?;+ let metrics = crate::utilsprites::RenderMetrics::with_font_metrics(&title_font.metrics());+ let gl_state = self.render_state.as_ref().unwrap();+ let ctx = DrawContext::new(gl_state, self.dimensions, &metrics);+ let title_width = ctx.measure_text_width(&title_font, &title);+ let hint_width = ctx.measure_text_width(&hint_font, &hint);+ let line_height = metrics.cell_size.height as f32;+ let eyes = if eyes_closed { "─ ─" } else { "• •" };+ let eyes_width = ctx.measure_text_width(&title_font, eyes);+ let eyes_height = line_height;+ let show_eyes = area.size.width >= 160.0 && area.size.height >= 100.0;+ let text_height = line_height * 2.4;+ let group_height = if show_eyes {+ eyes_height + line_height * 1.1 + text_height+ } else {+ text_height+ };+ let x_title = area.origin.x + ((area.size.width - title_width).max(0.0) / 2.0);+ let x_hint = area.origin.x + ((area.size.width - hint_width).max(0.0) / 2.0);+ let group_y = area.origin.y + ((area.size.height - group_height).max(0.0) / 2.0);++ // One measured text run keeps the two eyes centered as a unit across+ // fonts and display scales, without introducing a mascot asset.+ if show_eyes {+ let x_eyes = area.origin.x + ((area.size.width - eyes_width).max(0.0) / 2.0);+ ctx.draw_text_on_layer(+ layers,+ 2,+ &title_font,+ x_eyes,+ group_y,+ eyes,+ palette.text,+ area.size.width,+ )?;+ }++ let y_title = if show_eyes {+ group_y + eyes_height + line_height * 1.1+ } else {+ group_y+ };+ ctx.draw_text_on_layer(+ layers,+ 2,+ &title_font,+ x_title,+ y_title,+ &title,+ palette.text,+ area.size.width,+ )?;+ ctx.draw_text_on_layer(+ layers,+ 2,+ &hint_font,+ x_hint,+ y_title + line_height * 1.4,+ &hint,+ palette.secondary_text,+ area.size.width,+ )?;+ Ok(true)+ }++ /// In A mode a follower keeps the canonical PTY grid. If its window is+ /// larger, mark the renderer-only remainder with a faint cell grid rather+ /// than stretching or reflowing terminal data that belongs to the owner.+ fn paint_frontend_shared_unused_grid(+ &mut self,+ layers: &mut TripleLayerQuadAllocator<'_>,+ ) -> anyhow::Result<()> {+ let Some(state) = self.active_remote_frontend_viewport_state() else {+ return Ok(());+ };+ if state.access.mode != codec::FrontendAccessMode::TmuxLatest+ || self.owns_frontend_viewport()+ {+ return Ok(());+ }+ let area = self.content_view_area();+ let cell_w = self.render_metrics.cell_size.width.max(1) as f32;+ let cell_h = self.render_metrics.cell_size.height.max(1) as f32;+ let used_w = (state.canonical_size.cols as f32 * cell_w).min(area.size.width);+ let used_h = (state.canonical_size.rows as f32 * cell_h).min(area.size.height);+ if used_w >= area.size.width && used_h >= area.size.height {+ return Ok(());+ }+ let palette = UiPalette::for_appearance(crate::native_settings::effective_appearance());+ let line = palette.muted_text.mul_alpha(0.10);+ let right_x = area.origin.x + used_w;+ let bottom_y = area.origin.y + used_h;++ let mut x = right_x;+ while x <= area.max_x() {+ self.filled_rectangle(+ layers,+ 0,+ euclid::rect(x, area.origin.y, 1.0, area.size.height),+ line,+ )?;+ x += cell_w;+ }+ let mut y = area.origin.y;+ while y <= area.max_y() {+ if right_x < area.max_x() {+ self.filled_rectangle(+ layers,+ 0,+ euclid::rect(right_x, y, area.max_x() - right_x, 1.0),+ line,+ )?;+ }+ y += cell_h;+ }+ y = bottom_y;+ while y <= area.max_y() {+ self.filled_rectangle(layers, 0, euclid::rect(area.origin.x, y, used_w, 1.0), line)?;+ y += cell_h;+ }+ x = area.origin.x;+ while x <= right_x {+ if bottom_y < area.max_y() {+ self.filled_rectangle(+ layers,+ 0,+ euclid::rect(x, bottom_y, 1.0, area.max_y() - bottom_y),+ line,+ )?;+ }+ x += cell_w;+ }+ Ok(())+ }+fn damp_scroll_value(current: f32, target: f32) -> (f32, bool) {let delta = target - current;if delta.abs() <= 0.75 {@@ -735,6 +892,15 @@ impl crate::TermWindow {let content_view_active = self.content_view_foreground();if !content_view_active {+ // Takeover remains opaque while this actively polls and hydrates+ // the post-resize remote screen. Once every pane is coherent the+ // matching epoch is cleared before `frontend_blocked` is sampled.+ self.advance_frontend_geometry_confirmation();+ }++ let frontend_blocked = !content_view_active && self.frontend_surface_blocked();++ if !content_view_active && !frontend_blocked {for pos in panes {if pos.is_active {self.update_text_cursor(&pos);@@ -753,13 +919,20 @@ impl crate::TermWindow {.context("paint_split")?;}}+ self.paint_frontend_shared_unused_grid(&mut layers)+ .context("paint shared unused grid")?;}- if !content_view_active {+ if !content_view_active && !frontend_blocked {self.paint_bottom_quote(&mut layers).context("paint_bottom_quote")?;}+ if frontend_blocked {+ self.paint_frontend_handoff_overlay(&mut layers)+ .context("paint frontend handoff overlay")?;+ }+if content_view_active {self.paint_content_view(&mut layers).context("paint_content_view")?;diff --git a/wezterm-gui/src/termwindow/render/pane.rs b/wezterm-gui/src/termwindow/render/pane.rsindex 5fd756bc..47cf7be7 100644--- a/wezterm-gui/src/termwindow/render/pane.rs+++ b/wezterm-gui/src/termwindow/render/pane.rs@@ -58,13 +58,13 @@ fn clamp_pane_horizontal_span(fn visible_render_columns(requested_cols: usize,content_left: f32,- viewport_right: f32,+ clip_right: f32,cell_width: f32,) -> usize {if requested_cols == 0 || cell_width <= 0.0 {return 0;}- let visible_width = (viewport_right - content_left).max(0.0);+ let visible_width = (clip_right - content_left).max(0.0);requested_cols.min((visible_width / cell_width).floor().max(0.0) as usize)}@@ -95,7 +95,7 @@ mod pane_geometry_tests {}#[test]- fn terminal_columns_are_clipped_while_old_geometry_is_being_repaired() {+ fn terminal_columns_are_clipped_to_the_current_pane_while_geometry_is_repaired() {assert_eq!(visible_render_columns(100, 354.0, 802.0, 10.0), 44);assert_eq!(visible_render_columns(30, 354.0, 802.0, 10.0), 30);assert_eq!(visible_render_columns(100, 900.0, 802.0, 10.0), 0);@@ -1134,16 +1134,24 @@ impl crate::TermWindow {let content_left = padding_left+ border.left.get() as f32+ pos.left as f32 * global_render_metrics.cell_size.width as f32;+ let pane_target_size = self.terminal_size_for_positioned_pane(pos, pane_render_metrics);+ let pane_content_right =+ (content_left + pos.pixel_width as f32).min(self.terminal_viewport_right());let visible_cols = visible_render_columns(dims.cols,content_left,- self.terminal_viewport_right(),+ pane_content_right,pane_render_metrics.cell_size.width.max(1) as f32,);let mut render_dims = dims;- render_dims.cols = visible_cols;- render_dims.pixel_width =- visible_cols.saturating_mul(pane_render_metrics.cell_size.width.max(1) as usize);+ render_dims.cols = visible_cols.min(pane_target_size.cols);+ render_dims.viewport_rows = render_dims.viewport_rows.min(pane_target_size.rows);+ render_dims.pixel_width = render_dims+ .cols+ .saturating_mul(pane_render_metrics.cell_size.width.max(1) as usize);+ render_dims.pixel_height = render_dims+ .viewport_rows+ .saturating_mul(pane_render_metrics.cell_size.height.max(1) as usize);let gl_state = self.render_state.as_ref().unwrap();@@ -1524,6 +1532,8 @@ impl crate::TermWindow {top_pixel_y: NotNan::new(self.top_pixel_y).unwrap()+ line_idx as f32 * self.render_metrics.cell_size.height as f32,left_pixel_x: NotNan::new(self.left_pixel_x).unwrap(),+ render_cols: self.dims.cols,+ render_pixel_width: self.dims.pixel_width,phys_line_idx: line_idx,reverse_video: self.dims.reverse_video,};diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rsindex ead4635a..9f00057d 100644--- a/wezterm-gui/src/termwindow/resize.rs+++ b/wezterm-gui/src/termwindow/resize.rs@@ -1,19 +1,61 @@use crate::resize_increment_calculator::ResizeIncrementCalculator;+use crate::termwindow::TermWindowNotif;use crate::ui::rescale_ui_usize;use crate::utilsprites::RenderMetrics;use ::window::{Dimensions, ResizeIncrement, Window, WindowOps, WindowState};use config::{ConfigHandle, DimensionContext};+use mux::domain::Domain;use mux::pane::{Pane, PaneId};use mux::tab::PositionedPane;use mux::Mux;use std::collections::HashMap;use std::rc::Rc;use std::sync::Arc;-use wezterm_client::domain::ClientDomain;+use std::time::Duration;+use wezterm_client::domain::{ClientDomain, RemoteFrontendGate};use wezterm_client::pane::ClientPane;use wezterm_font::FontConfiguration;use wezterm_term::TerminalSize;+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum FrontendGeometryAction {+ Passive,+ Set { takeover: bool },+ Claim,+}++fn frontend_geometry_action(+ ownership: Option<bool>,+ collaborative: bool,+ previewing: bool,+) -> FrontendGeometryAction {+ match ownership {+ Some(false) if previewing && collaborative => FrontendGeometryAction::Claim,+ Some(false) => FrontendGeometryAction::Passive,+ Some(true) => FrontendGeometryAction::Set { takeover: false },+ None => FrontendGeometryAction::Set { takeover: true },+ }+}++// Full-screen TUIs handle SIGWINCH asynchronously after the server-side PTY+// resize has returned. Keep two 125ms overlay frames of quiet time so a+// slightly delayed clear/redraw cannot become the first visible GUI frame.+const FRONTEND_GEOMETRY_SETTLE: Duration = Duration::from_millis(200);++fn geometry_confirmation_settled(+ ready: bool,+ now: std::time::Instant,+ ready_since: &mut Option<std::time::Instant>,+) -> bool {+ if !ready {+ *ready_since = None;+ return false;+ }++ let started = ready_since.get_or_insert(now);+ now.duration_since(*started) >= FRONTEND_GEOMETRY_SETTLE+}+#[derive(Debug, Clone, Copy)]pub struct RowsAndCols {pub rows: usize,@@ -27,14 +69,100 @@ pub enum ScaleChange {}impl super::TermWindow {- fn tab_owns_frontend_viewport(&self, tab: &Arc<mux::tab::Tab>) -> bool {+ pub(crate) fn active_frontend_access_state(&self) -> Option<mux::FrontendAccessState> {+ let pane = Mux::get()+ .get_active_tab_for_window(self.mux_window_id)?+ .get_active_pane()?;+ if let Some(client) = pane.downcast_ref::<ClientPane>() {+ return client+ .remote_access_state()+ .map(|state| mux::FrontendAccessState {+ mode: match state.mode {+ codec::FrontendAccessMode::TmuxLatest => {+ mux::FrontendAccessMode::TmuxLatest+ }+ codec::FrontendAccessMode::Handoff => mux::FrontendAccessMode::Handoff,+ },+ owner: state.owner,+ generation: state.generation,+ });+ }+ Some(Mux::get().frontend_access_state())+ }++ pub(crate) fn frontend_terminal_gate(&self) -> RemoteFrontendGate {+ let Some(tab) = Mux::get().get_active_tab_for_window(self.mux_window_id) else {+ return RemoteFrontendGate::Visible;+ };+ let Some(pane) = tab.get_active_pane() else {+ return RemoteFrontendGate::Visible;+ };+ let gate = if let Some(client) = pane.downcast_ref::<ClientPane>() {+ client.remote_frontend_gate()+ } else {+ let state = Mux::get().frontend_access_state();+ if state.mode == mux::FrontendAccessMode::TmuxLatest+ || Mux::get()+ .active_identity()+ .as_deref()+ .is_some_and(|identity| state.owner.as_ref() == Some(identity))+ {+ RemoteFrontendGate::Visible+ } else {+ RemoteFrontendGate::Claimable { owner: state.owner }+ }+ };+ let obscured_by_geometry = self+ .frontend_geometry_phases+ .get(&tab.tab_id())+ .copied()+ .is_some_and(super::FrontendGeometryPhase::obscures_terminal);+ if obscured_by_geometry+ && matches!(+ gate,+ RemoteFrontendGate::Visible+ | RemoteFrontendGate::Claimable { .. }+ | RemoteFrontendGate::Syncing+ )+ {+ RemoteFrontendGate::Syncing+ } else {+ // Connection health remains more informative than a geometry+ // wait if the transport drops during takeover.+ gate+ }+ }++ pub(crate) fn frontend_surface_blocked(&self) -> bool {+ self.frontend_terminal_gate().obscures_terminal()+ }++ pub(crate) fn frontend_takeover_claimable(&self) -> bool {+ self.frontend_terminal_gate().is_claimable()+ }++ pub(crate) fn active_remote_frontend_viewport_state(+ &self,+ ) -> Option<codec::ClientViewportState> {+ Mux::get()+ .get_active_tab_for_window(self.mux_window_id)?+ .get_active_pane()?+ .downcast_ref::<ClientPane>()?+ .remote_viewport_state()+ }++ fn tab_frontend_viewport_ownership(&self, tab: &Arc<mux::tab::Tab>) -> Option<bool> {if let Some(owns) = tab.get_active_pane().and_then(|pane| {pane.downcast_ref::<ClientPane>().map(ClientPane::owns_remote_viewport)}) {- return owns == Some(true);+ return owns;}- Mux::get().current_identity_owns_frontend_lease(tab.tab_id())+ Some(Mux::get().current_identity_owns_frontend_lease(tab.tab_id()))+ }++ fn tab_owns_frontend_viewport(&self, tab: &Arc<mux::tab::Tab>) -> bool {+ self.tab_frontend_viewport_ownership(tab) == Some(true)}pub(crate) fn owns_frontend_viewport(&self) -> bool {@@ -43,69 +171,714 @@ impl super::TermWindow {.map_or(true, |tab| self.tab_owns_frontend_viewport(&tab))}- fn report_active_frontend_viewport(&self) {+ fn begin_frontend_geometry_epoch(+ &mut self,+ tab_id: mux::tab::TabId,+ takeover: bool,+ ) -> Option<u64> {+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .copied()+ .is_some_and(super::FrontendGeometryPhase::is_in_flight)+ {+ return None;+ }+ let epoch = self.next_frontend_geometry_epoch;+ self.next_frontend_geometry_epoch =+ self.next_frontend_geometry_epoch.wrapping_add(1).max(1);+ let phase = if takeover {+ super::FrontendGeometryPhase::TakeoverSyncing { epoch }+ } else {+ super::FrontendGeometryPhase::Committing { epoch }+ };+ self.frontend_geometry_phases.insert(tab_id, phase);+ self.invalidate_window();+ Some(epoch)+ }++ fn finish_frontend_geometry_epoch(+ &mut self,+ tab_id: mux::tab::TabId,+ epoch: u64,+ succeeded: bool,+ adopted: &[(PaneId, TerminalSize)],+ ) {+ let Some(phase) = self.frontend_geometry_phases.get(&tab_id).copied() else {+ return;+ };+ if phase.epoch() != epoch {+ return;+ }++ let mux = Mux::get();+ for (pane_id, size) in adopted {+ let Some(pane) = mux.get_pane(*pane_id) else {+ continue;+ };+ let Some(client) = pane.downcast_ref::<ClientPane>() else {+ continue;+ };+ if succeeded {+ // A resync notification can race the RPC completion and+ // temporarily put the advertised dimensions back. Validate+ // the surface against the exact acknowledged viewport before+ // allowing the first unmasked paint.+ client.adopt_frontend_geometry(*size);+ } else {+ client.forget_frontend_geometry(*size);+ }+ }++ if succeeded && phase.obscures_terminal() {+ // The RPC acknowledgement means that the server has issued the+ // PTY resize, not that the resized screen has reached this+ // renderer. Keep the opaque takeover state and actively fetch a+ // complete post-resize snapshot before revealing it.+ self.frontend_geometry_confirmations.insert(+ tab_id,+ super::FrontendGeometryConfirmation {+ epoch,+ panes: adopted.to_vec(),+ ready_since: None,+ },+ );+ self.advance_frontend_geometry_confirmation();+ self.update_title_post_status();+ self.invalidate_window();+ return;+ }++ self.complete_frontend_geometry_epoch(tab_id, epoch);+ }++ fn complete_frontend_geometry_epoch(&mut self, tab_id: mux::tab::TabId, epoch: u64) {+ let Some(phase) = self.frontend_geometry_phases.get(&tab_id).copied() else {+ return;+ };+ if phase.epoch() != epoch {+ return;+ }+ let keep_follow_up_obscured = phase.obscures_terminal();+ self.frontend_geometry_confirmations.remove(&tab_id);+ self.frontend_geometry_phases.remove(&tab_id);+ 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+ // old epoch is replaced before this callback can paint.+ self.sync_active_tab_geometry_now();+ if keep_follow_up_obscured {+ if let Some(super::FrontendGeometryPhase::Committing { epoch }) =+ self.frontend_geometry_phases.get(&tab_id).copied()+ {+ self.frontend_geometry_phases.insert(+ tab_id,+ super::FrontendGeometryPhase::TakeoverSyncing { epoch },+ );+ }+ }+ }+ self.update_title_post_status();+ self.invalidate_window();+ }++ /// Progress the active takeover without painting its old terminal grid.+ /// Each call forces a remote render poll and primes missing visible rows;+ /// PaneOutput and the overlay animation schedule subsequent checks.+ pub(crate) fn advance_frontend_geometry_confirmation(&mut self) {+ let Some(tab) = Mux::get().get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ let tab_id = tab.tab_id();+ let Some(confirmation) = self.frontend_geometry_confirmations.get(&tab_id).cloned() else {+ return;+ };+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .copied()+ .map(super::FrontendGeometryPhase::epoch)+ != Some(confirmation.epoch)+ {+ self.frontend_geometry_confirmations.remove(&tab_id);+ return;+ }++ let mux = Mux::get();+ let mut ready = !confirmation.panes.is_empty();+ for (pane_id, size) in &confirmation.panes {+ let pane_ready = mux+ .get_pane(*pane_id)+ .and_then(|pane| {+ pane.downcast_ref::<ClientPane>()+ .map(|client| client.prime_frontend_geometry(*size))+ })+ .unwrap_or(false);+ ready &= pane_ready;+ }++ let now = std::time::Instant::now();+ let settled = if let Some(pending) = self.frontend_geometry_confirmations.get_mut(&tab_id) {+ geometry_confirmation_settled(ready, now, &mut pending.ready_since)+ } else {+ false+ };+ if settled {+ self.complete_frontend_geometry_epoch(tab_id, confirmation.epoch);+ }+ }++ pub(crate) fn active_tab_is(&self, tab_id: mux::tab::TabId) -> bool {+ Mux::get()+ .get_active_tab_for_window(self.mux_window_id)+ .is_some_and(|tab| tab.tab_id() == tab_id)+ }++ /// Reflow one active top-level tab and derive both the root viewport and+ /// every visible pane surface from that same final layout pass.+ fn prepare_client_frontend_geometry(+ &mut self,+ tab: &Arc<mux::tab::Tab>,+ ) -> Option<(+ Arc<dyn Domain>,+ codec::ClientViewport,+ Vec<(PaneId, TerminalSize)>,+ )> {+ if !self.active_tab_is(tab.tab_id()) {+ return None;+ }+ let active_pane = tab.get_active_pane()?;+ let client_pane = active_pane.downcast_ref::<ClientPane>()?;+ let domain_id = client_pane.domain_id();+ let domain = Mux::get().get_domain(domain_id)?;+ if !domain.is::<ClientDomain>() {+ return None;+ }++ tab.resize(self.terminal_size);+ self.reapply_collapsed_panes_for_tab(tab.tab_id());++ let mut panes = Vec::new();+ let mut adopted = Vec::new();+ for positioned in self.get_panes_to_render() {+ let pane = positioned.pane.downcast_ref::<ClientPane>()?;+ if pane.domain_id() != domain_id {+ return None;+ }+ let font_scale = self.pane_font_scale(positioned.pane.pane_id());+ let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {+ self.render_metrics+ } else {+ match self.pane_font_resources(font_scale) {+ Ok((_, metrics)) => metrics,+ Err(err) => {+ log::warn!("cannot calculate native viewport: {err:#}");+ return None;+ }+ }+ };+ let size = self.terminal_size_for_positioned_pane(&positioned, metrics);+ panes.push(codec::ClientPaneViewport {+ pane_id: positioned.pane.pane_id(),+ size,+ });+ adopted.push((positioned.pane.pane_id(), size));+ }+ for (pane_id, size) in &adopted {+ let pane = Mux::get().get_pane(*pane_id)?;+ pane.downcast_ref::<ClientPane>()?+ .adopt_frontend_geometry(*size);+ }++ Some((+ domain,+ codec::ClientViewport::Native {+ size: self.terminal_size,+ panes,+ },+ adopted,+ ))+ }++ /// Keep a remote split visually attached to its divider while it is being+ /// dragged. Tab's split tree intentionally skips remote mirror PTY+ /// resizes; adopt the exact GUI pane surfaces locally and defer the one+ /// complete viewport RPC until release.+ pub(crate) fn preview_active_tab_geometry_now(&mut self) {+ if self.content_view_foreground() {+ return;+ }let mux = Mux::get();let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {return;};- let Some(active_pane) = tab.get_active_pane() else {+ let tab_id = tab.tab_id();+ if tab+ .get_active_pane()+ .is_none_or(|pane| pane.downcast_ref::<ClientPane>().is_none())+ {+ self.force_sync_active_mux_tab_pane_sizes();+ return;+ }++ let mode = self.active_frontend_access_state().map(|state| state.mode);+ let ownership = self.tab_frontend_viewport_ownership(&tab);+ if mode == Some(mux::FrontendAccessMode::Handoff) && ownership != Some(true) {+ return;+ }+ if self.prepare_client_frontend_geometry(&tab).is_none() {+ return;+ }++ let epoch = self.next_frontend_geometry_epoch;+ self.next_frontend_geometry_epoch =+ self.next_frontend_geometry_epoch.wrapping_add(1).max(1);+ self.frontend_geometry_phases+ .insert(tab_id, super::FrontendGeometryPhase::Previewing { epoch });+ self.invalidate_window();+ }++ /// Take the viewport because someone is using this window right now.+ ///+ /// The server hands the lease over on *input*, and a click in a pane that+ /// is not asking for mouse reporting never reaches the server at all — it+ /// is handled here. So a window sat down at and clicked in kept drawing at+ /// whatever size the phone that last typed had left it, until something+ /// incidental happened to re-report the geometry.+ ///+ /// Terminal-area clicks and scrolling claim. Tab/sidebar/window chrome+ /// calls never reach this method, so merely navigating the surrounding UI+ /// cannot steal the terminal from another renderer.+ ///+ /// Nothing happens when this window already owns the viewport, which is+ /// the overwhelmingly common case, so an ordinary click costs one+ /// comparison.+ pub(crate) fn claim_frontend_viewport_for_interaction(&mut self) {+ if !matches!(+ self.frontend_terminal_gate(),+ RemoteFrontendGate::Visible | RemoteFrontendGate::Claimable { .. }+ ) {+ return;+ }+ let mux = Mux::get();+ let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {return;};let tab_id = tab.tab_id();- let owns = self.tab_owns_frontend_viewport(&tab);+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .copied()+ .is_some_and(super::FrontendGeometryPhase::is_in_flight)+ || self.owns_frontend_viewport()+ {+ return;+ }- if let Some(client_pane) = active_pane.downcast_ref::<ClientPane>() {- let domain_id = client_pane.domain_id();- let Some(domain) = mux.get_domain(domain_id) else {+ if tab+ .get_active_pane()+ .is_some_and(|pane| pane.downcast_ref::<ClientPane>().is_none())+ {+ let Some(client_id) = mux.active_identity() else {return;};- if !domain.is::<ClientDomain>() {+ let viewport = self.local_frontend_viewport_for_tab(&tab, true);+ if let Err(err) = mux.claim_local_frontend_viewport(&client_id, tab_id, viewport) {+ log::warn!("claiming local GUI frontend viewport: {err:#}");return;}- let panes = if owns {- self.get_panes_to_render()- .into_iter()- .filter_map(|positioned| {- let pane = positioned.pane.downcast_ref::<ClientPane>()?;- if pane.domain_id() != domain_id {- return None;+ self.resize_mux_tabs_to_current_terminal_size();+ self.invalidate_window();+ return;+ }++ let Some(epoch) = self.begin_frontend_geometry_epoch(tab_id, true) else {+ return;+ };+ let Some((domain, viewport, adopted)) = self.prepare_client_frontend_geometry(&tab) else {+ self.frontend_geometry_phases.remove(&tab_id);+ self.invalidate_window();+ return;+ };+ let Some(window) = self.window.as_ref().cloned() else {+ self.frontend_geometry_phases.remove(&tab_id);+ return;+ };+ promise::spawn::spawn(async move {+ let result = match domain.downcast_ref::<ClientDomain>() {+ Some(client_domain) => {+ let result = client_domain.claim_client_viewport(tab_id, viewport).await;+ if let Err(err) = &result {+ log::warn!("claiming remote GUI frontend viewport: {err:#}");+ if let Err(resync_err) = client_domain.resync().await {+ log::warn!(+ "resyncing after failed frontend viewport claim: {resync_err:#}"+ );}- let font_scale = self.pane_font_scale(positioned.pane.pane_id());- let metrics =- if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {- self.render_metrics- } else {- match self.pane_font_resources(font_scale) {- Ok((_, metrics)) => metrics,- Err(err) => {- log::warn!("cannot calculate native viewport: {err:#}");- return None;- }- }- };- Some(codec::ClientPaneViewport {- pane_id: positioned.pane.pane_id(),- size: self.terminal_size_for_positioned_pane(&positioned, metrics),- })- })- .collect()- } else {- Vec::new()+ }+ result.map(|_| client_domain.owns_remote_viewport(tab_id) == Some(true))+ }+ None => Err(anyhow::anyhow!("frontend domain is not a client domain")),};- let viewport = codec::ClientViewport::Native {+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ let succeeded = result.as_ref().is_ok_and(|owns| *owns);+ let is_still_active = term_window.active_tab_is(tab_id);+ term_window.finish_frontend_geometry_epoch(tab_id, epoch, succeeded, &adopted);+ if succeeded && is_still_active {+ for pos in term_window.get_panes_to_render() {+ term_window.scroll_to_bottom(&pos.pane);+ }+ }+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }++ pub(crate) fn request_frontend_access_mode(&mut self, mode: codec::FrontendAccessMode) {+ let mux = Mux::get();+ let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ let tab_id = tab.tab_id();+ let is_remote = tab+ .get_active_pane()+ .is_some_and(|pane| pane.downcast_ref::<ClientPane>().is_some());+ if is_remote {+ let Some((domain, viewport)) = self.client_viewport_for_tab(&tab, true) else {+ return;+ };+ let Some(window) = self.window.as_ref().cloned() else {+ return;+ };+ promise::spawn::spawn(async move {+ let result = match domain.downcast_ref::<ClientDomain>() {+ Some(domain) => domain+ .set_frontend_access_mode(tab_id, mode, viewport)+ .await+ .map(|_| ()),+ None => Ok(()),+ };+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ if let Err(err) = result {+ log::warn!("changing frontend access mode: {err:#}");+ } else {+ for pos in term_window.get_panes_to_render() {+ term_window.scroll_to_bottom(&pos.pane);+ }+ term_window.resize_mux_tabs_to_current_terminal_size();+ }+ term_window.update_title_post_status();+ term_window.invalidate_window();+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ return;+ }++ let Some(client_id) = mux.active_identity() else {+ return;+ };+ let target = match mode {+ codec::FrontendAccessMode::TmuxLatest => mux::FrontendAccessMode::TmuxLatest,+ codec::FrontendAccessMode::Handoff => mux::FrontendAccessMode::Handoff,+ };+ let viewport = self.local_frontend_viewport_for_tab(&tab, true);+ if let Err(err) =+ mux.validate_frontend_access_mode_change(&client_id, target, tab_id, &viewport)+ {+ log::warn!("changing local frontend access mode: {err:#}");+ return;+ }+ let prior = mux.frontend_access_state().mode;+ if let Err(err) = wezterm_mux_server_impl::thinkterm_access::persist_mode(target) {+ log::warn!("persisting local frontend access mode: {err:#}");+ return;+ }+ if let Err(err) = mux.set_frontend_access_mode(&client_id, target, tab_id, viewport) {+ if prior != target {+ if let Err(rollback) =+ wezterm_mux_server_impl::thinkterm_access::persist_mode(prior)+ {+ log::error!("rolling back local frontend mode: {rollback:#}");+ }+ }+ log::warn!("changing local frontend access mode: {err:#}");+ return;+ }+ for pos in self.get_panes_to_render() {+ self.scroll_to_bottom(&pos.pane);+ }+ self.resize_mux_tabs_to_current_terminal_size();+ self.update_title_post_status();+ self.invalidate_window();+ }++ /// How this window would describe itself for `tab`, when that tab is+ /// backed by a remote mux. `None` for a tab that is not.+ ///+ /// `include_panes` says whether the per-pane split is worth offering.+ /// It is false for any tab this window is not currently drawing — its+ /// split is not the one in force, and offering it would ask the server to+ /// act on a layout nobody is looking at. The overall grid is still said,+ /// because the server can only hand the viewport to a client whose+ /// geometry it already holds: a tab this window has never described is a+ /// tab it can never take back.+ fn client_viewport_for_tab(+ &self,+ tab: &Arc<mux::tab::Tab>,+ include_panes: bool,+ ) -> Option<(Arc<dyn Domain>, codec::ClientViewport)> {+ let mux = Mux::get();+ let active_pane = tab.get_active_pane()?;+ let client_pane = active_pane.downcast_ref::<ClientPane>()?;+ let domain_id = client_pane.domain_id();+ let domain = mux.get_domain(domain_id)?;+ if !domain.is::<ClientDomain>() {+ return None;+ }+ let panes = if include_panes {+ self.get_panes_to_render()+ .into_iter()+ .filter_map(|positioned| {+ let pane = positioned.pane.downcast_ref::<ClientPane>()?;+ if pane.domain_id() != domain_id {+ return None;+ }+ let font_scale = self.pane_font_scale(positioned.pane.pane_id());+ let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {+ self.render_metrics+ } else {+ match self.pane_font_resources(font_scale) {+ Ok((_, metrics)) => metrics,+ Err(err) => {+ log::warn!("cannot calculate native viewport: {err:#}");+ return None;+ }+ }+ };+ Some(codec::ClientPaneViewport {+ pane_id: positioned.pane.pane_id(),+ size: self.terminal_size_for_positioned_pane(&positioned, metrics),+ })+ })+ .collect()+ } else {+ Vec::new()+ };+ Some((+ domain,+ codec::ClientViewport::Native {size: self.terminal_size,panes,+ },+ ))+ }++ /// Debounce resize-driven advertisements. Only the active tab has exact+ /// pane rectangles; background tabs are never overwritten with an empty+ /// native layout.+ pub(crate) fn report_frontend_viewport(&self) {+ if self+ .frontend_viewport_report_pending+ .swap(true, std::sync::atomic::Ordering::AcqRel)+ {+ return;+ }+ let Some(window) = self.window.as_ref().cloned() else {+ self.frontend_viewport_report_pending+ .store(false, std::sync::atomic::Ordering::Release);+ return;+ };+ let pending = Arc::clone(&self.frontend_viewport_report_pending);+ promise::spawn::spawn(async move {+ smol::Timer::after(Duration::from_millis(120)).await;+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ pending.store(false, std::sync::atomic::Ordering::Release);+ term_window.report_frontend_viewport_now();+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }++ fn report_frontend_viewport_now(&mut self) {+ let mux = Mux::get();+ let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ if let Some(phase) = self.frontend_geometry_phases.get(&tab.tab_id()).copied() {+ if phase.is_in_flight() {+ self.frontend_geometry_resync_after_epoch+ .insert(tab.tab_id());+ }+ // Preview geometry is committed explicitly on divider release;+ // in-flight geometry schedules one newest follow-up above.+ return;+ }+ self.report_frontend_viewport_for_tab(&tab);+ }++ /// Immediately converge the active top-level tab. Discrete lifecycle+ /// 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_active_tab_geometry_now(&mut self) {+ if self.content_view_foreground() {+ return;+ }+ let mux = Mux::get();+ let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ let tab_id = tab.tab_id();+ let Some(active_pane) = tab.get_active_pane() else {+ return;+ };++ if active_pane.downcast_ref::<ClientPane>().is_none() {+ tab.resize(self.terminal_size);+ self.reapply_collapsed_panes_for_tab(tab_id);+ self.force_sync_active_mux_tab_pane_sizes();+ self.report_frontend_viewport_for_tab(&tab);+ self.invalidate_window();+ return;+ }++ let ownership = self.tab_frontend_viewport_ownership(&tab);+ let previewing = matches!(+ self.frontend_geometry_phases.get(&tab_id),+ Some(super::FrontendGeometryPhase::Previewing { .. })+ );+ let collaborative = self+ .active_frontend_access_state()+ .is_some_and(|state| state.mode == mux::FrontendAccessMode::TmuxLatest);++ // A known passive renderer advertises availability without reshaping+ // its mirror. The sole exception is an explicit A-mode layout preview:+ // releasing its divider claims and commits that final geometry.+ let action = frontend_geometry_action(ownership, collaborative, previewing);+ if action == FrontendGeometryAction::Passive {+ self.frontend_geometry_phases.remove(&tab_id);+ self.report_frontend_viewport_for_tab(&tab);+ self.invalidate_window();+ return;+ }+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .copied()+ .is_some_and(super::FrontendGeometryPhase::is_in_flight)+ {+ self.frontend_geometry_resync_after_epoch.insert(tab_id);+ return;+ }+ let takeover = action == FrontendGeometryAction::Set { takeover: true };+ let claim = action == FrontendGeometryAction::Claim;+ let Some(epoch) = self.begin_frontend_geometry_epoch(tab_id, takeover) else {+ return;+ };+ let Some((domain, viewport, adopted)) = self.prepare_client_frontend_geometry(&tab) else {+ self.frontend_geometry_phases.remove(&tab_id);+ self.invalidate_window();+ return;+ };+ let Some(window) = self.window.as_ref().cloned() else {+ self.frontend_geometry_phases.remove(&tab_id);+ return;+ };++ promise::spawn::spawn(async move {+ let result = match domain.downcast_ref::<ClientDomain>() {+ Some(client_domain) => {+ let result = if claim {+ client_domain.claim_client_viewport(tab_id, viewport).await+ } else {+ client_domain.set_client_viewport(tab_id, viewport).await+ };+ if let Err(err) = &result {+ log::warn!("synchronizing active GUI tab geometry: {err:#}");+ if let Err(resync_err) = client_domain.resync().await {+ log::warn!(+ "resyncing after failed active tab geometry: {resync_err:#}"+ );+ }+ }+ // SetClientViewport is intentionally non-claiming. It+ // succeeds even when another frontend owns B mode, in+ // which case the submitted geometry was only recorded+ // and will never be reflected by the server pane. Do+ // not wait forever for that impossible confirmation.+ result.map(|_| client_domain.owns_remote_viewport(tab_id) == Some(true))+ }+ None => Err(anyhow::anyhow!("frontend domain is not a client domain")),+ };+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ let geometry_applied = result.as_ref().is_ok_and(|owns| *owns);+ term_window.finish_frontend_geometry_epoch(+ tab_id,+ epoch,+ geometry_applied,+ &adopted,+ );+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }++ fn report_frontend_viewport_for_tab(&self, tab: &Arc<mux::tab::Tab>) {+ let mux = Mux::get();+ let Some(active_pane) = tab.get_active_pane() else {+ return;+ };+ let tab_id = tab.tab_id();+ // Only the tab being drawn can offer a pane split, and only when it+ // holds the lease; anything else describes a layout nobody sees.+ let include_panes = self.active_tab_is(tab_id) && self.tab_owns_frontend_viewport(tab);++ if active_pane.downcast_ref::<ClientPane>().is_some() {+ let Some((domain, viewport)) = self.client_viewport_for_tab(tab, include_panes) else {+ return;+ };+ let adopted = match &viewport {+ codec::ClientViewport::Native { panes, .. } => panes+ .iter()+ .map(|pane| (pane.pane_id, pane.size))+ .collect::<Vec<_>>(),+ codec::ClientViewport::CellGrid { .. } => Vec::new(),};+ let window = self.window.as_ref().cloned();promise::spawn::spawn(async move {- let Some(domain) = domain.downcast_ref::<ClientDomain>() else {+ let Some(client_domain) = domain.downcast_ref::<ClientDomain>() else {return Ok::<(), anyhow::Error>(());};- domain.set_client_viewport(tab_id, viewport).await?;+ if let Err(err) = client_domain.set_client_viewport(tab_id, viewport).await {+ log::warn!("publishing GUI frontend viewport: {err:#}");+ if let Err(resync_err) = client_domain.resync().await {+ log::warn!("resyncing after failed GUI viewport: {resync_err:#}");+ }+ if let Some(window) = window {+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ let mux = Mux::get();+ for (pane_id, size) in &adopted {+ if let Some(pane) = mux.get_pane(*pane_id) {+ if let Some(client) = pane.downcast_ref::<ClientPane>() {+ client.forget_frontend_geometry(*size);+ }+ }+ }+ term_window.invalidate_window();+ })));+ }+ }Ok(())}).detach();return;}+ let owns = include_panes;// This GUI is itself hosting the authoritative mux. Register its// LocalPane viewport under the GUI's normal ClientId just like a@@ -114,7 +887,21 @@ impl super::TermWindow {let Some(client_id) = mux.active_identity() else {return;};- let panes = if owns {+ if let Err(err) = mux.set_client_viewport(+ &client_id,+ tab_id,+ self.local_frontend_viewport_for_tab(tab, owns),+ ) {+ log::warn!("cannot publish local GUI viewport: {err:#}");+ }+ }++ fn local_frontend_viewport_for_tab(+ &self,+ _tab: &Arc<mux::tab::Tab>,+ include_panes: bool,+ ) -> mux::FrontendViewport {+ let panes = if include_panes {self.get_panes_to_render().into_iter().filter(|positioned| !positioned.pane.is_remote_mirror())@@ -140,15 +927,9 @@ impl super::TermWindow {} else {Vec::new()};- if let Err(err) = mux.set_client_viewport(- &client_id,- tab_id,- mux::FrontendViewport::Native {- size: self.terminal_size,- panes,- },- ) {- log::warn!("cannot publish local GUI viewport: {err:#}");+ mux::FrontendViewport::Native {+ size: self.terminal_size,+ panes,}}@@ -456,7 +1237,11 @@ impl super::TermWindow {|| dims.pixel_height != target_size.pixel_height|| dims.dpi != target_size.dpi{- pos.pane.resize(target_size)?;+ if let Some(client) = pos.pane.downcast_ref::<ClientPane>() {+ client.adopt_frontend_geometry(target_size);+ } else {+ pos.pane.resize(target_size)?;+ }}Ok(())@@ -492,21 +1277,31 @@ impl super::TermWindow {}pub(crate) fn resize_mux_tabs_to_current_terminal_size(&mut self) {- if !self.owns_frontend_viewport() {- self.report_active_frontend_viewport();- return;- }let mux = Mux::get();- if let Some(window) = mux.get_window(self.mux_window_id) {- for tab in window.iter() {- if self.tab_owns_frontend_viewport(tab) {- tab.resize(self.terminal_size);- }+ let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ match self.tab_frontend_viewport_ownership(&tab) {+ None => {+ // This is the common first-open race: the remote topology is+ // already present but its access snapshot has not arrived.+ // A passive report can make this client the first owner while+ // leaving the old renderer geometry visible. Route it through+ // the opaque takeover epoch so root and pane surfaces are+ // converged before the first terminal frame.+ self.sync_active_tab_geometry_now();+ return;+ }+ Some(false) => {+ self.report_frontend_viewport();+ return;}+ Some(true) => {}}- self.reapply_collapsed_panes_for_window();+ tab.resize(self.terminal_size);+ self.reapply_collapsed_panes_for_tab(tab.tab_id());self.force_sync_active_mux_tab_pane_sizes();- self.report_active_frontend_viewport();+ self.report_frontend_viewport();}/// Repair a missed/deferred sidebar reflow before terminal geometry is@@ -542,7 +1337,7 @@ impl super::TermWindow {if !tab.resize(self.terminal_size) {return;}- self.reapply_collapsed_panes_for_window();+ self.reapply_collapsed_panes_for_tab(tab.tab_id());self.force_sync_active_mux_tab_pane_sizes();}@@ -718,7 +1513,7 @@ impl super::TermWindow {self.resize_mux_tabs_to_current_terminal_size();}} else {- self.report_active_frontend_viewport();+ self.report_frontend_viewport();log::trace!("terminal size unchanged; syncing active pane geometry");if !self.content_view_foreground() {self.sync_pane_font_sizes();@@ -1072,3 +1867,74 @@ pub fn effective_right_padding(config: &ConfigHandle, context: DimensionContext)config.window_padding.right.evaluate_as_pixels(context) as usize}}++#[cfg(test)]+mod frontend_geometry_tests {+ use super::{+ frontend_geometry_action, geometry_confirmation_settled, FrontendGeometryAction,+ FRONTEND_GEOMETRY_SETTLE,+ };+ use crate::termwindow::FrontendGeometryPhase;+ use std::time::{Duration, Instant};++ #[test]+ fn only_takeover_geometry_obscures_the_terminal() {+ assert!(!FrontendGeometryPhase::Previewing { epoch: 1 }.obscures_terminal());+ assert!(!FrontendGeometryPhase::Committing { epoch: 2 }.obscures_terminal());+ assert!(FrontendGeometryPhase::TakeoverSyncing { epoch: 3 }.obscures_terminal());+ }++ #[test]+ fn geometry_action_separates_owner_updates_takeover_and_passive_tabs() {+ assert_eq!(+ frontend_geometry_action(Some(true), false, false),+ FrontendGeometryAction::Set { takeover: false }+ );+ assert_eq!(+ frontend_geometry_action(None, false, false),+ FrontendGeometryAction::Set { takeover: true }+ );+ assert_eq!(+ frontend_geometry_action(Some(false), false, false),+ FrontendGeometryAction::Passive+ );+ assert_eq!(+ frontend_geometry_action(Some(false), true, true),+ FrontendGeometryAction::Claim+ );+ }++ #[test]+ fn takeover_geometry_must_remain_ready_for_a_stable_interval() {+ let start = Instant::now();+ let mut ready_since = None;++ assert!(!geometry_confirmation_settled(+ true,+ start,+ &mut ready_since+ ));+ assert!(!geometry_confirmation_settled(+ true,+ start + FRONTEND_GEOMETRY_SETTLE - Duration::from_millis(1),+ &mut ready_since+ ));+ assert!(geometry_confirmation_settled(+ true,+ start + FRONTEND_GEOMETRY_SETTLE,+ &mut ready_since+ ));++ assert!(!geometry_confirmation_settled(+ false,+ start + FRONTEND_GEOMETRY_SETTLE,+ &mut ready_since+ ));+ assert_eq!(ready_since, None);+ assert!(!geometry_confirmation_settled(+ true,+ start + FRONTEND_GEOMETRY_SETTLE,+ &mut ready_since+ ));+ }+}diff --git a/wezterm-gui/src/termwindow/ssh_hosts_view.rs b/wezterm-gui/src/termwindow/ssh_hosts_view.rsindex 753b2311..321a90c2 100644--- a/wezterm-gui/src/termwindow/ssh_hosts_view.rs+++ b/wezterm-gui/src/termwindow/ssh_hosts_view.rs@@ -616,10 +616,9 @@ impl SshHostsView {// nothing resolves the domain to connect, and every rename or// delete is refused because it has to go through a server this// device can no longer name.- let orphaned_spaces =- workspace_threads::space_ids_for_domains(&ssh_hosts::domain_names_for_host(- &entry.spec,- ));+ let orphaned_spaces = workspace_threads::space_ids_for_domains(+ &ssh_hosts::domain_names_for_host(&entry.spec),+ );if let Err(err) = ssh_hosts::try_remove_host(&id) {log::error!("failed to delete SSH host {id}: {err:#}");diff --git a/wezterm-gui/src/termwindow/ui/context_menu.rs b/wezterm-gui/src/termwindow/ui/context_menu.rsindex bf054f8b..01dc7dc1 100644--- a/wezterm-gui/src/termwindow/ui/context_menu.rs+++ b/wezterm-gui/src/termwindow/ui/context_menu.rs@@ -199,6 +199,9 @@ impl crate::TermWindow {crate::termwindow::ContextMenuApplicationAction::Note(command) => {self.perform_right_sidebar_note_command(command);}+ crate::termwindow::ContextMenuApplicationAction::SetFrontendAccessMode(mode) => {+ self.request_frontend_access_mode(mode);+ }crate::termwindow::ContextMenuApplicationAction::ActivateWorkspaceThread {space_id,thread_id,diff --git a/wezterm-gui/src/workspace_threads.rs b/wezterm-gui/src/workspace_threads.rsindex b53378f6..76ac0734 100644--- a/wezterm-gui/src/workspace_threads.rs+++ b/wezterm-gui/src/workspace_threads.rs@@ -1797,6 +1797,43 @@ pub async fn materialize_thread(return Ok(());}+ // A remote mux owns both its ThinkTerm tree and terminal topology. Use+ // its dedicated, serialized materialization RPC instead of sending an+ // ordinary SpawnV2 from sidebar chrome. In handoff mode an ordinary+ // spawn is correctly rejected for a non-owner, but that used to leave a+ // cold Thread with no terminal surface on which the user could click to+ // take control. EnsureThinkTermThread creates only the missing backing+ // terminal and deliberately does not claim the frontend lease; after the+ // resync below, the opaque terminal surface can perform the real claim.+ if let Some((_project_id, thread_id)) = parse_thread_workspace_name(&workspace_name) {+ if let Ok(domain) = mux.resolve_spawn_tab_domain(None, &default_domain) {+ if let Some(client_domain) =+ domain.downcast_ref::<wezterm_client::domain::ClientDomain>()+ {+ let response = client_domain+ .ensure_thinkterm_thread(Some(thread_id), size)+ .await+ .context("ensure remote ThinkTerm thread")?;+ if response.workspace != workspace_name {+ anyhow::bail!(+ "remote selected workspace {}, expected {} for thread {}",+ response.workspace,+ workspace_name,+ response.thread_id+ );+ }+ if mux.iter_windows_in_workspace(&workspace_name).is_empty() {+ anyhow::bail!(+ "remote materialized thread {} but resync installed no window in {}",+ response.thread_id,+ workspace_name+ );+ }+ return Ok(());+ }+ }+ }+// Decoding before the branch, rather than inside `materialize_layout`, is// what makes a layout this build cannot read a lost *arrangement* instead// of a Thread that will not open: an undecodable snapshot falls through todiff --git a/wezterm-mux-server-impl/Cargo.toml b/wezterm-mux-server-impl/Cargo.tomlindex c1bc85c4..85c83f00 100644--- a/wezterm-mux-server-impl/Cargo.toml+++ b/wezterm-mux-server-impl/Cargo.toml@@ -24,6 +24,7 @@ portable-pty = { workspace=true, features = ["serde_support"]}promise.workspace = truerangeset.workspace = truercgen.workspace = true+serde.workspace = trueserde_json.workspace = truesmol.workspace = truetempfile.workspace = truediff --git a/wezterm-mux-server-impl/src/dispatch.rs b/wezterm-mux-server-impl/src/dispatch.rsindex b86137a5..59c9b6d4 100644--- a/wezterm-mux-server-impl/src/dispatch.rs+++ b/wezterm-mux-server-impl/src/dispatch.rs@@ -226,6 +226,12 @@ where.await?;stream.flush().await.context("flushing PDU to client")?;}+ Ok(Item::Notif(MuxNotification::FrontendAccessChanged(state))) => {+ Pdu::FrontendAccessState(crate::sessionhandler::codec_access_state(state))+ .encode_async(&mut stream, 0)+ .await?;+ stream.flush().await.context("flushing PDU to client")?;+ }Ok(Item::Notif(MuxNotification::ActiveWorkspaceChanged(_))) => {}Ok(Item::Notif(MuxNotification::Empty)) => {}Err(err) => {diff --git a/wezterm-mux-server-impl/src/lib.rs b/wezterm-mux-server-impl/src/lib.rsindex bb3bed83..981f20fe 100644--- a/wezterm-mux-server-impl/src/lib.rs+++ b/wezterm-mux-server-impl/src/lib.rs@@ -9,6 +9,8 @@ pub mod dispatch;pub mod local;pub mod pki;pub mod sessionhandler;+pub mod thinkterm_access;+pub mod thinkterm_layout;pub mod thinkterm_session;pub mod thinkterm_tree;@@ -41,6 +43,9 @@ pub fn update_mux_domains_for_server(config: &ConfigHandle) -> anyhow::Result<()fn update_mux_domains_impl(config: &ConfigHandle, is_standalone_mux: bool) -> anyhow::Result<()> {let mux = Mux::get();+ thinkterm_access::initialize_mux(&mux);+ thinkterm_layout::initialize_mux(&mux);+for client_config in client_domains(&config) {if mux.get_domain_by_name(client_config.name()).is_some() {continue;diff --git a/wezterm-mux-server-impl/src/sessionhandler.rs b/wezterm-mux-server-impl/src/sessionhandler.rsindex b9d0a97a..36fc730d 100644--- a/wezterm-mux-server-impl/src/sessionhandler.rs+++ b/wezterm-mux-server-impl/src/sessionhandler.rs@@ -9,8 +9,9 @@ use mux::pane::{CachePolicy, Pane, PaneId};use mux::renderable::{RenderableDimensions, StableCursorPosition};use mux::tab::TabId;use mux::{- ClientRegistrationId, FrontendPaneViewport, FrontendViewport, FrontendViewportState, Mux,- PaletteSessionId,+ ClientRegistrationId, FrontendAccessMode as MuxFrontendAccessMode,+ FrontendAccessState as MuxFrontendAccessState, FrontendPaneViewport, FrontendViewport,+ FrontendViewportState, Mux, PaletteSessionId,};use promise::spawn::spawn_into_main_thread;use std::collections::HashMap;@@ -265,6 +266,29 @@ pub(crate) fn codec_viewport_state(state: FrontendViewportState) -> ClientViewpo.collect(),}),generation: state.generation,+ access: codec_access_state(state.access),+ }+}++pub(crate) fn codec_access_state(state: MuxFrontendAccessState) -> FrontendAccessState {+ FrontendAccessState {+ mode: codec_access_mode(state.mode),+ owner: state.owner,+ generation: state.generation,+ }+}++fn codec_access_mode(mode: MuxFrontendAccessMode) -> FrontendAccessMode {+ match mode {+ MuxFrontendAccessMode::TmuxLatest => FrontendAccessMode::TmuxLatest,+ MuxFrontendAccessMode::Handoff => FrontendAccessMode::Handoff,+ }+}++fn mux_access_mode(mode: FrontendAccessMode) -> MuxFrontendAccessMode {+ match mode {+ FrontendAccessMode::TmuxLatest => MuxFrontendAccessMode::TmuxLatest,+ FrontendAccessMode::Handoff => MuxFrontendAccessMode::Handoff,}}@@ -300,17 +324,62 @@ fn claim_viewport_for_pane(registration: Option<ClientRegistrationId>,pane_id: PaneId,) -> anyhow::Result<TabId> {+ let client_id =+ client_id.ok_or_else(|| anyhow!("terminal input requires an identified client"))?;+ let registration = registration+ .ok_or_else(|| anyhow!("terminal input requires a live client registration"))?;+ if mux+ .registered_client_has_frontend_access(client_id, registration)+ .is_none()+ {+ anyhow::bail!("terminal input came from a superseded client connection");+ }let (_domain_id, _window_id, tab_id) = mux.resolve_pane_id(pane_id).ok_or_else(|| anyhow!("no such pane {pane_id}"))?;- if let (Some(client_id), Some(registration)) = (client_id, registration) {- if !mux.registered_client_had_tab_input(client_id, registration, tab_id) {- anyhow::bail!("client connection was superseded");+ if !mux.registered_client_had_tab_input(client_id, registration, tab_id) {+ match mux.registered_client_has_frontend_access(client_id, registration) {+ None => anyhow::bail!("client connection was superseded"),+ Some(false) => anyhow::bail!("terminal is being operated on another device"),+ Some(true) => anyhow::bail!("unable to acquire the frontend layout"),}}Ok(tab_id)}+fn require_registered_frontend_access(+ mux: &Mux,+ client_id: Option<&Arc<ClientId>>,+ registration: Option<ClientRegistrationId>,+) -> anyhow::Result<()> {+ let client_id = client_id.ok_or_else(|| anyhow!("request requires an identified client"))?;+ let registration =+ registration.ok_or_else(|| anyhow!("request requires a live client registration"))?;+ match mux.registered_client_has_frontend_access(client_id, registration) {+ None => anyhow::bail!("client connection was superseded"),+ Some(false) => anyhow::bail!("terminal is being operated on another device"),+ Some(true) => Ok(()),+ }+}++/// Mutations which can be reached through tab/menu chrome must still obey B's+/// global owner, but checking them must not itself claim A's layout lease.+fn requires_existing_frontend_access(pdu: &Pdu) -> bool {+ matches!(+ pdu,+ Pdu::EraseScrollbackRequest(_)+ | Pdu::KillPane(_)+ | Pdu::SetPaneZoomed(_)+ | Pdu::SpawnV2(_)+ | Pdu::SplitPane(_)+ | Pdu::SpawnPaneInStack(_)+ | Pdu::ActivatePaneInStack(_)+ | Pdu::MovePaneToStack(_)+ | Pdu::MovePaneToNewTab(_)+ | Pdu::AdjustPaneSize(_)+ )+}+fn activate_client_palette(mux: &Mux,pane: &Arc<dyn Pane>,@@ -416,31 +485,6 @@ impl SessionHandler {if decoded.pdu.is_user_input() {let mux = Mux::get();mux.registered_client_had_input(client_id, registration);- // Whoever last acted *on a terminal* decides how big it is —- // typing, pasting, a mouse event a program asked for. Not a- // resize: a renderer reports its pane sizes on its first frame,- // so counting that made opening a second client take the grid- // away from the one someone was using. Without- // this the first renderer to attach kept the tab at its own- // size for as long as it stayed connected, so picking up a- // phone while a desktop was still open left the phone reading a- // grid shaped for the desktop and unable to do anything about- // it. Claiming needs a viewport this client has already- // advertised, so a client that has yet to draw changes nothing.- if let Some(tab_id) = decoded- .pdu- .is_terminal_interaction()- .then(|| decoded.pdu.pane_id())- .flatten()- .and_then(|pane_id| mux.resolve_pane_id(pane_id))- .map(|(_, _, tab_id)| tab_id)- {- if let Err(err) =- mux.claim_registered_client_viewport(client_id, registration, tab_id)- {- log::trace!("input did not move the viewport for tab {tab_id}: {err:#}");- }- }}}@@ -455,6 +499,17 @@ impl SessionHandler {sender.send(DecodedPdu { pdu, serial }).ok();};+ if requires_existing_frontend_access(&decoded.pdu) {+ if let Err(err) = require_registered_frontend_access(+ &Mux::get(),+ self.client_id.as_ref(),+ self.client_registration,+ ) {+ send_response(Err(err));+ return;+ }+ }+fn catch<F, SND>(f: F, send_response: SND)whereF: FnOnce() -> anyhow::Result<Pdu>,@@ -539,11 +594,10 @@ impl SessionHandler {let pane = mux.get_pane(pane_id).ok_or_else(|| anyhow::anyhow!("pane {pane_id} not found"))?;- claim_viewport_for_pane(+ require_registered_frontend_access(&mux,client_id.as_ref(),registration,- pane_id,)?;if let Some(palette) = configured_palette {@@ -1170,7 +1224,7 @@ impl SessionHandler {}).detach();}- Pdu::ClaimClientViewport(ClaimClientViewport { tab_id }) => {+ Pdu::ClaimClientViewport(ClaimClientViewport { tab_id, viewport }) => {let client_id = self.client_id.clone();let registration = self.client_registration;spawn_into_main_thread(async move {@@ -1183,7 +1237,12 @@ impl SessionHandler {anyhow!("ClaimClientViewport requires a live client registration")})?;let state = Mux::get()- .claim_registered_client_viewport(&client_id, registration, tab_id)?+ .claim_registered_client_viewport(+ &client_id,+ registration,+ tab_id,+ mux_viewport(viewport),+ )?.ok_or_else(|| anyhow!("client connection was superseded"))?;Ok(Pdu::ClientViewportState(codec_viewport_state(state)))},@@ -1193,6 +1252,65 @@ impl SessionHandler {.detach();}+ Pdu::SetFrontendAccessMode(SetFrontendAccessMode {+ mode,+ tab_id,+ viewport,+ }) => {+ let client_id = self.client_id.clone();+ let registration = self.client_registration;+ spawn_into_main_thread(async move {+ catch(+ move || {+ let client_id = client_id.ok_or_else(|| {+ anyhow!("SetFrontendAccessMode requires an identified client")+ })?;+ let registration = registration.ok_or_else(|| {+ anyhow!("SetFrontendAccessMode requires a live client registration")+ })?;+ let mux = Mux::get();+ let target_mode = mux_access_mode(mode);+ let viewport = mux_viewport(viewport);+ mux.validate_registered_frontend_access_mode_change(+ &client_id,+ registration,+ target_mode,+ tab_id,+ &viewport,+ )?;+ let prior_mode = mux.frontend_access_state().mode;+ crate::thinkterm_access::persist_mode(target_mode)?;+ match mux.set_registered_frontend_access_mode(+ &client_id,+ registration,+ target_mode,+ tab_id,+ viewport,+ ) {+ Ok(state) => {+ Ok(Pdu::FrontendAccessState(codec_access_state(state)))+ }+ Err(err) => {+ if prior_mode != target_mode {+ if let Err(rollback) =+ crate::thinkterm_access::persist_mode(prior_mode)+ {+ log::error!(+ "failed to roll back persisted frontend mode: \+ {rollback:#}"+ );+ }+ }+ Err(err)+ }+ }+ },+ send_response,+ )+ })+ .detach();+ }+Pdu::MutateThinkTermTree(MutateThinkTermTree { ops }) => {// mutate() broadcasts to every connection when the batch// changed something; the direct response here is what lets the@@ -1483,6 +1601,7 @@ impl SessionHandler {| Pdu::ThinkTermSessionState { .. }| Pdu::EnsureThinkTermThreadResponse { .. }| Pdu::ClientViewportState { .. }+ | Pdu::FrontendAccessState { .. }| Pdu::ErrorResponse { .. } => {send_response(Err(anyhow!("expected a request, got {:?}", decoded.pdu)))}@@ -1536,24 +1655,47 @@ async fn ensure_thinkterm_thread(let spawned = if has_live_pane {false} else {- let command_dir = match landing.project_path.trim() {- "" => None,- path if path.starts_with("wezterm-mux://") => None,- path => Some(path.to_string()),- };- mux.spawn_tab_or_window(- None,- SpawnTabDomain::DefaultDomain,- None,- command_dir,+ crate::thinkterm_layout::begin_restore(&landing.workspace);+ let restored = crate::thinkterm_layout::restore_thread_layout(+ &landing.thread_id,+ &landing.workspace,+ &landing.project_path,request.size,- None,- landing.workspace.clone(),- None,)- .await?;- crate::thinkterm_session::publish_changed();- true+ .await;++ let (materialized, preserve_saved_layout) = match restored {+ Ok(true) => (Ok(()), false),+ Ok(false) => (+ spawn_default_thinkterm_thread(&mux, &landing, request.size).await,+ false,+ ),+ Err(err) => {+ log::warn!(+ "failed to restore ThinkTerm layout for thread {}: {err:#}; \+ opening one default shell",+ landing.thread_id+ );+ (+ spawn_default_thinkterm_thread(&mux, &landing, request.size)+ .await+ .context("spawn fallback shell after layout restore failure"),+ true,+ )+ }+ };++ match materialized {+ Ok(()) => {+ crate::thinkterm_layout::finish_restore(&landing.workspace, !preserve_saved_layout);+ crate::thinkterm_session::publish_changed();+ true+ }+ Err(err) => {+ crate::thinkterm_layout::finish_restore(&landing.workspace, false);+ return Err(err);+ }+ }};Ok(Pdu::EnsureThinkTermThreadResponse(@@ -1565,6 +1707,30 @@ async fn ensure_thinkterm_thread())}+async fn spawn_default_thinkterm_thread(+ mux: &Mux,+ landing: &crate::thinkterm_tree::LandingRecord,+ size: wezterm_term::TerminalSize,+) -> anyhow::Result<()> {+ let command_dir = match landing.project_path.trim() {+ "" => None,+ path if path.starts_with("wezterm-mux://") => None,+ path => Some(path.to_string()),+ };+ mux.spawn_tab_or_window(+ None,+ SpawnTabDomain::DefaultDomain,+ None,+ command_dir,+ size,+ None,+ landing.workspace.clone(),+ None,+ )+ .await?;+ Ok(())+}+fn schedule_split_pane<SND>(split: SplitPane, send_response: SND, client_id: Option<Arc<ClientId>>)whereSND: Fn(anyhow::Result<Pdu>) + 'static,@@ -1736,8 +1902,46 @@ async fn move_pane(#[cfg(test)]mod tests {- use super::PerPane;+ use super::{claim_viewport_for_pane, requires_existing_frontend_access, PerPane};+ use codec::{EnsureThinkTermThread, Pdu};+ use mux::client::ClientId;+ use mux::Mux;+ use std::sync::Arc;use wezterm_term::color::ColorPalette;+ use wezterm_term::TerminalSize;++ #[test]+ fn cold_thread_materialization_does_not_require_an_existing_owner() {+ let request = Pdu::EnsureThinkTermThread(EnsureThinkTermThread {+ preferred_thread_id: Some("thread-main".to_string()),+ size: TerminalSize::default(),+ });++ assert!(!requires_existing_frontend_access(&request));+ }++ #[test]+ fn terminal_input_requires_identity_and_a_live_registration() {+ let mux = Mux::new(None);+ let missing_identity = claim_viewport_for_pane(&mux, None, None, usize::MAX)+ .unwrap_err()+ .to_string();+ assert!(missing_identity.contains("identified client"));++ let client = Arc::new(ClientId::new());+ let missing_registration = claim_viewport_for_pane(&mux, Some(&client), None, usize::MAX)+ .unwrap_err()+ .to_string();+ assert!(missing_registration.contains("live client registration"));++ let stale_registration = mux.register_client(Arc::clone(&client));+ mux.unregister_client(&client, stale_registration);+ let superseded =+ claim_viewport_for_pane(&mux, Some(&client), Some(stale_registration), usize::MAX)+ .unwrap_err()+ .to_string();+ assert!(superseded.contains("superseded client connection"));+ }#[test]fn application_palette_delivery_distinguishes_unsent_from_reset() {diff --git a/wezterm-mux-server-impl/src/thinkterm_access.rs b/wezterm-mux-server-impl/src/thinkterm_access.rsnew file mode 100644index 00000000..27461281--- /dev/null+++ b/wezterm-mux-server-impl/src/thinkterm_access.rs@@ -0,0 +1,174 @@+//! Durable selection of ThinkTerm's server-wide frontend access mode.+//!+//! Only the mode is durable. Owners and generations identify live transports+//! and must be rebuilt after each mux-server restart. A malformed existing file+//! is never silently overwritten: the server starts safely in Handoff mode but+//! refuses mode mutations until the operator repairs or removes that file.++use anyhow::{Context, Result};+use mux::{FrontendAccessMode, Mux};+use serde::{Deserialize, Serialize};+use std::io::Write;+use std::path::{Path, PathBuf};+use std::sync::Mutex;++#[derive(Clone, Debug, Deserialize, Serialize)]+struct StoredAccess {+ version: u32,+ mode: StoredMode,+}++#[derive(Clone, Copy, Debug, Deserialize, Serialize)]+#[serde(rename_all = "snake_case")]+enum StoredMode {+ TmuxLatest,+ Handoff,+}++impl From<StoredMode> for FrontendAccessMode {+ fn from(value: StoredMode) -> Self {+ match value {+ StoredMode::TmuxLatest => Self::TmuxLatest,+ StoredMode::Handoff => Self::Handoff,+ }+ }+}++impl From<FrontendAccessMode> for StoredMode {+ fn from(value: FrontendAccessMode) -> Self {+ match value {+ FrontendAccessMode::TmuxLatest => Self::TmuxLatest,+ FrontendAccessMode::Handoff => Self::Handoff,+ }+ }+}++#[derive(Debug)]+struct StoreState {+ mode: FrontendAccessMode,+ load_error: Option<String>,+}++lazy_static::lazy_static! {+ static ref STORE: Mutex<StoreState> = Mutex::new(load_state(&access_path()));+}++pub fn access_path() -> PathBuf {+ config::DATA_DIR.join("thinkterm_access.json")+}++fn load_state(path: &Path) -> StoreState {+ match load_from_path(path) {+ Ok(mode) => StoreState {+ mode,+ load_error: None,+ },+ Err(err) => {+ log::error!(+ "failed to load ThinkTerm access mode from {}: {err:#}; \+ starting in Handoff and refusing to overwrite the file",+ path.display()+ );+ StoreState {+ mode: FrontendAccessMode::Handoff,+ load_error: Some(format!("{err:#}")),+ }+ }+ }+}++fn load_from_path(path: &Path) -> Result<FrontendAccessMode> {+ if !path.exists() {+ return Ok(FrontendAccessMode::Handoff);+ }+ let file = std::fs::File::open(path).with_context(|| format!("open {}", path.display()))?;+ let stored: StoredAccess = serde_json::from_reader(std::io::BufReader::new(file))+ .with_context(|| format!("parse {}", path.display()))?;+ if stored.version != 1 {+ anyhow::bail!(+ "unsupported ThinkTerm access file version {} in {}",+ stored.version,+ path.display()+ );+ }+ Ok(stored.mode.into())+}++fn save_to_path(path: &Path, mode: FrontendAccessMode) -> Result<()> {+ let parent = path+ .parent()+ .ok_or_else(|| anyhow::anyhow!("{} has no parent directory", path.display()))?;+ std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;+ let mut file = tempfile::NamedTempFile::new_in(parent)+ .with_context(|| format!("create temporary access file in {}", parent.display()))?;+ serde_json::to_writer_pretty(+ &mut file,+ &StoredAccess {+ version: 1,+ mode: mode.into(),+ },+ )+ .with_context(|| format!("write {}", path.display()))?;+ file.flush()+ .with_context(|| format!("flush {}", path.display()))?;+ file.as_file()+ .sync_all()+ .with_context(|| format!("sync {}", path.display()))?;+ file.persist(path)+ .with_context(|| format!("replace {}", path.display()))?;+ Ok(())+}++pub fn initialize_mux(mux: &Mux) {+ if mux.frontend_access_mode_is_initialized() {+ return;+ }+ mux.initialize_frontend_access_mode(STORE.lock().unwrap().mode);+}++/// Persist before the caller commits the mux state. `StoreState` changes only+/// after the atomic replace succeeds.+pub fn persist_mode(mode: FrontendAccessMode) -> Result<()> {+ let mut store = STORE.lock().unwrap();+ if let Some(err) = &store.load_error {+ anyhow::bail!(+ "refusing to overwrite unreadable {}: {err}",+ access_path().display()+ );+ }+ if store.mode == mode {+ return Ok(());+ }+ save_to_path(&access_path(), mode)?;+ store.mode = mode;+ Ok(())+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn missing_file_defaults_to_handoff_and_round_trips_both_modes() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("nested").join("thinkterm_access.json");+ assert_eq!(load_from_path(&path).unwrap(), FrontendAccessMode::Handoff);++ save_to_path(&path, FrontendAccessMode::TmuxLatest).unwrap();+ assert_eq!(+ load_from_path(&path).unwrap(),+ FrontendAccessMode::TmuxLatest+ );+ save_to_path(&path, FrontendAccessMode::Handoff).unwrap();+ assert_eq!(load_from_path(&path).unwrap(), FrontendAccessMode::Handoff);+ }++ #[test]+ fn malformed_file_is_an_error_instead_of_becoming_a_default() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("thinkterm_access.json");+ std::fs::write(&path, b"not json").unwrap();+ assert!(load_from_path(&path).is_err());+ assert!(path.exists());+ }+}diff --git a/wezterm-mux-server-impl/src/thinkterm_layout.rs b/wezterm-mux-server-impl/src/thinkterm_layout.rsnew file mode 100644index 00000000..f29ad5a2--- /dev/null+++ b/wezterm-mux-server-impl/src/thinkterm_layout.rs@@ -0,0 +1,951 @@+//! Durable server-side layout snapshots for remote ThinkTerm Threads.+//!+//! The mux server owns remote terminal topology. This module records enough+//! structure to rebuild tabs, splits and pane-local stacks after the server+//! process disappears. It deliberately does not attempt to preserve PTYs,+//! scrollback or running programs.++use anyhow::{Context, Result};+use config::keyassignment::SpawnTabDomain;+use futures::future::LocalBoxFuture;+use mux::domain::SplitSource;+use mux::pane::PaneId;+use mux::tab::{PaneEntry, PaneNode, SplitDirection, SplitRequest, SplitSize};+use mux::window::WindowId;+use mux::{Mux, MuxNotification};+use serde::{Deserialize, Serialize};+use std::collections::{HashMap, HashSet};+use std::hash::{DefaultHasher, Hash, Hasher};+use std::io::Write;+use std::path::{Path, PathBuf};+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};+use std::sync::Mutex;+use std::time::Duration;+use wezterm_term::TerminalSize;++const LAYOUT_VERSION: u32 = 1;+const SNAPSHOT_DEBOUNCE: Duration = Duration::from_millis(180);++#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]+struct StoredLayouts {+ version: u32,+ layouts: HashMap<String, StoredThreadLayout>,+}++impl Default for StoredLayouts {+ fn default() -> Self {+ Self {+ version: LAYOUT_VERSION,+ layouts: HashMap::new(),+ }+ }+}++#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]+pub(crate) struct StoredThreadLayout {+ workspace: String,+ active_tab: usize,+ /// PaneNode is also a wire type. Keeping each tree as JSON allows an old+ /// server to leave a newer snapshot untouched when it cannot decode it.+ tabs: Vec<serde_json::Value>,+ #[serde(default)]+ terminal_specs: Vec<StoredTerminalSpec>,+}++#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]+struct StoredTerminalSpec {+ pane_id: PaneId,+ cwd: Option<String>,+ domain: Option<String>,+ title: String,+}++#[derive(Debug)]+struct StoreState {+ stored: StoredLayouts,+ load_error: Option<String>,+ restoring_workspaces: HashSet<String>,+ /// Workspaces seen live in the preceding snapshot. If one subsequently+ /// disappears, the user closed its final pane and the old layout must not+ /// come back on the next EnsureThinkTermThread.+ live_workspaces: HashSet<String>,+ /// A failed restore leaves one fallback shell. Preserve the original+ /// snapshot while that fallback has the same structure; focus and resize+ /// notifications must not silently replace it. A later real structural+ /// edit is allowed to become the new snapshot.+ protected_failed_layouts: HashMap<String, Option<u64>>,+}++lazy_static::lazy_static! {+ static ref STORE: Mutex<StoreState> = Mutex::new(load_state(&layout_path()));+}++static LISTENER_INSTALLED: AtomicBool = AtomicBool::new(false);+static CHANGE_GENERATION: AtomicU64 = AtomicU64::new(0);++pub fn layout_path() -> PathBuf {+ config::DATA_DIR.join("thinkterm_layout.json")+}++fn load_state(path: &Path) -> StoreState {+ match load_from_path(path) {+ Ok(stored) => StoreState {+ stored,+ load_error: None,+ restoring_workspaces: HashSet::new(),+ live_workspaces: HashSet::new(),+ protected_failed_layouts: HashMap::new(),+ },+ Err(err) => {+ log::error!(+ "failed to load ThinkTerm layouts from {}: {err:#}; \+ keeping the file untouched and opening one shell per Thread",+ path.display()+ );+ StoreState {+ stored: StoredLayouts::default(),+ load_error: Some(format!("{err:#}")),+ restoring_workspaces: HashSet::new(),+ live_workspaces: HashSet::new(),+ protected_failed_layouts: HashMap::new(),+ }+ }+ }+}++fn load_from_path(path: &Path) -> Result<StoredLayouts> {+ if !path.exists() {+ return Ok(StoredLayouts::default());+ }+ let file = std::fs::File::open(path).with_context(|| format!("open {}", path.display()))?;+ let stored: StoredLayouts = serde_json::from_reader(std::io::BufReader::new(file))+ .with_context(|| format!("parse {}", path.display()))?;+ if stored.version != LAYOUT_VERSION {+ anyhow::bail!(+ "unsupported ThinkTerm layout file version {} in {}",+ stored.version,+ path.display()+ );+ }+ Ok(stored)+}++fn save_to_path(path: &Path, stored: &StoredLayouts) -> Result<()> {+ let parent = path+ .parent()+ .ok_or_else(|| anyhow::anyhow!("{} has no parent directory", path.display()))?;+ std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;+ let mut file = tempfile::NamedTempFile::new_in(parent)+ .with_context(|| format!("create temporary layout file in {}", parent.display()))?;+ serde_json::to_writer_pretty(&mut file, stored)+ .with_context(|| format!("write {}", path.display()))?;+ file.flush()+ .with_context(|| format!("flush {}", path.display()))?;+ file.as_file()+ .sync_all()+ .with_context(|| format!("sync {}", path.display()))?;+ file.persist(path)+ .with_context(|| format!("replace {}", path.display()))?;+ Ok(())+}++fn commit_candidate(+ path: &Path,+ current: &mut StoredLayouts,+ candidate: StoredLayouts,+) -> Result<bool> {+ if candidate == *current {+ return Ok(false);+ }+ save_to_path(path, &candidate)?;+ *current = candidate;+ Ok(true)+}++fn prune_orphaned_layouts(+ stored: &StoredLayouts,+ valid_thread_ids: &HashSet<String>,+) -> StoredLayouts {+ let mut candidate = stored.clone();+ candidate+ .layouts+ .retain(|thread_id, _| valid_thread_ids.contains(thread_id));+ candidate+}++pub fn initialize_mux(mux: &Mux) {+ if let Err(err) = reconcile_with_tree(&crate::thinkterm_tree::snapshot()) {+ log::error!("reconciling ThinkTerm layouts at startup: {err:#}");+ }+ if LISTENER_INSTALLED.swap(true, Ordering::AcqRel) {+ return;+ }+ mux.subscribe(|notification| {+ if notification_changes_layout(¬ification) {+ schedule_snapshot();+ }+ true+ });+}++fn notification_changes_layout(notification: &MuxNotification) -> bool {+ matches!(+ notification,+ MuxNotification::PaneAdded(_)+ | MuxNotification::PaneRemoved(_)+ | MuxNotification::WindowCreated(_)+ | MuxNotification::WindowRemoved(_)+ | MuxNotification::WindowWorkspaceChanged(_)+ | MuxNotification::TabAddedToWindow { .. }+ | MuxNotification::PaneFocused(_)+ | MuxNotification::TabResized(_)+ | MuxNotification::WorkspaceRenamed { .. }+ | MuxNotification::Empty+ )+}++fn schedule_snapshot() {+ let generation = CHANGE_GENERATION.fetch_add(1, Ordering::AcqRel) + 1;+ promise::spawn::spawn(async move {+ smol::Timer::after(SNAPSHOT_DEBOUNCE).await;+ if CHANGE_GENERATION.load(Ordering::Acquire) != generation {+ return;+ }+ promise::spawn::spawn_into_main_thread(async move {+ if CHANGE_GENERATION.load(Ordering::Acquire) != generation {+ return;+ }+ if let Err(err) = snapshot_live_layouts(generation) {+ log::error!("persisting ThinkTerm layouts: {err:#}");+ }+ })+ .detach();+ })+ .detach();+}++fn thread_records(tree: &codec::ThinkTermTree) -> Vec<(String, String)> {+ tree.projects+ .iter()+ .flat_map(|project| {+ project.threads.iter().filter_map(|thread| {+ thread+ .materialized_workspace_name+ .as_ref()+ .or(thread.planned_workspace_name.as_ref())+ .map(|workspace| (thread.id.clone(), workspace.clone()))+ })+ })+ .collect()+}++fn snapshot_live_layouts(_generation: u64) -> Result<()> {+ let tree = crate::thinkterm_tree::snapshot();+ let records = thread_records(&tree);+ let valid_thread_ids = records+ .iter()+ .map(|(thread_id, _)| thread_id.clone())+ .collect::<HashSet<_>>();+ let mux = Mux::get();+ let mut live = HashMap::new();+ let mut current_live_workspaces = HashSet::new();++ for (thread_id, workspace) in &records {+ let has_live_window = mux+ .iter_windows_in_workspace(workspace)+ .into_iter()+ .filter_map(|window_id| mux.get_window(window_id))+ .any(|window| window.iter().any(|tab| !tab.iter_all_panes().is_empty()));+ if has_live_window {+ current_live_workspaces.insert(workspace.clone());+ }+ if let Some(layout) = snapshot_workspace(&mux, workspace)? {+ live.insert(thread_id.clone(), layout);+ }+ }++ let mut store = STORE.lock().unwrap();+ if store.load_error.is_some() {+ return Ok(());+ }++ let mut candidate = prune_orphaned_layouts(&store.stored, &valid_thread_ids);++ for (thread_id, workspace) in &records {+ if store.restoring_workspaces.contains(workspace) {+ continue;+ }+ if let Some(protected) = store.protected_failed_layouts.get(workspace) {+ let live_fingerprint = live.get(thread_id).and_then(layout_structure_fingerprint);+ if live_fingerprint == *protected {+ continue;+ }+ store.protected_failed_layouts.remove(workspace);+ }+ if let Some(layout) = live.remove(thread_id) {+ candidate.layouts.insert(thread_id.clone(), layout);+ } else if store.live_workspaces.contains(workspace) {+ candidate.layouts.remove(thread_id);+ }+ }++ let mut next_live = current_live_workspaces;+ for workspace in &store.restoring_workspaces {+ if store.live_workspaces.contains(workspace) {+ next_live.insert(workspace.clone());+ }+ }++ commit_candidate(&layout_path(), &mut store.stored, candidate)?;+ store.live_workspaces = next_live;+ Ok(())+}++fn snapshot_workspace(mux: &Mux, workspace: &str) -> Result<Option<StoredThreadLayout>> {+ for window_id in mux.iter_windows_in_workspace(workspace) {+ 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() {+ let node = tab.codec_pane_tree();+ collect_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);+ }+ return Ok(Some(StoredThreadLayout {+ workspace: workspace.to_string(),+ active_tab,+ tabs,+ terminal_specs,+ }));+ }+ Ok(None)+}++fn collect_terminal_specs(+ mux: &Mux,+ node: &PaneNode,+ terminal_specs: &mut Vec<StoredTerminalSpec>,+) {+ match node {+ PaneNode::Empty => {}+ PaneNode::Leaf(entry) => collect_terminal_spec(mux, entry, terminal_specs),+ PaneNode::Stack(stack) => {+ for entry in &stack.panes {+ collect_terminal_spec(mux, entry, terminal_specs);+ }+ }+ PaneNode::Split { left, right, .. } => {+ collect_terminal_specs(mux, left, terminal_specs);+ collect_terminal_specs(mux, right, terminal_specs);+ }+ }+}++fn collect_terminal_spec(+ mux: &Mux,+ entry: &PaneEntry,+ terminal_specs: &mut Vec<StoredTerminalSpec>,+) {+ let domain = mux+ .get_pane(entry.pane_id)+ .and_then(|pane| mux.get_domain(pane.domain_id()))+ .map(|domain| domain.domain_name().to_string());+ terminal_specs.push(StoredTerminalSpec {+ pane_id: entry.pane_id,+ cwd: working_dir_from_entry(entry),+ domain,+ title: entry.title.clone(),+ });+}++fn working_dir_from_entry(entry: &PaneEntry) -> Option<String> {+ entry.working_dir.as_ref().map(|url| {+ url.url+ .to_file_path()+ .ok()+ .and_then(|path| path.to_str().map(str::to_owned))+ .unwrap_or_else(|| url.url.path().to_string())+ })+}++pub(crate) fn reconcile_with_tree(tree: &codec::ThinkTermTree) -> Result<()> {+ let valid = tree+ .projects+ .iter()+ .flat_map(|project| project.threads.iter().map(|thread| thread.id.clone()))+ .collect::<HashSet<_>>();+ let mut store = STORE.lock().unwrap();+ if let Some(err) = &store.load_error {+ anyhow::bail!(+ "refusing to overwrite unreadable {}: {err}",+ layout_path().display()+ );+ }+ let candidate = prune_orphaned_layouts(&store.stored, &valid);+ commit_candidate(&layout_path(), &mut store.stored, candidate)?;+ Ok(())+}++pub(crate) fn begin_restore(workspace: &str) {+ STORE+ .lock()+ .unwrap()+ .restoring_workspaces+ .insert(workspace.to_string());+}++pub(crate) fn finish_restore(workspace: &str, succeeded: bool) {+ let failed_fingerprint = if succeeded {+ None+ } else {+ snapshot_workspace(&Mux::get(), workspace)+ .ok()+ .flatten()+ .and_then(|layout| layout_structure_fingerprint(&layout))+ };+ {+ let mut store = STORE.lock().unwrap();+ store.restoring_workspaces.remove(workspace);+ if !succeeded {+ store+ .protected_failed_layouts+ .insert(workspace.to_string(), failed_fingerprint);+ }+ }+ if succeeded {+ schedule_snapshot();+ }+}++fn saved_layout(thread_id: &str) -> Option<StoredThreadLayout> {+ let store = STORE.lock().unwrap();+ if store.load_error.is_some() {+ return None;+ }+ store.stored.layouts.get(thread_id).cloned()+}++pub(crate) async fn restore_thread_layout(+ thread_id: &str,+ workspace: &str,+ project_path: &str,+ size: TerminalSize,+) -> Result<bool> {+ let Some(layout) = saved_layout(thread_id) else {+ return Ok(false);+ };+ if layout.workspace != workspace {+ log::warn!(+ "ignoring stale ThinkTerm layout workspace {} for thread {thread_id}; expected {workspace}",+ layout.workspace+ );+ return Ok(false);+ }+ let tabs = decode_layout_tabs(&layout)?;+ if tabs.is_empty() {+ return Ok(false);+ }++ let mux = Mux::get();+ let mut created_window = None;+ let result = restore_decoded_layout(+ &mux,+ workspace,+ project_path,+ size,+ &layout,+ &tabs,+ &mut created_window,+ )+ .await;+ if result.is_err() {+ if let Some(window_id) = created_window {+ mux.kill_window(window_id);+ }+ }+ result.map(|()| true)+}++fn decode_layout_tabs(layout: &StoredThreadLayout) -> Result<Vec<PaneNode>> {+ layout+ .tabs+ .iter()+ .map(|tab| {+ serde_json::from_value::<PaneNode>(tab.clone())+ .context("decode saved ThinkTerm pane tree")+ })+ .collect()+}++async fn restore_decoded_layout(+ mux: &Mux,+ workspace: &str,+ project_path: &str,+ size: TerminalSize,+ layout: &StoredThreadLayout,+ tabs: &[PaneNode],+ created_window: &mut Option<WindowId>,+) -> Result<()> {+ let specs = layout+ .terminal_specs+ .iter()+ .map(|spec| (spec.pane_id, spec.clone()))+ .collect::<HashMap<_, _>>();+ let mut spawned_tabs = Vec::new();++ for node in tabs {+ let first = first_pane_entry(node);+ let cwd = first.and_then(|entry| cwd_for_entry(entry, &specs, project_path));+ let domain = first+ .map(|entry| domain_for_entry(mux, entry, &specs, true))+ .unwrap_or(SpawnTabDomain::DefaultDomain);+ let (tab, pane, window_id) = mux+ .spawn_tab_or_window(+ *created_window,+ domain,+ None,+ cwd,+ size,+ None,+ workspace.to_string(),+ None,+ )+ .await+ .context("restore ThinkTerm tab")?;+ *created_window = Some(window_id);+ let mut pane_map = HashMap::new();+ restore_node(+ mux,+ pane.pane_id(),+ node,+ &specs,+ project_path,+ &mut pane_map,+ )+ .await?;+ if let Some(active) = active_pane_entry(node)+ .and_then(|entry| pane_map.get(&entry.pane_id))+ .and_then(|pane_id| mux.get_pane(*pane_id))+ {+ tab.set_active_pane_silent(&active);+ }+ spawned_tabs.push(tab);+ }++ if let Some(window_id) = *created_window {+ if let Some(mut window) = mux.get_window_mut(window_id) {+ window.set_active_without_saving(layout.active_tab.min(spawned_tabs.len() - 1));+ }+ }+ Ok(())+}++fn restore_node<'a>(+ mux: &'a Mux,+ base_pane_id: PaneId,+ node: &'a PaneNode,+ specs: &'a HashMap<PaneId, StoredTerminalSpec>,+ project_path: &'a str,+ pane_map: &'a mut HashMap<PaneId, PaneId>,+) -> LocalBoxFuture<'a, Result<()>> {+ Box::pin(async move {+ match node {+ PaneNode::Empty => {}+ PaneNode::Leaf(entry) => {+ pane_map.insert(entry.pane_id, base_pane_id);+ }+ PaneNode::Stack(stack) => {+ if let Some(first) = stack.panes.first() {+ pane_map.insert(first.pane_id, base_pane_id);+ }+ let base = mux.get_pane(base_pane_id).ok_or_else(|| {+ anyhow::anyhow!("restored base pane {base_pane_id} disappeared")+ })?;+ let dims = base.get_dimensions();+ let stack_size = TerminalSize {+ rows: dims.viewport_rows,+ cols: dims.cols,+ pixel_width: dims.pixel_width,+ pixel_height: dims.pixel_height,+ dpi: dims.dpi,+ };+ for entry in stack.panes.iter().skip(1) {+ let pane = mux+ .spawn_pane_in_stack(+ base_pane_id,+ domain_for_entry(mux, entry, specs, false),+ None,+ cwd_for_entry(entry, specs, project_path),+ stack_size,+ )+ .await+ .context("restore ThinkTerm pane stack")?;+ pane_map.insert(entry.pane_id, pane.pane_id());+ }+ if let Some(entry) = stack.panes.get(stack.active) {+ if let Some(pane_id) = pane_map.get(&entry.pane_id) {+ mux.activate_pane_in_stack(*pane_id)?;+ }+ }+ }+ PaneNode::Split { left, right, node } => {+ let right_entry = first_pane_entry(right);+ let request = SplitRequest {+ direction: node.direction,+ target_is_second: true,+ top_level: false,+ size: SplitSize::Percent(split_second_percent(+ node.direction,+ node.first,+ node.second,+ )),+ };+ let (right_pane, _) = mux+ .split_pane(+ base_pane_id,+ request,+ SplitSource::Spawn {+ command: None,+ command_dir: right_entry+ .and_then(|entry| cwd_for_entry(entry, specs, project_path)),+ },+ right_entry+ .map(|entry| domain_for_entry(mux, entry, specs, false))+ .unwrap_or(SpawnTabDomain::CurrentPaneDomain),+ )+ .await+ .context("restore ThinkTerm split")?;+ restore_node(mux, base_pane_id, left, specs, project_path, pane_map).await?;+ restore_node(+ mux,+ right_pane.pane_id(),+ right,+ specs,+ project_path,+ pane_map,+ )+ .await?;+ }+ }+ Ok(())+ })+}++fn first_pane_entry(node: &PaneNode) -> Option<&PaneEntry> {+ match node {+ PaneNode::Empty => None,+ PaneNode::Leaf(entry) => Some(entry),+ PaneNode::Stack(stack) => stack.panes.first(),+ PaneNode::Split { left, right, .. } => {+ first_pane_entry(left).or_else(|| first_pane_entry(right))+ }+ }+}++fn active_pane_entry(node: &PaneNode) -> Option<&PaneEntry> {+ match node {+ PaneNode::Empty => None,+ PaneNode::Leaf(entry) => entry.is_active_pane.then_some(entry),+ PaneNode::Stack(stack) => stack+ .panes+ .iter()+ .find(|entry| entry.is_active_pane)+ .or_else(|| stack.panes.get(stack.active)),+ PaneNode::Split { left, right, .. } => {+ active_pane_entry(left).or_else(|| active_pane_entry(right))+ }+ }+}++fn cwd_for_entry(+ entry: &PaneEntry,+ specs: &HashMap<PaneId, StoredTerminalSpec>,+ project_path: &str,+) -> Option<String> {+ specs+ .get(&entry.pane_id)+ .and_then(|spec| usable_directory(spec.cwd.as_deref()))+ .or_else(|| usable_directory(working_dir_from_entry(entry).as_deref()))+ .or_else(|| usable_directory(Some(project_path)))+}++fn usable_directory(path: Option<&str>) -> Option<String> {+ let path = path?.trim();+ if path.is_empty() || path.starts_with("wezterm-mux://") {+ return None;+ }+ let expanded = if path == "~" {+ config::HOME_DIR.to_path_buf()+ } else if let Some(rest) = path.strip_prefix("~/") {+ config::HOME_DIR.join(rest)+ } else {+ PathBuf::from(path)+ };+ expanded+ .is_dir()+ .then(|| expanded.to_string_lossy().to_string())+}++fn domain_for_entry(+ mux: &Mux,+ entry: &PaneEntry,+ specs: &HashMap<PaneId, StoredTerminalSpec>,+ root: bool,+) -> SpawnTabDomain {+ specs+ .get(&entry.pane_id)+ .and_then(|spec| spec.domain.as_deref())+ .filter(|domain| mux.get_domain_by_name(domain).is_some())+ .map(|domain| SpawnTabDomain::DomainName(domain.to_string()))+ .unwrap_or(if root {+ SpawnTabDomain::DefaultDomain+ } else {+ SpawnTabDomain::CurrentPaneDomain+ })+}++fn split_second_percent(+ direction: SplitDirection,+ first: TerminalSize,+ second: TerminalSize,+) -> u8 {+ let (first, second) = match direction {+ SplitDirection::Horizontal => (first.cols, second.cols),+ SplitDirection::Vertical => (first.rows, second.rows),+ };+ let total = first.saturating_add(second).max(1);+ ((second.saturating_mul(100) / total).clamp(5, 95)) as u8+}++fn layout_structure_fingerprint(layout: &StoredThreadLayout) -> Option<u64> {+ let mut hasher = DefaultHasher::new();+ layout.tabs.len().hash(&mut hasher);+ for tab in &layout.tabs {+ let node = serde_json::from_value::<PaneNode>(tab.clone()).ok()?;+ hash_node_structure(&node, &mut hasher);+ }+ Some(hasher.finish())+}++fn hash_node_structure<H: Hasher>(node: &PaneNode, hasher: &mut H) {+ match node {+ PaneNode::Empty => 0u8.hash(hasher),+ PaneNode::Leaf(entry) => {+ 1u8.hash(hasher);+ entry.pane_id.hash(hasher);+ }+ PaneNode::Stack(stack) => {+ 2u8.hash(hasher);+ stack.panes.len().hash(hasher);+ for entry in &stack.panes {+ entry.pane_id.hash(hasher);+ }+ }+ PaneNode::Split { left, right, node } => {+ 3u8.hash(hasher);+ match node.direction {+ SplitDirection::Horizontal => 0u8.hash(hasher),+ SplitDirection::Vertical => 1u8.hash(hasher),+ }+ hash_node_structure(left, hasher);+ hash_node_structure(right, hasher);+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use mux::renderable::StableCursorPosition;++ fn sample_layout(workspace: &str) -> StoredThreadLayout {+ StoredThreadLayout {+ workspace: workspace.to_string(),+ active_tab: 1,+ tabs: vec![serde_json::to_value(PaneNode::Empty).unwrap()],+ terminal_specs: vec![StoredTerminalSpec {+ pane_id: 7,+ cwd: Some("/tmp".to_string()),+ domain: Some("local".to_string()),+ title: "shell".to_string(),+ }],+ }+ }++ #[test]+ fn missing_file_defaults_and_versioned_layout_round_trips() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("nested").join("thinkterm_layout.json");+ assert_eq!(load_from_path(&path).unwrap(), StoredLayouts::default());+ let mut stored = StoredLayouts::default();+ stored+ .layouts+ .insert("thread-1".to_string(), sample_layout("workspace-1"));+ save_to_path(&path, &stored).unwrap();+ assert_eq!(load_from_path(&path).unwrap(), stored);+ }++ #[test]+ fn malformed_or_unknown_layout_file_is_not_replaced() {+ let dir = tempfile::tempdir().unwrap();+ let malformed = dir.path().join("malformed.json");+ std::fs::write(&malformed, b"not json").unwrap();+ assert!(load_from_path(&malformed).is_err());+ assert_eq!(std::fs::read(&malformed).unwrap(), b"not json");++ let unknown = dir.path().join("unknown.json");+ std::fs::write(&unknown, br#"{"version":99,"layouts":{}}"#).unwrap();+ assert!(load_from_path(&unknown).is_err());+ assert!(String::from_utf8(std::fs::read(&unknown).unwrap())+ .unwrap()+ .contains("\"version\":99"));+ }++ #[test]+ fn failed_atomic_replace_does_not_change_the_in_memory_candidate() {+ let dir = tempfile::tempdir().unwrap();+ let blocker = dir.path().join("blocker");+ std::fs::write(&blocker, b"file").unwrap();+ let path = blocker.join("thinkterm_layout.json");+ let mut current = StoredLayouts::default();+ current+ .layouts+ .insert("thread-1".to_string(), sample_layout("workspace-1"));+ let before = current.clone();+ assert!(commit_candidate(&path, &mut current, StoredLayouts::default()).is_err());+ assert_eq!(current, before);+ }++ #[test]+ fn deleting_tree_entries_prunes_only_their_layouts() {+ let mut stored = StoredLayouts::default();+ stored+ .layouts+ .insert("keep".to_string(), sample_layout("workspace-keep"));+ stored+ .layouts+ .insert("delete".to_string(), sample_layout("workspace-delete"));+ let valid = HashSet::from(["keep".to_string()]);+ let pruned = prune_orphaned_layouts(&stored, &valid);+ assert!(pruned.layouts.contains_key("keep"));+ assert!(!pruned.layouts.contains_key("delete"));+ }++ #[test]+ fn split_ratio_uses_saved_proportions_not_absolute_size() {+ let first = TerminalSize {+ rows: 40,+ cols: 30,+ pixel_width: 0,+ pixel_height: 0,+ dpi: 96,+ };+ let second = TerminalSize {+ rows: 40,+ cols: 70,+ pixel_width: 0,+ pixel_height: 0,+ dpi: 96,+ };+ assert_eq!(+ split_second_percent(SplitDirection::Horizontal, first, second),+ 70+ );+ }++ #[test]+ fn output_notifications_do_not_schedule_layout_persistence() {+ assert!(!notification_changes_layout(&MuxNotification::PaneOutput(+ 7+ )));+ assert!(notification_changes_layout(&MuxNotification::TabResized(9)));+ assert!(notification_changes_layout(&MuxNotification::PaneFocused(+ 7+ )));+ }++ fn pane_entry(pane_id: PaneId, size: TerminalSize, active: bool) -> PaneEntry {+ PaneEntry {+ window_id: 1,+ tab_id: 2,+ pane_id,+ title: "shell".to_string(),+ size,+ working_dir: None,+ is_active_pane: active,+ is_zoomed_pane: false,+ alt_screen: false,+ workspace: "workspace-1".to_string(),+ cursor_pos: StableCursorPosition::default(),+ physical_top: 0,+ top_row: 0,+ left_col: 0,+ tty_name: None,+ }+ }++ #[test]+ fn failed_restore_protection_ignores_focus_and_size_but_not_structure() {+ let size_a = TerminalSize {+ rows: 24,+ cols: 80,+ pixel_width: 800,+ pixel_height: 600,+ dpi: 96,+ };+ let size_b = TerminalSize {+ rows: 60,+ cols: 160,+ pixel_width: 1600,+ pixel_height: 1200,+ dpi: 144,+ };+ let one = StoredThreadLayout {+ workspace: "workspace-1".to_string(),+ active_tab: 0,+ tabs: vec![serde_json::to_value(PaneNode::Leaf(pane_entry(7, size_a, true))).unwrap()],+ terminal_specs: vec![],+ };+ let resized = StoredThreadLayout {+ workspace: "workspace-1".to_string(),+ active_tab: 0,+ tabs: vec![serde_json::to_value(PaneNode::Leaf(pane_entry(7, size_b, false))).unwrap()],+ terminal_specs: vec![],+ };+ let extra_tab = StoredThreadLayout {+ workspace: "workspace-1".to_string(),+ active_tab: 1,+ tabs: vec![+ serde_json::to_value(PaneNode::Leaf(pane_entry(7, size_b, false))).unwrap(),+ serde_json::to_value(PaneNode::Leaf(pane_entry(8, size_b, true))).unwrap(),+ ],+ terminal_specs: vec![],+ };+ assert_eq!(+ layout_structure_fingerprint(&one),+ layout_structure_fingerprint(&resized)+ );+ assert_ne!(+ layout_structure_fingerprint(&one),+ layout_structure_fingerprint(&extra_tab)+ );+ }++ #[test]+ fn unreadable_pane_tree_rejects_restore_without_mutating_the_snapshot() {+ let mut layout = sample_layout("workspace-1");+ layout.tabs = vec![serde_json::json!({"future_node": {"field": true}})];+ let before = layout.clone();+ assert!(decode_layout_tabs(&layout).is_err());+ assert_eq!(layout, before);+ }+}diff --git a/wezterm-mux-server-impl/src/thinkterm_tree.rs b/wezterm-mux-server-impl/src/thinkterm_tree.rsindex 64ca8206..abf8edd1 100644--- a/wezterm-mux-server-impl/src/thinkterm_tree.rs+++ b/wezterm-mux-server-impl/src/thinkterm_tree.rs@@ -243,6 +243,9 @@ pub fn ensure_landing(preferred_thread_id: Option<&str>) -> Result<LandingRecord(landing, changed)};if changed {+ if let Err(err) = crate::thinkterm_layout::reconcile_with_tree(&snapshot()) {+ log::error!("reconciling ThinkTerm layouts after tree mutation: {err:#}");+ }Mux::notify_from_any_thread(MuxNotification::ThinkTermTreeChanged);}Ok(landing)@@ -291,6 +294,9 @@ pub fn mutate(ops: &[TreeOp]) -> Result<ThinkTermTree> {};if changed {+ if let Err(err) = crate::thinkterm_layout::reconcile_with_tree(&tree) {+ log::error!("reconciling ThinkTerm layouts after tree mutation: {err:#}");+ }Mux::notify_from_any_thread(MuxNotification::ThinkTermTreeChanged);}