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
Add adaptive remote split resizing
RoversX541d3f563e69
diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rsindex c010cec6..a6b294b5 100644--- a/wezterm-client/src/domain.rs+++ b/wezterm-client/src/domain.rs@@ -15,6 +15,7 @@ use portable_pty::CommandBuilder;use promise::spawn::spawn_into_new_thread;use std::collections::{HashMap, HashSet};use std::sync::{Arc, Mutex};+use std::time::{Duration, Instant};use wezterm_term::TerminalSize;#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]@@ -190,6 +191,78 @@ pub enum RemoteFrontendGate {Syncing,}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum AutomaticRemotePaneResize {+ Live,+ OnRelease,+}++const VIEWPORT_RTT_LIVE_MS: f64 = 80.0;+const VIEWPORT_RTT_ON_RELEASE_MS: f64 = 140.0;+const VIEWPORT_RTT_MIN_SAMPLES: u32 = 3;+const VIEWPORT_RTT_EWMA_ALPHA: f64 = 0.25;+const VIEWPORT_FAILURE_COOLDOWN: Duration = Duration::from_secs(30);++#[derive(Debug)]+struct ViewportLatencyState {+ ewma_ms: Option<f64>,+ successful_samples: u32,+ selected: AutomaticRemotePaneResize,+ degraded_until: Option<Instant>,+}++impl Default for ViewportLatencyState {+ fn default() -> Self {+ Self {+ ewma_ms: None,+ successful_samples: 0,+ selected: AutomaticRemotePaneResize::Live,+ degraded_until: None,+ }+ }+}++impl ViewportLatencyState {+ fn record_success(&mut self, elapsed: Duration) {+ let elapsed_ms = elapsed.as_secs_f64() * 1_000.0;+ self.ewma_ms = Some(match self.ewma_ms {+ Some(previous) => {+ previous * (1.0 - VIEWPORT_RTT_EWMA_ALPHA) + elapsed_ms * VIEWPORT_RTT_EWMA_ALPHA+ }+ None => elapsed_ms,+ });+ self.successful_samples = self.successful_samples.saturating_add(1);+ }++ fn record_failure(&mut self, now: Instant) {+ self.selected = AutomaticRemotePaneResize::OnRelease;+ self.degraded_until = now.checked_add(VIEWPORT_FAILURE_COOLDOWN);+ }++ fn choose(&mut self, now: Instant, ready: bool, tardy: bool) -> AutomaticRemotePaneResize {+ if !ready || tardy {+ return AutomaticRemotePaneResize::OnRelease;+ }+ if self.degraded_until.is_some_and(|until| now < until) {+ return AutomaticRemotePaneResize::OnRelease;+ }+ self.degraded_until = None;+ if self.successful_samples < VIEWPORT_RTT_MIN_SAMPLES {+ return AutomaticRemotePaneResize::Live;+ }+ match self.ewma_ms {+ Some(ewma) if ewma <= VIEWPORT_RTT_LIVE_MS => {+ self.selected = AutomaticRemotePaneResize::Live;+ }+ Some(ewma) if ewma >= VIEWPORT_RTT_ON_RELEASE_MS => {+ self.selected = AutomaticRemotePaneResize::OnRelease;+ }+ _ => {}+ }+ self.selected+ }+}+impl RemoteFrontendGate {pub fn obscures_terminal(&self) -> bool {!matches!(self, Self::Visible)@@ -324,6 +397,9 @@ pub struct ClientInner {/// old remote-id maps are cleared, this is what prevents a failed retry/// from materializing duplicate native windows on its next attempt.pending_recovery_windows: Mutex<HashMap<String, WindowId>>,+ /// Measured end-to-end latency of complete viewport RPCs. GUI Auto mode+ /// consults this once at drag start; it never changes policy mid-drag.+ viewport_latency: Mutex<ViewportLatencyState>,}/// RAII scope for a structure-mutating RPC; defers resyncs for its lifetime@@ -912,6 +988,7 @@ impl ClientInner {ready_server_id: Mutex::new(ready_server_id),pending_recovery_targets: Mutex::new(HashMap::new()),pending_recovery_windows: Mutex::new(HashMap::new()),+ viewport_latency: Mutex::new(ViewportLatencyState::default()),}}}@@ -1334,6 +1411,18 @@ impl ClientDomain {.map_or(false, |inner| inner.client.is_reconnecting())}+ pub fn automatic_remote_pane_resize(&self, pane_is_tardy: bool) -> AutomaticRemotePaneResize {+ let Some(inner) = self.inner() else {+ return AutomaticRemotePaneResize::OnRelease;+ };+ let choice = inner.viewport_latency.lock().unwrap().choose(+ Instant::now(),+ inner.client.connection_phase() == ClientConnectionPhase::Ready,+ pane_is_tardy,+ );+ choice+ }+/// Automatic reconnection failed for long enough that the retry loop/// parked itself; nothing is torn down, and resume_reconnect() starts/// another round.@@ -1989,13 +2078,32 @@ impl ClientDomain {.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+ let started_at = Instant::now();+ let result = inner.client.set_client_viewport(codec::SetClientViewport {tab_id: remote_tab_id,viewport,})- .await?;+ .await;+ let state = match result {+ Ok(state) => {+ inner+ .viewport_latency+ .lock()+ .unwrap()+ .record_success(started_at.elapsed());+ state+ }+ Err(err) => {+ inner+ .viewport_latency+ .lock()+ .unwrap()+ .record_failure(Instant::now());+ return Err(err);+ }+ };inner.remember_reported_viewport(remote_tab_id, reported);self.process_remote_viewport_state(state.clone());Ok(state)@@ -2043,13 +2151,32 @@ impl ClientDomain {.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+ let started_at = Instant::now();+ let result = inner.client.claim_client_viewport(codec::ClaimClientViewport {tab_id: remote_tab_id,viewport,})- .await?;+ .await;+ let state = match result {+ Ok(state) => {+ inner+ .viewport_latency+ .lock()+ .unwrap()+ .record_success(started_at.elapsed());+ state+ }+ Err(err) => {+ inner+ .viewport_latency+ .lock()+ .unwrap()+ .record_failure(Instant::now());+ return Err(err);+ }+ };inner.remember_reported_viewport(remote_tab_id, reported);self.process_remote_viewport_state(state.clone());Ok(state)@@ -2454,11 +2581,12 @@ mod tests {accepts_generation, acknowledge_recovery_target, active_remote_tabs_by_workspace,consistent_remote_tab_id, owns_remote_viewport_from_states,remote_frontend_gate_from_state, remote_move_pane_id, server_runtime_replaced,- thread_id_for_workspace, FrontendRecoveryAck, FrontendRecoveryBarrier,- FrontendRecoverySlot, RemoteFrontendGate,+ thread_id_for_workspace, AutomaticRemotePaneResize, FrontendRecoveryAck,+ FrontendRecoveryBarrier, FrontendRecoverySlot, RemoteFrontendGate, ViewportLatencyState,};use crate::client::ClientConnectionPhase;use std::collections::HashMap;+ use std::time::{Duration, Instant};fn client_id(hostname: &str, id: usize) -> mux::client::ClientId {mux::client::ClientId {@@ -2512,6 +2640,72 @@ mod tests {assert!(!accepts_generation(Some(9), 8));}+ #[test]+ fn automatic_remote_resize_uses_samples_and_hysteresis() {+ let now = Instant::now();+ let mut state = ViewportLatencyState::default();+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::Live+ );++ for _ in 0..3 {+ state.record_success(Duration::from_millis(50));+ }+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::Live+ );++ state.record_success(Duration::from_millis(500));+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::OnRelease+ );++ // The 80-140ms band retains the previous decision instead of+ // oscillating at a threshold while the connection jitters.+ state.ewma_ms = Some(110.0);+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::OnRelease+ );+ state.ewma_ms = Some(70.0);+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::Live+ );+ }++ #[test]+ fn automatic_remote_resize_degrades_for_failure_tardy_and_reconnect() {+ let now = Instant::now();+ let mut state = ViewportLatencyState::default();+ for _ in 0..3 {+ state.record_success(Duration::from_millis(40));+ }+ state.record_failure(now);+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::OnRelease+ );++ state.degraded_until = Some(now - Duration::from_millis(1));+ state.ewma_ms = Some(40.0);+ assert_eq!(+ state.choose(now, true, false),+ AutomaticRemotePaneResize::Live+ );+ assert_eq!(+ state.choose(now, true, true),+ AutomaticRemotePaneResize::OnRelease+ );+ assert_eq!(+ state.choose(now, false, false),+ AutomaticRemotePaneResize::OnRelease+ );+ }+#[test]fn handoff_ownership_uses_latest_connection_state_across_tabs() {let mac = client_id("mac", 1);diff --git a/wezterm-client/src/pane/clientpane.rs b/wezterm-client/src/pane/clientpane.rsindex 20858f39..ef4e5480 100644--- a/wezterm-client/src/pane/clientpane.rs+++ b/wezterm-client/src/pane/clientpane.rs@@ -640,6 +640,51 @@ impl ClientPane {changed}+ /// Pin the local render surface to a divider preview epoch. Unlike a+ /// normal adoption this deliberately preserves cached rows and ignores+ /// older server dimensions until the final full viewport is confirmed.+ pub fn preview_frontend_geometry(&self, epoch: u64, size: TerminalSize) -> bool {+ *self.requested_size.lock() = Some(size);+ let render = self.renderable.lock();+ let mut inner = render.inner.borrow_mut();+ let changed = inner.begin_frontend_preview(epoch, size);+ if changed {+ inner.update_last_send();+ }+ changed+ }++ pub fn server_geometry_matches(&self, size: TerminalSize) -> bool {+ self.renderable+ .lock()+ .inner+ .borrow()+ .server_geometry_matches(size)+ }++ pub fn finish_frontend_geometry_preview(+ &self,+ epoch: u64,+ size: TerminalSize,+ succeeded: bool,+ ) -> bool {+ if !succeeded {+ let mut requested = self.requested_size.lock();+ if requested.as_ref() == Some(&size) {+ requested.take();+ }+ }+ self.renderable+ .lock()+ .inner+ .borrow_mut()+ .end_frontend_preview(epoch, succeeded)+ }++ pub fn is_remote_tardy(&self) -> bool {+ self.renderable.lock().inner.borrow().is_tardy()+ }+/// 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.diff --git a/wezterm-client/src/pane/renderable.rs b/wezterm-client/src/pane/renderable.rsindex 6757c877..25efef80 100644--- a/wezterm-client/src/pane/renderable.rs+++ b/wezterm-client/src/pane/renderable.rs@@ -33,6 +33,12 @@ struct FetchToken {started_at: Instant,}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+struct FrontendPreviewGeometry {+ epoch: u64,+ size: wezterm_term::TerminalSize,+}+#[derive(Debug)]enum LineEntry {// Up to date wrt. server and has been rendered at least once@@ -98,6 +104,22 @@ fn render_dimensions_match_terminal_size(&& dimensions.dpi == size.dpi}+fn resolve_server_geometry(+ visible: RenderableDimensions,+ previous_server: RenderableDimensions,+ next_server: RenderableDimensions,+ preview_active: bool,+) -> (RenderableDimensions, Option<bool>) {+ if preview_active {+ let invalidation = render_geometry_changed(previous_server, next_server).then_some(true);+ (visible, invalidation)+ } else if render_geometry_changed(visible, next_server) {+ (next_server, Some(visible.cols == next_server.cols))+ } else {+ (next_server, None)+ }+}+fn fetch_token_is_current(token: FetchToken, epoch: u64) -> bool {token.epoch == epoch}@@ -118,6 +140,11 @@ pub struct RenderableInner {/// server value separate lets it remain masked until a post-resize render/// snapshot has actually arrived.server_dimensions: RenderableDimensions,+ /// While a native GUI divider is moving, this is the authoritative render+ /// surface. Remote snapshots continue updating `server_dimensions` and+ /// line contents, but cannot bounce the visible surface back to an older+ /// grid between mouse-move frames.+ frontend_preview: Option<FrontendPreviewGeometry>,lines: LruCache<StableRowIndex, LineEntry>,line_cache_epoch: u64,@@ -161,6 +188,7 @@ impl RenderableInner {cursor_position: StableCursorPosition::default(),dimensions,server_dimensions: dimensions,+ frontend_preview: None,lines: LruCache::new(NonZeroUsize::new(configuration().scrollback_lines.max(128)).unwrap(),),@@ -406,13 +434,19 @@ impl RenderableInner {{self.cursor_position = delta.cursor_position;}+ let prior_server_dimensions = self.server_dimensions;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;+ let (visible_dimensions, invalidate) = resolve_server_geometry(+ self.dimensions,+ prior_server_dimensions,+ delta.dimensions,+ self.frontend_preview.is_some(),+ );+ self.dimensions = visible_dimensions;+ if let Some(preserve_lines) = invalidate {+ // During a preview, retain old rows while marking them stale. This+ // prevents a blank flash as a full-screen application redraws.self.invalidate_line_cache(preserve_lines);- } else {- self.dimensions = delta.dimensions;}self.title = delta.title;self.working_dir = delta.working_dir.map(Into::into);@@ -527,6 +561,53 @@ impl RenderableInner {true}+ pub(crate) fn begin_frontend_preview(+ &mut self,+ epoch: u64,+ size: wezterm_term::TerminalSize,+ ) -> bool {+ if self+ .frontend_preview+ .is_some_and(|preview| preview.epoch > epoch)+ {+ return false;+ }+ self.frontend_preview = Some(FrontendPreviewGeometry { epoch, size });+ if render_dimensions_match_terminal_size(self.dimensions, size) {+ return false;+ }+ self.dimensions.cols = size.cols;+ self.dimensions.viewport_rows = size.rows;+ self.dimensions.pixel_width = size.pixel_width;+ self.dimensions.pixel_height = size.pixel_height;+ self.dimensions.dpi = size.dpi;+ true+ }++ pub(crate) fn server_geometry_matches(&self, size: wezterm_term::TerminalSize) -> bool {+ render_dimensions_match_terminal_size(self.server_dimensions, size)+ }++ pub(crate) fn end_frontend_preview(&mut self, epoch: u64, succeeded: bool) -> bool {+ let Some(preview) = self.frontend_preview else {+ return false;+ };+ if preview.epoch != epoch {+ return false;+ }+ self.frontend_preview = None;+ if succeeded && self.server_geometry_matches(preview.size) {+ self.dimensions = self.server_dimensions;+ return true;+ }+ if !succeeded && render_geometry_changed(self.dimensions, self.server_dimensions) {+ let preserve_lines = self.dimensions.cols == self.server_dimensions.cols;+ self.dimensions = self.server_dimensions;+ self.invalidate_line_cache(preserve_lines);+ }+ true+ }+fn make_stale(&mut self, stable_row: StableRowIndex) {match self.lines.pop(&stable_row) {Some(LineEntry::Stale(old))@@ -1066,6 +1147,21 @@ mod test {assert!(render_geometry_changed(current, new_dpi));}+ #[test]+ fn server_updates_cannot_replace_a_pinned_preview_grid() {+ let server = dimensions(80, 24, 96);+ let preview = dimensions(140, 42, 96);+ let next_server = dimensions(100, 30, 96);++ let (visible, invalidation) = resolve_server_geometry(preview, server, next_server, true);+ assert_eq!(visible, preview);+ assert_eq!(invalidation, Some(true));++ let (visible, invalidation) = resolve_server_geometry(server, server, next_server, false);+ assert_eq!(visible, next_server);+ assert_eq!(invalidation, Some(false));+ }+#[test]fn server_geometry_confirmation_requires_the_complete_terminal_size() {let expected = wezterm_term::TerminalSize {diff --git a/wezterm-gui/i18n/en-US.ftl b/wezterm-gui/i18n/en-US.ftlindex 0e8aa840..2b277ce5 100644--- a/wezterm-gui/i18n/en-US.ftl+++ b/wezterm-gui/i18n/en-US.ftl@@ -102,6 +102,11 @@ settings-terminal-native-font-size = ThinkTerm Font Sizesettings-terminal-native-font-size-description = Saved locally and applied immediately to open terminal windows.settings-terminal-native-font-family = Native Font Familysettings-terminal-native-font-family-description = Local quick-setting draft. Persistence and terminal application are pending.+settings-remote-pane-resize-mode = Remote Split Resize+settings-remote-pane-resize-mode-description = Auto follows live when the mux is fast and sends once on release when the connection is slow.+settings-remote-pane-resize-mode-auto = Auto+settings-remote-pane-resize-mode-live = Live+settings-remote-pane-resize-mode-on-release = On releasesettings-bottom-quote = Bottom Quotesettings-bottom-quote-description = Shows a small quote in the existing bottom gutter.settings-quote-font-size = Quote Font Sizediff --git a/wezterm-gui/i18n/fr-FR.ftl b/wezterm-gui/i18n/fr-FR.ftlindex 688a43b2..274605aa 100644--- a/wezterm-gui/i18n/fr-FR.ftl+++ b/wezterm-gui/i18n/fr-FR.ftl@@ -102,6 +102,11 @@ settings-terminal-native-font-size = Taille de police ThinkTermsettings-terminal-native-font-size-description = Enregistrée localement et appliquée immédiatement aux fenêtres de terminal ouvertes.settings-terminal-native-font-family = Famille de police nativesettings-terminal-native-font-family-description = Brouillon de réglage rapide local. L’enregistrement et l’application au terminal sont à venir.+settings-remote-pane-resize-mode = Redimensionnement des divisions distantes+settings-remote-pane-resize-mode-description = Auto synchronise en direct lorsque le mux est rapide et une seule fois au relâchement sur une connexion lente.+settings-remote-pane-resize-mode-auto = Auto+settings-remote-pane-resize-mode-live = Direct+settings-remote-pane-resize-mode-on-release = Au relâchementsettings-bottom-quote = Citation inférieuresettings-bottom-quote-description = Affiche une courte citation dans la marge inférieure existante.settings-quote-font-size = Taille de la citationdiff --git a/wezterm-gui/i18n/ja-JP.ftl b/wezterm-gui/i18n/ja-JP.ftlindex beac9f42..005561b5 100644--- a/wezterm-gui/i18n/ja-JP.ftl+++ b/wezterm-gui/i18n/ja-JP.ftl@@ -102,6 +102,11 @@ settings-terminal-native-font-size = ThinkTerm のフォントサイズsettings-terminal-native-font-size-description = ローカルに保存し、開いているターミナルウィンドウへすぐ適用します。settings-terminal-native-font-family = ネイティブフォントファミリーsettings-terminal-native-font-family-description = ローカルのクイック設定案です。保存とターミナルへの適用は未対応です。+settings-remote-pane-resize-mode = リモート分割のサイズ変更+settings-remote-pane-resize-mode-description = 自動では mux が速いときはライブ同期し、遅い接続では離したときに一度だけ同期します。+settings-remote-pane-resize-mode-auto = 自動+settings-remote-pane-resize-mode-live = ライブ+settings-remote-pane-resize-mode-on-release = 離したときsettings-bottom-quote = 下部の引用文settings-bottom-quote-description = 既存の下部余白に短い引用文を表示します。settings-quote-font-size = 引用文のフォントサイズdiff --git a/wezterm-gui/i18n/zh-CN.ftl b/wezterm-gui/i18n/zh-CN.ftlindex beb81c9a..35178056 100644--- a/wezterm-gui/i18n/zh-CN.ftl+++ b/wezterm-gui/i18n/zh-CN.ftl@@ -102,6 +102,11 @@ settings-terminal-native-font-size = ThinkTerm 字号settings-terminal-native-font-size-description = 本地保存,并立即应用于已打开的终端窗口。settings-terminal-native-font-family = 原生字体settings-terminal-native-font-family-description = 本地快速设置草稿;保存和应用到终端的功能尚未完成。+settings-remote-pane-resize-mode = 远程分屏缩放+settings-remote-pane-resize-mode-description = 自动模式在 mux 响应快时实时同步,网络较慢时只在松手后同步一次。+settings-remote-pane-resize-mode-auto = 自动+settings-remote-pane-resize-mode-live = 实时+settings-remote-pane-resize-mode-on-release = 松手后settings-bottom-quote = 底部语录settings-bottom-quote-description = 在现有底部留白中显示一条小语录。settings-quote-font-size = 语录字号diff --git a/wezterm-gui/src/native_settings.rs b/wezterm-gui/src/native_settings.rsindex 2a07620d..16ef8a4d 100644--- a/wezterm-gui/src/native_settings.rs+++ b/wezterm-gui/src/native_settings.rs@@ -166,6 +166,30 @@ pub(crate) enum NativeBottomQuoteMode {PseudoRandom,}+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize)]+#[serde(rename_all = "snake_case")]+pub(crate) enum NativeRemotePaneResizeMode {+ Auto,+ Live,+ OnRelease,+}++impl Default for NativeRemotePaneResizeMode {+ fn default() -> Self {+ Self::Auto+ }+}++impl NativeRemotePaneResizeMode {+ pub(crate) fn next(self) -> Self {+ match self {+ Self::Auto => Self::Live,+ Self::Live => Self::OnRelease,+ Self::OnRelease => Self::Auto,+ }+ }+}+impl Default for NativeBottomQuoteMode {fn default() -> Self {Self::Timed@@ -193,12 +217,17 @@ pub(crate) struct NativeAppearanceSettings {pub(crate) struct NativeTerminalSettings {pub(crate) font_size: Option<f64>,pub(crate) font_family: Option<String>,+ pub(crate) remote_pane_resize_mode: NativeRemotePaneResizeMode,pub(crate) bottom_quote_enabled: bool,pub(crate) bottom_quote_mode: NativeBottomQuoteMode,pub(crate) bottom_quote_interval_minutes: Option<u32>,pub(crate) bottom_quote_font_size: Option<f64>,}+pub(crate) fn remote_pane_resize_mode() -> NativeRemotePaneResizeMode {+ load().terminal.remote_pane_resize_mode+}+#[derive(Debug, Clone, Default, Deserialize, Serialize)]#[serde(default)]pub(crate) struct NativeChromeSettings {@@ -794,6 +823,34 @@ mod tests {);}+ #[test]+ fn older_settings_default_remote_pane_resize_to_auto() {+ let settings: ThinkTermNativeSettings = serde_json::from_str(r#"{"version":1}"#).unwrap();+ assert_eq!(+ settings.terminal.remote_pane_resize_mode,+ NativeRemotePaneResizeMode::Auto+ );+ }++ #[test]+ fn remote_pane_resize_modes_use_stable_snake_case_values() {+ for (mode, encoded) in [+ (NativeRemotePaneResizeMode::Auto, "auto"),+ (NativeRemotePaneResizeMode::Live, "live"),+ (NativeRemotePaneResizeMode::OnRelease, "on_release"),+ ] {+ let mut settings = ThinkTermNativeSettings::default();+ settings.terminal.remote_pane_resize_mode = mode;+ let value = serde_json::to_value(&settings).unwrap();+ assert_eq!(+ value["terminal"]["remote_pane_resize_mode"],+ serde_json::Value::String(encoded.to_string())+ );+ let decoded: ThinkTermNativeSettings = serde_json::from_value(value).unwrap();+ assert_eq!(decoded.terminal.remote_pane_resize_mode, mode);+ }+ }+#[test]fn older_settings_leave_application_language_unset_for_legacy_migration() {let settings: ThinkTermNativeSettings = serde_json::from_str(r#"{"version":1}"#).unwrap();diff --git a/wezterm-gui/src/settings_window.rs b/wezterm-gui/src/settings_window.rsindex 64e98de6..b04288e4 100644--- a/wezterm-gui/src/settings_window.rs+++ b/wezterm-gui/src/settings_window.rs@@ -36,9 +36,10 @@ use window::{};use crate::native_settings::{- NativeAppIcon, NativeBottomQuoteMode, NativeRendererBackend, NativeThemeMode,- ThinkTermNativeSettings, DEFAULT_HOME_FONT_SIZE, DEFAULT_PANE_HEADER_FONT_SIZE,- DEFAULT_SETTINGS_FONT_SIZE, DEFAULT_SIDEBAR_FONT_SIZE, DEFAULT_TAB_FONT_SIZE,+ NativeAppIcon, NativeBottomQuoteMode, NativeRemotePaneResizeMode, NativeRendererBackend,+ NativeThemeMode, ThinkTermNativeSettings, DEFAULT_HOME_FONT_SIZE,+ DEFAULT_PANE_HEADER_FONT_SIZE, DEFAULT_SETTINGS_FONT_SIZE, DEFAULT_SIDEBAR_FONT_SIZE,+ DEFAULT_TAB_FONT_SIZE,};use fluent_bundle::FluentArgs;@@ -356,6 +357,14 @@ fn localized_quote_mode_label(mode: NativeBottomQuoteMode) -> String {})}+fn localized_remote_pane_resize_mode_label(mode: NativeRemotePaneResizeMode) -> String {+ crate::i18n::tr(match mode {+ NativeRemotePaneResizeMode::Auto => "settings-remote-pane-resize-mode-auto",+ NativeRemotePaneResizeMode::Live => "settings-remote-pane-resize-mode-live",+ NativeRemotePaneResizeMode::OnRelease => "settings-remote-pane-resize-mode-on-release",+ })+}+fn settings_tr(id: &'static str, values: &[(&'static str, String)]) -> String {let mut args = FluentArgs::new();for (name, value) in values {@@ -399,6 +408,7 @@ enum SettingsAction {RestartApplication,QuitApplication,ToggleBottomQuote,+ CycleRemotePaneResizeMode,CycleBottomQuoteMode,DecreaseBottomQuoteFontSize,IncreaseBottomQuoteFontSize,@@ -3048,6 +3058,39 @@ impl SettingsWindow {};self.save_and_apply_bottom_quote_settings(status);}+ SettingsAction::CycleRemotePaneResizeMode => {+ self.ui.open_dropdown = None;+ self.native_settings.terminal.remote_pane_resize_mode =+ self.native_settings.terminal.remote_pane_resize_mode.next();+ match crate::native_settings::save(&self.native_settings) {+ Ok(()) => {+ if let Some(front_end) = crate::frontend::try_front_end() {+ front_end.invalidate_all_windows();+ }+ self.status = settings_tr(+ "settings-status-value-now",+ &[+ (+ "setting",+ crate::i18n::tr("settings-remote-pane-resize-mode"),+ ),+ (+ "value",+ localized_remote_pane_resize_mode_label(+ self.native_settings.terminal.remote_pane_resize_mode,+ ),+ ),+ ],+ );+ }+ Err(err) => {+ self.status = settings_tr(+ "settings-status-terminal-error",+ &[("error", format!("{err:#}"))],+ );+ }+ }+ }SettingsAction::CycleBottomQuoteMode => {self.ui.open_dropdown = None;self.native_settings.terminal.bottom_quote_mode =@@ -3470,11 +3513,11 @@ impl SettingsWindow {{let size = size.max(current_size);crate::perf::log_counter("settings_atlas_reallocate", size);- let recreated = self- .render_state- .as_mut()- .unwrap()- .recreate_texture_atlas(&self.fonts, &self.metrics, Some(size));+ let recreated = self.render_state.as_mut().unwrap().recreate_texture_atlas(+ &self.fonts,+ &self.metrics,+ Some(size),+ );// Every cached glyph now points into the old atlas,// whether or not the new one was allocated.self.invalidate_shaped_text();@@ -4429,8 +4472,8 @@ impl SettingsWindow {let row_step = self.settings_row_step();let section_y = self.ui_px(CONTENT_SECTION_Y) - scroll;// Each settings card owns its row count because rows are painted manually.- // Terminal currently paints eight rows below; the count drives card height and scroll extent.- let row_count = 8;+ // Terminal currently paints nine rows below; the count drives card height and scroll extent.+ let row_count = 9;let (card_y, first_row_y) = self.settings_card_geometry(section_y, row_count);let card_height = self.settings_card_height(row_count);let button_y = card_y + card_height + self.settings_section_card_gap();@@ -4518,11 +4561,24 @@ impl SettingsWindow {SettingsAction::FontFamilyInput,true,)?;- self.paint_toggle_setting_row(+ self.paint_action_setting_row(layers,row_x,first_row_y + row_step * 4.0,row_width,+ &crate::i18n::tr("settings-remote-pane-resize-mode"),+ &crate::i18n::tr("settings-remote-pane-resize-mode-description"),+ &localized_remote_pane_resize_mode_label(+ self.native_settings.terminal.remote_pane_resize_mode,+ ),+ SettingsAction::CycleRemotePaneResizeMode,+ true,+ )?;+ self.paint_toggle_setting_row(+ layers,+ row_x,+ first_row_y + row_step * 5.0,+ row_width,&crate::i18n::tr("settings-bottom-quote"),&crate::i18n::tr("settings-bottom-quote-description"),self.native_settings.terminal.bottom_quote_enabled,@@ -4532,7 +4588,7 @@ impl SettingsWindow {self.paint_font_size_stepper_row(layers,row_x,- first_row_y + row_step * 5.0,+ first_row_y + row_step * 6.0,row_width,&crate::i18n::tr("settings-quote-font-size"),&crate::i18n::tr("settings-quote-font-size-description"),@@ -4546,7 +4602,7 @@ impl SettingsWindow {self.paint_action_setting_row(layers,row_x,- first_row_y + row_step * 6.0,+ first_row_y + row_step * 7.0,row_width,&crate::i18n::tr("settings-quote-rotation"),&crate::i18n::tr("settings-quote-rotation-description"),@@ -4557,7 +4613,7 @@ impl SettingsWindow {self.paint_font_size_stepper_row(layers,row_x,- first_row_y + row_step * 7.0,+ first_row_y + row_step * 8.0,row_width,&crate::i18n::tr("settings-quote-interval"),&crate::i18n::tr("settings-quote-interval-description"),diff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rsindex 6f6ee81f..7ac06367 100644--- a/wezterm-gui/src/termwindow/mod.rs+++ b/wezterm-gui/src/termwindow/mod.rs@@ -1311,6 +1311,33 @@ pub(crate) struct FrontendRecoveryGeometry {pub(crate) generation: u64,}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum RemoteDividerResizeStrategy {+ Live,+ OnRelease,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub(crate) struct PreparedRemoteDividerGeometry {+ pub(crate) viewport: codec::ClientViewport,+ pub(crate) panes: Vec<(PaneId, TerminalSize)>,+}++#[derive(Debug, Clone)]+pub(crate) struct RemoteDividerResizeStream {+ pub(crate) epoch: u64,+ pub(crate) strategy: RemoteDividerResizeStrategy,+ pub(crate) domain_id: DomainId,+ pub(crate) connection_generation: u64,+ pub(crate) claim_first: bool,+ pub(crate) finishing: bool,+ pub(crate) latest: PreparedRemoteDividerGeometry,+ pub(crate) pending: Option<PreparedRemoteDividerGeometry>,+ pub(crate) in_flight: Option<codec::ClientViewport>,+ pub(crate) last_acknowledged: Option<codec::ClientViewport>,+ pub(crate) final_acknowledged_at: Option<Instant>,+}+pub struct TermWindow {pub window: Option<Window>,pub config: ConfigHandle,@@ -1339,6 +1366,10 @@ pub struct TermWindow {/// epoch reaches the normal local render-surface confirmation point.frontend_recovery_geometry: HashMap<TabId, FrontendRecoveryGeometry>,frontend_geometry_resync_after_epoch: HashSet<TabId>,+ /// Latest-only full-viewport streams for native divider drags. A stream+ /// owns the matching ClientPane preview epoch until its final target is+ /// confirmed or explicitly rolled back.+ remote_divider_resize_streams: HashMap<TabId, RemoteDividerResizeStream>,next_frontend_geometry_epoch: u64,frontend_viewport_report_pending: Arc<AtomicBool>,/// A blocked press is consumed even if the takeover round-trip completes@@ -1788,6 +1819,7 @@ impl TermWindow {}fn close_requested(&mut self, window: &Window) {+ self.cancel_remote_divider_resizes_except(None);self.flush_right_sidebar_note_blocking();self.persist_workspace_layout_after_mutation("window close requested");@@ -1870,6 +1902,14 @@ impl TermWindow {self.right_sidebar_file_drag = None;self.pane_tab_drag = None;self.sidebar_row_drag = None;+ let lost_split_drag = self+ .dragging+ .as_ref()+ .is_some_and(|(item, _)| matches!(item.item_type, UIItemType::Split(_)));+ if lost_split_drag {+ self.finish_remote_split_drag();+ self.persist_workspace_layout_after_mutation("split drag lost focus");+ }self.dragging = None;}@@ -2083,6 +2123,7 @@ impl TermWindow {frontend_geometry_confirmations: HashMap::new(),frontend_recovery_geometry: HashMap::new(),frontend_geometry_resync_after_epoch: HashSet::new(),+ remote_divider_resize_streams: HashMap::new(),next_frontend_geometry_epoch: 1,frontend_viewport_report_pending: Arc::new(AtomicBool::new(false)),frontend_handoff_consumed_press: false,@@ -3197,6 +3238,7 @@ impl TermWindow {return;}+ self.cancel_remote_divider_resizes_except(None);self.mux_window_id = mux_window_id;*self.mux_window_id_for_subscriptions.lock().unwrap() = mux_window_id;diff --git a/wezterm-gui/src/termwindow/mouseevent.rs b/wezterm-gui/src/termwindow/mouseevent.rsindex a5b60997..1985497a 100644--- a/wezterm-gui/src/termwindow/mouseevent.rs+++ b/wezterm-gui/src/termwindow/mouseevent.rs@@ -1405,7 +1405,7 @@ impl super::TermWindow {.as_ref().is_some_and(|(item, _)| matches!(item.item_type, UIItemType::Split(_))){- self.sync_active_tab_geometry_now();+ self.finish_remote_split_drag();self.persist_workspace_layout_after_mutation("split drag released");}if completed_drag.as_ref().is_some_and(|(item, _)| {diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rsindex b1b2d77c..cf93cc19 100644--- a/wezterm-gui/src/termwindow/resize.rs+++ b/wezterm-gui/src/termwindow/resize.rs@@ -11,8 +11,10 @@ use mux::Mux;use std::collections::HashMap;use std::rc::Rc;use std::sync::Arc;-use std::time::Duration;-use wezterm_client::domain::{ClientDomain, FrontendRecoverySlot, RemoteFrontendGate};+use std::time::{Duration, Instant};+use wezterm_client::domain::{+ AutomaticRemotePaneResize, ClientDomain, FrontendRecoverySlot, RemoteFrontendGate,+};use wezterm_client::pane::ClientPane;use wezterm_font::FontConfiguration;use wezterm_term::TerminalSize;@@ -37,6 +39,23 @@ fn frontend_geometry_action(}}+fn remote_divider_target_is_owed(+ in_flight: Option<&codec::ClientViewport>,+ acknowledged: Option<&codec::ClientViewport>,+ target: &codec::ClientViewport,+) -> bool {+ in_flight != Some(target) && acknowledged != Some(target)+}++fn remote_divider_can_pump(+ strategy: super::RemoteDividerResizeStrategy,+ finishing: bool,+ in_flight: bool,+ has_pending: bool,+) -> bool {+ !in_flight && has_pending && (strategy == super::RemoteDividerResizeStrategy::Live || finishing)+}+// 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.@@ -417,6 +436,18 @@ impl super::TermWindow {Arc<dyn Domain>,codec::ClientViewport,Vec<(PaneId, TerminalSize)>,+ )> {+ self.prepare_client_frontend_geometry_with_preview(tab, None)+ }++ fn prepare_client_frontend_geometry_with_preview(+ &mut self,+ tab: &Arc<mux::tab::Tab>,+ preview_epoch: Option<u64>,+ ) -> Option<(+ Arc<dyn Domain>,+ codec::ClientViewport,+ Vec<(PaneId, TerminalSize)>,)> {if !self.active_tab_is(tab.tab_id()) {return None;@@ -460,8 +491,12 @@ impl super::TermWindow {}for (pane_id, size) in &adopted {let pane = Mux::get().get_pane(*pane_id)?;- pane.downcast_ref::<ClientPane>()?- .adopt_frontend_geometry(*size);+ let pane = pane.downcast_ref::<ClientPane>()?;+ if let Some(epoch) = preview_epoch {+ pane.preview_frontend_geometry(epoch, *size);+ } else {+ pane.adopt_frontend_geometry(*size);+ }}Some((@@ -475,9 +510,9 @@ impl super::TermWindow {}/// 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.+ /// dragged. The selected policy is frozen at drag start: Live pumps at+ /// most one RPC plus one replaceable newest target; OnRelease only keeps+ /// the local pinned preview until the drag ends.pub(crate) fn preview_active_tab_geometry_now(&mut self) {if self.content_view_foreground() {return;@@ -500,18 +535,368 @@ impl super::TermWindow {if mode == Some(mux::FrontendAccessMode::Handoff) && ownership != Some(true) {return;}- if self.prepare_client_frontend_geometry(&tab).is_none() {+ let epoch = if let Some(stream) = self.remote_divider_resize_streams.get(&tab_id) {+ stream.epoch+ } else {+ let epoch = self.next_frontend_geometry_epoch;+ self.next_frontend_geometry_epoch =+ self.next_frontend_geometry_epoch.wrapping_add(1).max(1);+ epoch+ };+ let Some((domain, viewport, panes)) =+ self.prepare_client_frontend_geometry_with_preview(&tab, Some(epoch))+ else {return;+ };+ let Some(client_domain) = domain.downcast_ref::<ClientDomain>() else {+ return;+ };+ let Some(connection_generation) = client_domain.connection_generation() else {+ return;+ };+ let prepared = super::PreparedRemoteDividerGeometry { viewport, panes };++ if let Some(stream) = self.remote_divider_resize_streams.get_mut(&tab_id) {+ stream.latest = prepared.clone();+ stream.pending = remote_divider_target_is_owed(+ stream.in_flight.as_ref(),+ stream.last_acknowledged.as_ref(),+ &prepared.viewport,+ )+ .then_some(prepared);+ } else {+ let pane_is_tardy = self.get_panes_to_render().into_iter().any(|positioned| {+ positioned+ .pane+ .downcast_ref::<ClientPane>()+ .is_some_and(ClientPane::is_remote_tardy)+ });+ let strategy = match crate::native_settings::remote_pane_resize_mode() {+ crate::native_settings::NativeRemotePaneResizeMode::Live => {+ super::RemoteDividerResizeStrategy::Live+ }+ crate::native_settings::NativeRemotePaneResizeMode::OnRelease => {+ super::RemoteDividerResizeStrategy::OnRelease+ }+ crate::native_settings::NativeRemotePaneResizeMode::Auto => {+ match client_domain.automatic_remote_pane_resize(pane_is_tardy) {+ AutomaticRemotePaneResize::Live => super::RemoteDividerResizeStrategy::Live,+ AutomaticRemotePaneResize::OnRelease => {+ super::RemoteDividerResizeStrategy::OnRelease+ }+ }+ }+ };+ let collaborative = mode == Some(mux::FrontendAccessMode::TmuxLatest);+ self.remote_divider_resize_streams.insert(+ tab_id,+ super::RemoteDividerResizeStream {+ epoch,+ strategy,+ domain_id: domain.domain_id(),+ connection_generation,+ claim_first: collaborative && ownership == Some(false),+ finishing: false,+ latest: prepared.clone(),+ pending: Some(prepared),+ in_flight: None,+ last_acknowledged: None,+ final_acknowledged_at: None,+ },+ );}- 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_confirmations.remove(&tab_id);self.frontend_geometry_phases.insert(tab_id, super::FrontendGeometryPhase::Previewing { epoch });+ self.pump_remote_divider_resize(tab_id);self.invalidate_window();}+ fn pump_remote_divider_resize(&mut self, tab_id: mux::tab::TabId) {+ let Some(stream) = self.remote_divider_resize_streams.get_mut(&tab_id) else {+ return;+ };+ if !remote_divider_can_pump(+ stream.strategy,+ stream.finishing,+ stream.in_flight.is_some(),+ stream.pending.is_some(),+ ) {+ return;+ }+ let Some(prepared) = stream.pending.take() else {+ return;+ };+ let epoch = stream.epoch;+ let domain_id = stream.domain_id;+ let generation = stream.connection_generation;+ let claim = stream.claim_first;+ stream.claim_first = false;+ stream.in_flight = Some(prepared.viewport.clone());++ let Some(domain) = Mux::get().get_domain(domain_id) else {+ self.abort_remote_divider_resize(tab_id, epoch, true);+ return;+ };+ let Some(client_domain) = domain.downcast_ref::<ClientDomain>() else {+ self.abort_remote_divider_resize(tab_id, epoch, true);+ return;+ };+ if client_domain.connection_generation() != Some(generation) {+ self.abort_remote_divider_resize(tab_id, epoch, true);+ return;+ }+ self.remember_gui_recovery_intent(client_domain, tab_id, &prepared.viewport);+ let Some(window) = self.window.as_ref().cloned() else {+ self.abort_remote_divider_resize(tab_id, epoch, false);+ return;+ };+ let sent = prepared.viewport.clone();+ promise::spawn::spawn(async move {+ let succeeded = match domain.downcast_ref::<ClientDomain>() {+ Some(client_domain)+ if client_domain.connection_generation() == Some(generation) =>+ {+ let result = if claim {+ client_domain+ .claim_client_viewport(tab_id, sent.clone())+ .await+ } else {+ client_domain+ .set_client_viewport(tab_id, sent.clone())+ .await+ };+ if let Err(err) = &result {+ log::warn!("streaming remote divider resize: {err:#}");+ }+ result.is_ok() && client_domain.owns_remote_viewport(tab_id) == Some(true)+ }+ Some(_) | None => false,+ };+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ term_window+ .remote_divider_resize_rpc_finished(tab_id, epoch, generation, sent, succeeded);+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }++ fn remote_divider_resize_rpc_finished(+ &mut self,+ tab_id: mux::tab::TabId,+ epoch: u64,+ generation: u64,+ sent: codec::ClientViewport,+ succeeded: bool,+ ) {+ let valid = self+ .remote_divider_resize_streams+ .get(&tab_id)+ .is_some_and(|stream| {+ stream.epoch == epoch+ && stream.connection_generation == generation+ && stream.in_flight.as_ref() == Some(&sent)+ });+ if !valid {+ return;+ }+ if !succeeded || !self.active_tab_is(tab_id) {+ self.abort_remote_divider_resize(tab_id, epoch, true);+ return;+ }++ let mut should_pump = false;+ let mut should_confirm = false;+ if let Some(stream) = self.remote_divider_resize_streams.get_mut(&tab_id) {+ stream.in_flight = None;+ stream.last_acknowledged = Some(sent);+ if stream.pending.is_some() {+ should_pump = true;+ } else if stream.finishing+ && stream.last_acknowledged.as_ref() == Some(&stream.latest.viewport)+ {+ stream+ .final_acknowledged_at+ .get_or_insert_with(Instant::now);+ should_confirm = true;+ }+ }+ if should_pump {+ self.pump_remote_divider_resize(tab_id);+ } else if should_confirm {+ self.confirm_remote_divider_resize(tab_id, epoch);+ }+ }++ pub(crate) fn finish_remote_split_drag(&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 (epoch, should_confirm) = {+ let Some(stream) = self.remote_divider_resize_streams.get_mut(&tab_id) else {+ self.sync_active_tab_geometry_now();+ return;+ };+ stream.finishing = true;+ if remote_divider_target_is_owed(+ stream.in_flight.as_ref(),+ stream.last_acknowledged.as_ref(),+ &stream.latest.viewport,+ ) {+ stream.pending = Some(stream.latest.clone());+ }+ let should_confirm = stream.in_flight.is_none()+ && stream.pending.is_none()+ && stream.last_acknowledged.as_ref() == Some(&stream.latest.viewport);+ if should_confirm {+ stream+ .final_acknowledged_at+ .get_or_insert_with(Instant::now);+ }+ (stream.epoch, should_confirm)+ };+ self.pump_remote_divider_resize(tab_id);+ if should_confirm {+ self.confirm_remote_divider_resize(tab_id, epoch);+ }+ }++ fn confirm_remote_divider_resize(&mut self, tab_id: mux::tab::TabId, epoch: u64) {+ let Some(stream) = self.remote_divider_resize_streams.get(&tab_id) else {+ return;+ };+ if stream.epoch != epoch || !stream.finishing || stream.in_flight.is_some() {+ return;+ }+ let generation = stream.connection_generation;+ let domain_id = stream.domain_id;+ let panes = stream.latest.panes.clone();+ let started = stream.final_acknowledged_at.unwrap_or_else(Instant::now);+ let domain_generation_matches = Mux::get().get_domain(domain_id).and_then(|domain| {+ domain+ .downcast_ref::<ClientDomain>()+ .and_then(ClientDomain::connection_generation)+ }) == Some(generation);+ let mut ready = domain_generation_matches && !panes.is_empty();+ for (pane_id, size) in &panes {+ let pane_ready = Mux::get()+ .get_pane(*pane_id)+ .and_then(|pane| {+ pane.downcast_ref::<ClientPane>().map(|client| {+ let matches = client.server_geometry_matches(*size);+ if !matches {+ let _ = client.prime_frontend_geometry(*size);+ }+ matches+ })+ })+ .unwrap_or(false);+ ready &= pane_ready;+ }+ if ready {+ self.complete_remote_divider_resize(tab_id, epoch);+ return;+ }+ if started.elapsed() >= Duration::from_secs(2) {+ log::warn!("remote divider resize did not converge for tab {tab_id}");+ self.abort_remote_divider_resize(tab_id, epoch, true);+ return;+ }+ let Some(window) = self.window.as_ref().cloned() else {+ self.abort_remote_divider_resize(tab_id, epoch, false);+ return;+ };+ promise::spawn::spawn(async move {+ smol::Timer::after(Duration::from_millis(25)).await;+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ term_window.confirm_remote_divider_resize(tab_id, epoch);+ })));+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }++ fn complete_remote_divider_resize(&mut self, tab_id: mux::tab::TabId, epoch: u64) {+ let Some(stream) = self.remote_divider_resize_streams.remove(&tab_id) else {+ return;+ };+ if stream.epoch != epoch {+ self.remote_divider_resize_streams.insert(tab_id, stream);+ return;+ }+ for (pane_id, size) in &stream.latest.panes {+ if let Some(pane) = Mux::get().get_pane(*pane_id) {+ if let Some(client) = pane.downcast_ref::<ClientPane>() {+ client.finish_frontend_geometry_preview(epoch, *size, true);+ }+ }+ }+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .is_some_and(|phase| phase.epoch() == epoch)+ {+ self.frontend_geometry_phases.remove(&tab_id);+ }+ self.update_title_post_status();+ self.invalidate_window();+ }++ fn abort_remote_divider_resize(&mut self, tab_id: mux::tab::TabId, epoch: u64, resync: bool) {+ let Some(stream) = self.remote_divider_resize_streams.remove(&tab_id) else {+ return;+ };+ if stream.epoch != epoch {+ self.remote_divider_resize_streams.insert(tab_id, stream);+ return;+ }+ for (pane_id, size) in &stream.latest.panes {+ if let Some(pane) = Mux::get().get_pane(*pane_id) {+ if let Some(client) = pane.downcast_ref::<ClientPane>() {+ client.finish_frontend_geometry_preview(epoch, *size, false);+ }+ }+ }+ if self+ .frontend_geometry_phases+ .get(&tab_id)+ .is_some_and(|phase| phase.epoch() == epoch)+ {+ self.frontend_geometry_phases.remove(&tab_id);+ }+ if resync {+ if let Some(domain) = Mux::get().get_domain(stream.domain_id) {+ promise::spawn::spawn(async move {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ if let Err(err) = client.resync().await {+ log::warn!("resyncing after failed divider resize: {err:#}");+ }+ }+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ }+ }+ self.update_title_post_status();+ self.invalidate_window();+ }++ pub(crate) fn cancel_remote_divider_resizes_except(&mut self, keep: Option<mux::tab::TabId>) {+ let stale = self+ .remote_divider_resize_streams+ .iter()+ .filter_map(|(tab_id, stream)| {+ (Some(*tab_id) != keep).then_some((*tab_id, stream.epoch))+ })+ .collect::<Vec<_>>();+ for (tab_id, epoch) in stale {+ self.abort_remote_divider_resize(tab_id, epoch, true);+ }+ }+/// 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@@ -945,6 +1330,7 @@ impl super::TermWindow {return;};let tab_id = tab.tab_id();+ self.cancel_remote_divider_resizes_except(Some(tab_id));let Some(active_pane) = tab.get_active_pane() else {return;};@@ -2095,10 +2481,10 @@ pub fn effective_right_padding(config: &ConfigHandle, context: DimensionContext)#[cfg(test)]mod frontend_geometry_tests {use super::{- frontend_geometry_action, geometry_confirmation_settled, FrontendGeometryAction,- FRONTEND_GEOMETRY_SETTLE,+ frontend_geometry_action, geometry_confirmation_settled, remote_divider_can_pump,+ remote_divider_target_is_owed, FrontendGeometryAction, FRONTEND_GEOMETRY_SETTLE,};- use crate::termwindow::FrontendGeometryPhase;+ use crate::termwindow::{FrontendGeometryPhase, RemoteDividerResizeStrategy};use std::time::{Duration, Instant};#[test]@@ -2161,4 +2547,50 @@ mod frontend_geometry_tests {&mut ready_since));}++ #[test]+ fn remote_divider_stream_has_one_in_flight_and_release_gates_slow_mode() {+ assert!(remote_divider_can_pump(+ RemoteDividerResizeStrategy::Live,+ false,+ false,+ true+ ));+ assert!(!remote_divider_can_pump(+ RemoteDividerResizeStrategy::Live,+ false,+ true,+ true+ ));+ assert!(!remote_divider_can_pump(+ RemoteDividerResizeStrategy::OnRelease,+ false,+ false,+ true+ ));+ assert!(remote_divider_can_pump(+ RemoteDividerResizeStrategy::OnRelease,+ true,+ false,+ true+ ));+ }++ #[test]+ fn remote_divider_latest_target_replaces_only_unsent_work() {+ let viewport = |cols| codec::ClientViewport::CellGrid {+ size: wezterm_term::TerminalSize {+ rows: 24,+ cols,+ pixel_width: cols * 10,+ pixel_height: 480,+ dpi: 96,+ },+ };+ let first = viewport(80);+ let latest = viewport(120);+ assert!(!remote_divider_target_is_owed(Some(&first), None, &first));+ assert!(remote_divider_target_is_owed(Some(&first), None, &latest));+ assert!(!remote_divider_target_is_owed(None, Some(&latest), &latest));+ }}