fix(tabs): clamp the "+" new-tab popup's hit-tests to its drawn position

The `+` new-tab popup (`NewTabMenu`) still had the clamp drift the shared
`clamped_position` helper set out to eliminate for the tab and file-
explorer menus: `render_new_tab_menu` hand-clamped `menu.position` when it
would overflow the right/bottom edge, while the hover and click hit-tests
used the raw, unclamped position. Opening the popup within
`NEW_TAB_MENU_WIDTH` of the right edge drew it shifted onto screen but left
its clickable/hoverable region anchored partly offscreen, so a click on a
visible item was treated as an outside-click and silently dismissed the
menu instead of activating it.

Give `NewTabMenu` the same `height()`/`clamped_position()` helpers as
`TabContextMenu` and route render + both hit-tests through them, clamping
against the last rendered frame size (as the tab menu already does) so
render and input always agree.

Regression test `plus_button_menu_near_right_edge_clicks_land_on_drawn_items`
fails without the hit-test fix.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GQYut8xrWsYyQffc4D84dz

Author: claude

crates/fresh-editor/src/app/mouse_input.rs

@@ -1028,11 +1028,16 @@ impl Editor {
 
         // Check the "+" new-tab popup menu (rendered on top)
         if let Some(ref menu) = self.active_window().new_tab_menu {
-            let menu_x = menu.position.0;
-            let menu_y = menu.position.1;
+            // Clamp against the last rendered frame size (mirrored from
+            // `frame.area()` each draw), matching the popup's render clamp — so
+            // a menu near the right/bottom edge hovers exactly where it draws.
+            let (menu_x, menu_y) = menu.clamped_position(
+                self.active_chrome().last_frame.width,
+                self.active_chrome().last_frame.height,
+            );
             let menu_width = super::types::NEW_TAB_MENU_WIDTH;
             let items = super::types::NewTabMenuItem::all();
-            let menu_height = items.len() as u16 + 2;
+            let menu_height = menu.height();
 
             if col >= menu_x
                 && col < menu_x + menu_width
@@ -3527,11 +3532,16 @@ impl Editor {
         col: u16,
         row: u16,
     ) -> Option<AnyhowResult<()>> {
-        let menu = self.active_window_mut().new_tab_menu.as_ref()?;
-        let (menu_x, menu_y) = menu.position;
+        // Clamp against the last rendered frame size, matching the popup's
+        // render and hover hit-test — during a resize `terminal_width/height`
+        // can lag `frame.area()`, drifting clicks off the drawn menu.
+        let frame_w = self.active_chrome().last_frame.width;
+        let frame_h = self.active_chrome().last_frame.height;
+        let menu = self.active_window().new_tab_menu.as_ref()?;
+        let (menu_x, menu_y) = menu.clamped_position(frame_w, frame_h);
         let items = super::types::NewTabMenuItem::all();
         let menu_width = super::types::NEW_TAB_MENU_WIDTH;
-        let menu_height = items.len() as u16 + 2; // items + borders
+        let menu_height = menu.height();
 
         // Click outside the menu closes it.
         if col < menu_x || col >= menu_x + menu_width || row < menu_y || row >= menu_y + menu_height

crates/fresh-editor/src/app/render.rs

@@ -3981,21 +3981,11 @@ impl Editor {
 
         let items = super::types::NewTabMenuItem::all();
         let menu_width = super::types::NEW_TAB_MENU_WIDTH;
-        let menu_height = items.len() as u16 + 2; // items + borders
-
-        let screen_width = frame.area().width;
-        let screen_height = frame.area().height;
+        let menu_height = menu.height();
 
-        let menu_x = if menu.position.0 + menu_width > screen_width {
-            screen_width.saturating_sub(menu_width)
-        } else {
-            menu.position.0
-        };
-        let menu_y = if menu.position.1 + menu_height > screen_height {
-            screen_height.saturating_sub(menu_height)
-        } else {
-            menu.position.1
-        };
+        // Shared clamp — the same helper hover and click hit-testing use, so
+        // the popup accepts input exactly where it draws.
+        let (menu_x, menu_y) = menu.clamped_position(frame.area().width, frame.area().height);
 
         let area = ratatui::layout::Rect::new(menu_x, menu_y, menu_width, menu_height);
 

crates/fresh-editor/src/app/types/context_menu.rs

@@ -180,6 +180,31 @@ impl NewTabMenu {
         }
     }
 
+    /// Menu height including the top/bottom borders.
+    pub fn height(&self) -> u16 {
+        NewTabMenuItem::all().len() as u16 + 2
+    }
+
+    /// Anchor position shifted so the menu fits on screen — the single source
+    /// of truth shared by rendering, hover, and click hit-testing, exactly as
+    /// [`TabContextMenu::clamped_position`]. Diverging copies would let the
+    /// popup draw shifted onto screen while its clickable region stayed
+    /// anchored offscreen.
+    pub fn clamped_position(&self, screen_width: u16, screen_height: u16) -> (u16, u16) {
+        let x = if self.position.0 + NEW_TAB_MENU_WIDTH > screen_width {
+            screen_width.saturating_sub(NEW_TAB_MENU_WIDTH)
+        } else {
+            self.position.0
+        };
+        let h = self.height();
+        let y = if self.position.1 + h > screen_height {
+            screen_height.saturating_sub(h)
+        } else {
+            self.position.1
+        };
+        (x, y)
+    }
+
     /// Move highlight down.
     pub fn next_item(&mut self) {
         let items = NewTabMenuItem::all();

crates/fresh-editor/tests/e2e/tab_new_button.rs

@@ -87,6 +87,59 @@ fn plus_button_pins_to_right_edge_on_overflow() {
     harness.assert_screen_contains("New File");
 }
 
+/// Near the right edge the popup clamps left so it fits on screen — and its
+/// click hit-test must clamp identically, or a click on the *drawn* item lands
+/// outside the menu's (unclamped) region and is treated as an outside-click.
+/// Regression: render clamped `menu.position` while the hit-tests used the raw
+/// position, so clicking a visible item near the edge silently dismissed the
+/// menu instead of activating it.
+#[test]
+fn plus_button_menu_near_right_edge_clicks_land_on_drawn_items() {
+    // Narrow bar + overflow pins the "+" (and thus the popup anchor) hard
+    // against the right edge, where `NEW_TAB_MENU_WIDTH` (18) overflows and
+    // forces the clamp.
+    let width: u16 = 50;
+    let mut harness = EditorTestHarness::new(width, 24).unwrap();
+    for _ in 0..8 {
+        harness.new_buffer().unwrap();
+    }
+    harness.render().unwrap();
+
+    let screen = harness.screen_to_string();
+    let plus_col = col_of_char_on_row(&screen, 1, '+').unwrap_or_else(|| {
+        panic!("expected a pinned '+' button on the tab row. Screen:\n{screen}")
+    });
+    assert!(
+        plus_col >= width - 3,
+        "precondition: '+' pinned near the right edge, got {plus_col}. Screen:\n{screen}"
+    );
+
+    harness.mouse_click(plus_col, 1).unwrap();
+    harness.assert_screen_contains("New File");
+
+    let buffers_before = harness.editor().active_window().buffers.len();
+
+    // Click "New File" where it is actually drawn (its clamped position). With
+    // the raw-position hit-test this click fell outside the menu → dismissed it
+    // with no new buffer; with the shared clamp it activates the item.
+    let screen = harness.screen_to_string();
+    let (nf_col, nf_row) = pos_of_substr(&screen, "New File")
+        .unwrap_or_else(|| panic!("expected 'New File' item in popup. Screen:\n{screen}"));
+    harness.mouse_click(nf_col + 1, nf_row).unwrap();
+
+    let screen = harness.screen_to_string();
+    assert!(
+        !screen.contains("New Terminal"),
+        "popup should be dismissed after selecting an item. Screen:\n{screen}"
+    );
+    assert_eq!(
+        harness.editor().active_window().buffers.len(),
+        buffers_before + 1,
+        "clicking the drawn 'New File' near the edge must create a buffer, \
+         not miss the item. Screen:\n{screen}"
+    );
+}
+
 #[test]
 fn plus_button_menu_captures_keyboard_and_filters_keys() {
     let mut harness = EditorTestHarness::new(120, 30).unwrap();