Fix: header menu scroll-race that caused drill-up button to vanish in CI

Increase the scroll-to-close guard delay in VirtualizedTableRenderer from
150 ms to 400 ms and the pre-click drain wait in open_header_menu from 300 ms
to 500 ms.  Under a 4-worker CI run the scroll event fired by scrollIntoView
routinely arrives 300–400 ms after the call, well past the old 150 ms guard,
closing the menu and stranding locator.evaluate for its full 30 s timeout.

Also add an explicit to_be_visible(15 s) guard inside click_menu_item so any
future regression surfaces as a clear assertion error instead of a silent hang.

Made-with: Cursor

Author: mayagbarnes

e2e_playwright/pivot_table_interactions_test.py

@@ -30,8 +30,15 @@
 ROW_HEADERS_REVENUE_DESC = ["South", "North", "West", "East"]
 
 
-def click_menu_item(locator) -> None:
-    """Click a menu item reliably even when the popover clips its viewport."""
+def click_menu_item(locator, timeout: int = 15000) -> None:
+    """Click a menu item reliably even when the popover clips its viewport.
+
+    Waits for the item to be visible before evaluating so that if the menu
+    closed between open_header_menu and this call (e.g. due to a stray scroll
+    event on a loaded CI runner) we get a clear assertion error quickly rather
+    than a 30 s Locator.evaluate hang.
+    """
+    expect(locator).to_be_visible(timeout=timeout)
     locator.evaluate(
         "el => { el.scrollIntoView({ block: 'center', inline: 'nearest' }); el.click(); }"
     )
@@ -111,19 +118,20 @@ def open_header_menu(page: Page, trigger_locator, menu_test_id: str):
     Scroll and click are intentionally separated by a short wait.  Even with
     ``behavior:'instant'``, browsers dispatch scroll events asynchronously — in
     Firefox and Chromium they can fire 200 ms+ after the scrollIntoView call.
-    Our React scroll-to-close listener has a 150 ms grace period after the menu
+    Our React scroll-to-close listener has a 400 ms grace period after the menu
     opens, but if the scroll event arrives later than that it closes the menu
     immediately.  By scrolling first, waiting for those events to drain, and
     only then clicking to open the menu, we ensure no scroll events are
-    in-flight when the listener registers.
+    in-flight when the listener registers.  500 ms comfortably outlasts delayed
+    scroll events on loaded CI runners.
     """
     expect(trigger_locator).to_be_attached(timeout=5000)
     menu = page.get_by_test_id(menu_test_id)
     for attempt in range(2):
         trigger_locator.evaluate(
             "el => el.scrollIntoView({ block: 'center', inline: 'nearest', behavior: 'instant' })"
         )
-        page.wait_for_timeout(300)  # let scroll events drain before opening menu
+        page.wait_for_timeout(500)  # let scroll events drain before opening menu
         trigger_locator.evaluate("el => el.click()")
         try:
             expect(menu).to_be_visible(timeout=5000)

streamlit_pivot/frontend/src/renderers/VirtualizedTableRenderer.tsx

@@ -537,10 +537,12 @@ const VirtualizedTableRenderer: FC<VirtualizedTableRendererProps> = ({
   // listen in the capture phase at the document root to catch scroll on the
   // wrapper, any descendant overflow container, or the window itself.
   //
-  // A 150 ms guard delay prevents stale scroll events that were queued
-  // synchronously during the click-to-open sequence (e.g. scrollIntoView
-  // followed by click) from immediately re-closing the menu before the user
-  // has had a chance to interact with it.
+  // A guard delay prevents stale scroll events that were queued during the
+  // click-to-open sequence (e.g. scrollIntoView followed by click) from
+  // immediately re-closing the menu before the user has had a chance to
+  // interact with it.  400 ms is chosen to comfortably outlast the browser's
+  // async scroll-event dispatch on both fast desktops and loaded CI runners;
+  // it is imperceptibly short from a UX perspective.
   useEffect(() => {
     if (!menuTarget) return;
     let listener: (() => void) | null = null;
@@ -551,7 +553,7 @@ const VirtualizedTableRenderer: FC<VirtualizedTableRendererProps> = ({
         passive: true,
         capture: true,
       });
-    }, 150);
+    }, 400);
     return () => {
       clearTimeout(timerId);
       if (listener)