perf: compress idle terminal scrollback (#3556)

1 files changed, 158 insertions, 2 deletions

diff --git a/src/server/headless/tests/mod.rs b/src/server/headless/tests/mod.rs
index 29a4cfbf..77a16fc7 100644
--- a/src/server/headless/tests/mod.rs
+++ b/src/server/headless/tests/mod.rs
@@ -1578,6 +1578,108 @@ async fn repeated_layout_action_reapplies_controller_geometry() {
 }
 
 #[tokio::test]
+async fn public_close_reapplies_controller_geometry() {
+    let mut server = test_headless_server();
+    let mut workspace = crate::workspace::Workspace::test_new("public-close-geometry");
+    let first_pane = workspace.tabs[0].root_pane;
+    let second_pane = workspace.test_split(ratatui::layout::Direction::Vertical);
+    workspace.insert_test_runtime(
+        first_pane,
+        crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
+    );
+    workspace.insert_test_runtime(
+        second_pane,
+        crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
+    );
+    server.app.state.workspaces = vec![workspace];
+    server.app.state.active = Some(0);
+    server.app.state.selected = 0;
+    server.app.state.mode = crate::app::Mode::Terminal;
+    let second_pane_id = server.app.public_pane_id(0, second_pane).unwrap();
+
+    let (control, _) = connect_test_shell(&mut server, 66, 100, 30);
+    let _ = control.recv().expect("snapshot");
+    let shrunk = server.app.state.workspaces[0].test_runtimes[&first_pane].current_size();
+    assert!(shrunk.0 < 30);
+
+    let (respond_to, _response_rx) = std::sync::mpsc::channel();
+    assert!(
+        server.handle_api_request_with_shutdown_check(crate::api::ApiRequestMessage {
+            request: crate::api::schema::Request {
+                id: "public-close-geometry".into(),
+                method: crate::api::schema::Method::PaneClose(crate::api::schema::PaneTarget {
+                    pane_id: second_pane_id,
+                }),
+            },
+            respond_to,
+            response_write_complete: None,
+            stream_active: None,
+        })
+    );
+
+    let runtime = &server.app.state.workspaces[0].test_runtimes[&first_pane];
+    let grown = runtime.current_size();
+    assert!(grown.0 > shrunk.0);
+    assert_eq!(runtime.terminal_dimensions(), Some((grown.1, grown.0)));
+    assert_eq!(
+        runtime.scroll_metrics().unwrap().viewport_rows,
+        grown.0 as usize
+    );
+    shutdown_test_runtimes(&mut server);
+}
+
+#[tokio::test]
+async fn geometry_reapply_replaces_a_controller_that_left_the_tab() {
+    let mut server = test_headless_server();
+    let mut workspace = crate::workspace::Workspace::test_new("geometry-controller-viewer");
+    let first_pane = workspace.tabs[0].root_pane;
+    let second_tab = workspace.test_add_tab(Some("second"));
+    let second_pane = workspace.tabs[second_tab].root_pane;
+    let third_tab = workspace.test_add_tab(Some("third"));
+    let third_pane = workspace.tabs[third_tab].root_pane;
+    for pane_id in [first_pane, second_pane, third_pane] {
+        workspace.insert_test_runtime(
+            pane_id,
+            crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
+        );
+    }
+    server.app.state.workspaces = vec![workspace];
+    server.app.state.active = Some(0);
+    server.app.state.selected = 0;
+    server.app.state.mode = crate::app::Mode::Terminal;
+    let second_tab_id = server.app.public_tab_id(0, second_tab).unwrap();
+    let third_tab_id = server.app.public_tab_id(0, third_tab).unwrap();
+
+    let (first_control, _) = connect_test_shell(&mut server, 67, 100, 30);
+    let (second_control, _) = connect_test_shell(&mut server, 68, 70, 20);
+    let _ = first_control.recv().expect("first snapshot");
+    let _ = second_control.recv().expect("second snapshot");
+
+    assert!(server.focus_shell_client_on_tab(67, &second_tab_id));
+    assert!(server.claim_shell_tab_geometry(67, false));
+    assert!(server.focus_shell_client_on_tab(67, &third_tab_id));
+    assert!(server.claim_shell_tab_geometry(67, false));
+    assert!(server.focus_shell_client_on_tab(68, &second_tab_id));
+    assert_eq!(
+        server.tab_geometry_controllers.get(&second_tab_id),
+        Some(&67)
+    );
+    let stale_size = server.app.state.workspaces[0].test_runtimes[&second_pane].current_size();
+
+    assert!(server.reapply_controlled_shell_tab_geometry(false));
+
+    assert_eq!(
+        server.tab_geometry_controllers.get(&second_tab_id),
+        Some(&68)
+    );
+    assert_ne!(
+        server.app.state.workspaces[0].test_runtimes[&second_pane].current_size(),
+        stale_size
+    );
+    shutdown_test_runtimes(&mut server);
+}
+
+#[tokio::test]
 async fn client_shell_tabs_render_accept_input_and_resize_independently() {
     let mut server = test_headless_server();
     let mut workspace = crate::workspace::Workspace::test_new("independent-geometry");
@@ -3436,8 +3538,8 @@ async fn pane_death_reconciles_each_client_view_and_focus() {
         .public_tab_id(0, second_tab)
         .expect("second tab id");
 
-    let (first_control, _) = connect_matching_test_shell(&mut server, 71);
-    let (second_control, _) = connect_matching_test_shell(&mut server, 72);
+    let (first_control, _) = connect_test_shell(&mut server, 71, 100, 30);
+    let (second_control, _) = connect_test_shell(&mut server, 72, 70, 20);
     let _ = first_control.recv().expect("first snapshot");
     let _ = second_control.recv().expect("second snapshot");
     assert!(server.focus_shell_client_on_tab(72, &second_tab_id));
@@ -3464,6 +3566,60 @@ async fn pane_death_reconciles_each_client_view_and_focus() {
         second_input.try_recv().is_err(),
         "focus gain was duplicated"
     );
+    assert_eq!(
+        server.tab_geometry_controllers.get(&second_tab_id),
+        Some(&71)
+    );
+    let before_resize = server.app.state.workspaces[0].test_runtimes[&second_pane].current_size();
+    assert!(server.handle_server_event(ServerEvent::ClientShellResize {
+        client_id: 71,
+        surface_cols: 90,
+        surface_rows: 25,
+        cell_width_px: 0,
+        cell_height_px: 0,
+        pixel_mouse: false,
+    }));
+    assert_ne!(
+        server.app.state.workspaces[0].test_runtimes[&second_pane].current_size(),
+        before_resize
+    );
+    shutdown_test_runtimes(&mut server);
+}
+
+#[tokio::test]
+async fn pane_death_reapplies_controller_geometry() {
+    let mut server = test_headless_server();
+    let mut workspace = crate::workspace::Workspace::test_new("pane-death-geometry");
+    let first_pane = workspace.tabs[0].root_pane;
+    let dead_pane = workspace.test_split(ratatui::layout::Direction::Vertical);
+    workspace.insert_test_runtime(
+        first_pane,
+        crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
+    );
+    workspace.insert_test_runtime(
+        dead_pane,
+        crate::terminal::TerminalRuntime::test_with_screen_bytes(80, 24, b""),
+    );
+    server.app.state.workspaces = vec![workspace];
+    server.app.state.active = Some(0);
+    server.app.state.selected = 0;
+    server.app.state.mode = crate::app::Mode::Terminal;
+
+    let (control, _) = connect_test_shell(&mut server, 73, 185, 46);
+    let _ = control.recv().expect("snapshot");
+    let shrunk = server.app.state.workspaces[0].test_runtimes[&first_pane].current_size();
+    assert!(shrunk.0 < 46);
+
+    assert!(server.handle_internal_event_with_forwarding(AppEvent::PaneDied { pane_id: dead_pane }));
+
+    let runtime = &server.app.state.workspaces[0].test_runtimes[&first_pane];
+    let grown = runtime.current_size();
+    assert!(grown.0 > shrunk.0);
+    assert_eq!(runtime.terminal_dimensions(), Some((grown.1, grown.0)));
+    assert_eq!(
+        runtime.scroll_metrics().unwrap().viewport_rows,
+        grown.0 as usize
+    );
     shutdown_test_runtimes(&mut server);
 }