gloomberb 0.9.2 → 0.9.3

package/src/components/input-search-bar.tsx

@@ -1,6 +1,9 @@
 import { useCallback, useEffect, useState, type RefObject } from "react";
 import { Box, Input, Text, type InputRenderable } from "../ui";
 import { colors } from "../theme/colors";
+import { useAppInputCapture } from "../state/app/input-capture";
+import { useShortcut } from "../react/input";
+import { isPlainArrowDown, stopSearchFocusNavigation } from "../utils/search-focus-navigation";
 
 export function InputSearchBar({
   value,
@@ -12,6 +15,7 @@ export function InputSearchBar({
   placeholder,
   debounceMs,
   normalizeValue = identity,
+  onNavigateDown,
   onFocus,
   onBlur,
   onQueryChange,
@@ -25,11 +29,23 @@ export function InputSearchBar({
   placeholder: string;
   debounceMs: number;
   normalizeValue?: (value: string) => string;
+  onNavigateDown?: () => void;
   onFocus: () => void;
   onBlur: () => void;
   onQueryChange: (query: string) => void;
 }) {
   const [draft, setDraft] = useState(value);
+  useAppInputCapture(focused && active);
+
+  useShortcut((event) => {
+    if (!onNavigateDown || !isPlainArrowDown(event)) return;
+    stopSearchFocusNavigation(event);
+    onNavigateDown();
+  }, {
+    allowEditable: true,
+    enabled: focused && active && !!onNavigateDown,
+    phase: "before",
+  });
 
   useEffect(() => {
     setDraft(value);

package/src/components/layout/shell/active-drag.ts

@@ -4,6 +4,7 @@ import {
   getRememberedFloatingRect,
   resizeSplitAtPath,
   simulateDrop,
+  type DockGeometryOptions,
   type DockLeafLayout,
   type DropTarget,
   type LayoutBounds,
@@ -32,6 +33,7 @@ interface UseShellActiveDragOptions {
   bounds: LayoutBounds;
   contentHeight: number;
   dispatch: Dispatch<AppAction>;
+  dockGeometryOptions: DockGeometryOptions;
   dockLeafLayouts: DockLeafLayout[];
   dragRuntime: ShellDragRuntimeState;
   focusPane: (paneId: string) => void;
@@ -51,6 +53,7 @@ export function useShellActiveDrag({
   bounds,
   contentHeight,
   dispatch,
+  dockGeometryOptions,
   dockLeafLayouts,
   dragRuntime,
   focusPane,
@@ -117,7 +120,7 @@ export function useShellActiveDrag({
           const hoveredCell = hoveredOverlay.cells.find((cell) => pointInRect(cell.rect, hitX, hitShellY));
           if (hoveredCell) {
             const target: DropTarget = { kind: "leaf", targetId: hoveredOverlay.targetId, position: hoveredCell.position };
-            const simulation = simulateDrop(baseLayout, drag.paneId, target, bounds);
+            const simulation = simulateDrop(baseLayout, drag.paneId, target, bounds, dockGeometryOptions);
             if (simulation.previewRect) {
               updateDockPreview({ kind: "dock", target, rect: simulation.previewRect });
             } else {
@@ -199,6 +202,7 @@ export function useShellActiveDrag({
     bounds,
     contentHeight,
     dispatch,
+    dockGeometryOptions,
     dividerPreviewRef,
     dockLeafLayouts,
     dockPreviewRef,

package/src/components/layout/shell/drag/runtime.ts

@@ -6,8 +6,10 @@ import {
   type MutableRefObject,
   type SetStateAction,
 } from "react";
+import { useRafCallback } from "../../../../react/use-raf-callback";
 import {
   type DockDividerLayout,
+  type DockGeometryOptions,
   type DockLeafLayout,
   type FloatingRect,
   type LayoutBounds,
@@ -91,17 +93,26 @@ export function useShellDragRuntimeState({
 }): ShellDragRuntimeState {
   const dragRef = useRef<DragMode | null>(null);
   const [dragFloatingRect, setDragFloatingRect] = useState<{ paneId: string; rect: FloatingRect } | null>(null);
+  const pendingDragFloatingRectRef = useRef<{ paneId: string; rect: FloatingRect } | null>(null);
   const [dragCursor, setDragCursor] = useState<{ x: number; y: number } | null>(null);
   const [dividerPreview, setDividerPreview] = useState<DividerPreviewState | null>(null);
   const [dockPreview, setDockPreview] = useState<DragPreview | null>(null);
   const dividerPreviewRef = useRef<DividerPreviewState | null>(null);
   const dockPreviewRef = useRef<DragPreview | null>(null);
+  const flushDragFloatingRect = useRafCallback(() => {
+    setDragFloatingRect(pendingDragFloatingRectRef.current);
+  });
 
   const updateDragFloatingRect = useCallback((next: { paneId: string; rect: FloatingRect } | null) => {
-    setDragFloatingRect(next
+    pendingDragFloatingRectRef.current = next
       ? { paneId: next.paneId, rect: constrainFloatingRectToBounds(next.rect, width, contentHeight) }
-      : null);
-  }, [contentHeight, width]);
+      : null;
+    if (!next) {
+      setDragFloatingRect(null);
+      return;
+    }
+    flushDragFloatingRect();
+  }, [contentHeight, flushDragFloatingRect, width]);
 
   const updateDividerPreview = useCallback((next: DividerPreviewState | null) => {
     dividerPreviewRef.current = next;
@@ -146,6 +157,7 @@ interface UseShellPointerRuntimeOptions {
   closePaneMenu: () => void;
   contentHeight: number;
   dispatch: Dispatch<AppAction>;
+  dockGeometryOptions: DockGeometryOptions;
   dockDividerLayouts: DockDividerLayout[];
   dockLeafLayouts: DockLeafLayout[];
   dragRuntime: ShellDragRuntimeState;
@@ -166,6 +178,7 @@ interface UseShellPointerRuntimeOptions {
   setHoveredMenuItemId: Dispatch<SetStateAction<string | null>>;
   setMenuState: Dispatch<SetStateAction<ActionMenuState | null>>;
   snapGuides: ReturnType<typeof makeSnapGuides>;
+  transientFocusActive: boolean;
   updateWindowModePreviewLayout: (nextLayout: LayoutConfig, paneId?: string) => void;
   visibleFloatingPanes: VisibleFloatingPane[];
   visibleLayout: LayoutConfig;
@@ -179,6 +192,7 @@ export function useShellPointerRuntime({
   closePaneMenu,
   contentHeight,
   dispatch,
+  dockGeometryOptions,
   dockDividerLayouts,
   dockLeafLayouts,
   dragRuntime,
@@ -195,6 +209,7 @@ export function useShellPointerRuntime({
   setHoveredMenuItemId,
   setMenuState,
   snapGuides,
+  transientFocusActive,
   updateWindowModePreviewLayout,
   visibleFloatingPanes,
   visibleLayout,
@@ -206,6 +221,7 @@ export function useShellPointerRuntime({
     bounds,
     contentHeight,
     dispatch,
+    dockGeometryOptions,
     dockLeafLayouts,
     focusPane,
     dragRuntime,
@@ -237,6 +253,7 @@ export function useShellPointerRuntime({
     selectWindowModePane,
     setHoveredMenuItemId,
     setMenuState,
+    transientFocusActive,
     visibleFloatingPanes,
     width,
     windowMode,
@@ -254,6 +271,7 @@ export function useShellPointerRuntime({
     selectWindowModePane,
     setHoveredMenuItemId,
     setMenuState,
+    transientFocusActive,
     windowMode,
   });
 

package/src/components/layout/shell/fullscreen.ts

@@ -0,0 +1,10 @@
+import { isPaneInLayout } from "../../../plugins/pane-manager";
+import { cloneLayout, type LayoutConfig } from "../../../types/config";
+
+export function resolvePaneFocusSourceLayout(
+  layout: LayoutConfig,
+  paneId: string | null,
+): LayoutConfig | null {
+  if (!paneId || !isPaneInLayout(layout, paneId)) return null;
+  return cloneLayout(layout);
+}

package/src/components/layout/shell/index.test.tsx

@@ -2,8 +2,14 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { TestDialogProvider, testRender } from "../../../renderers/opentui/test-utils";
 import { openTuiUiHost } from "../../../renderers/opentui/ui-host";
 import type { ReactNode } from "react";
-import { act, useReducer } from "react";
-import { AppContext, appReducer, createInitialState } from "../../../state/app/context";
+import { act, useReducer, useState } from "react";
+import {
+  AppContext,
+  appReducer,
+  createInitialState,
+  resolveTickerForPane,
+  usePaneTicker,
+} from "../../../state/app/context";
 import { cloneLayout, createDefaultConfig, TICKER_RESEARCH_PANE_ID, type LayoutConfig } from "../../../types/config";
 import type { PluginRegistry } from "../../../plugins/registry";
 import type { PaneProps } from "../../../types/plugin";
@@ -14,6 +20,8 @@ import {
   resolveAppHeaderHeightCells,
   Shell,
 } from "./index";
+import { resolvePaneFocusSourceLayout } from "./fullscreen";
+import { TransientLayoutProvider, useTransientLayout, type TransientLayoutState } from "../transient-layout";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -133,6 +141,44 @@ async function renderShellForWindowModeTest(
   return { actions, registry };
 }
 
+function CaptureTransientLayout({
+  controls,
+}: {
+  controls: { transientLayout: TransientLayoutState | null };
+}) {
+  const { transientLayout } = useTransientLayout();
+  controls.transientLayout = transientLayout;
+  return null;
+}
+
+function ShellTransientHarness({
+  initialState,
+  registry,
+  controls,
+}: {
+  initialState: ReturnType<typeof createInitialState>;
+  registry: PluginRegistry;
+  controls: {
+    dispatch?: (action: ShellTestAction) => void;
+    state?: ReturnType<typeof createInitialState>;
+    transientLayout: TransientLayoutState | null;
+  };
+}) {
+  const [state, dispatch] = useReducer(appReducer, initialState);
+  controls.dispatch = dispatch;
+  controls.state = state;
+  return (
+    <AppContext value={{ state, dispatch }}>
+      <TransientLayoutProvider>
+        <TestDialogProvider>
+          <Shell pluginRegistry={registry} />
+        </TestDialogProvider>
+        <CaptureTransientLayout controls={controls} />
+      </TransientLayoutProvider>
+    </AppContext>
+  );
+}
+
 function findUpdateLayout(actions: ShellTestAction[]) {
   return actions.find((action) => action.type === "UPDATE_LAYOUT");
 }
@@ -417,6 +463,7 @@ describe("Shell", () => {
     expect(resolvePaneManagementShortcut({ ...base, name: "o", key: "o" })).toBe("pop-out");
     expect(resolvePaneManagementShortcut({ ...base, name: "c", key: "c" })).toBe("copy-screenshot");
     expect(resolvePaneManagementShortcut({ ...base, name: "l", key: "l" })).toBe("layout-actions");
+    expect(resolvePaneManagementShortcut({ ...base, name: "f", key: "f" })).toBe("toggle-fullscreen");
     expect(resolvePaneManagementShortcut({ ...base, name: "g", key: "g" })).toBe("gridlock-all");
     expect(resolvePaneManagementShortcut({ ...base, name: "m", key: "m" })).toBe("window-mode");
     expect(resolvePaneManagementShortcut({ ...base, name: "r", key: "r" })).toBe("window-resize-mode");
@@ -425,6 +472,352 @@ describe("Shell", () => {
     expect(resolvePaneManagementShortcut({ ...base, name: "d", key: "d", meta: false, super: false })).toBeNull();
   });
 
+  test("toggles the focused pane fullscreen without persisting layout", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-fullscreen-shortcut-test");
+    const mainPane = requireLayoutInstance(config, "portfolio-list:main");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    const dockedLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      },
+      instances: [{ ...mainPane }, { ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    const { actions } = await renderShellForWindowModeTest(
+      createShellStateWithLayout(config, dockedLayout, "portfolio-list:main"),
+      { width: 80, height: 18 },
+    );
+
+    expect(testSetup.captureCharFrame()).toContain("Main Portfolio");
+    expect(testSetup.captureCharFrame()).toContain("Ticker Research Body");
+
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+    let frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Main Portfolio");
+    expect(frame).not.toContain("Ticker Research Body");
+    expect(actions.some((action) => action.type === "UPDATE_LAYOUT")).toBe(false);
+
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+    frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Main Portfolio");
+    expect(frame).toContain("Ticker Research Body");
+    expect(actions.some((action) => action.type === "UPDATE_LAYOUT")).toBe(false);
+  });
+
+  test("captures the source layout for transient pane focus", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-fullscreen-layout-test");
+    const layout = cloneLayout(config.layout);
+    layout.dockRoot = { kind: "pane", instanceId: "portfolio-list:main" };
+    layout.floating = [{ instanceId: "ticker-detail:main", x: 8, y: 2, width: 32, height: 10, zIndex: 75 }];
+
+    const focusedLayout = resolvePaneFocusSourceLayout(layout, "ticker-detail:main");
+
+    expect(focusedLayout).toMatchObject({
+      dockRoot: { kind: "pane", instanceId: "portfolio-list:main" },
+      floating: [{ instanceId: "ticker-detail:main", x: 8, y: 2, width: 32, height: 10, zIndex: 75 }],
+    });
+    expect(focusedLayout).not.toBe(layout);
+    expect(focusedLayout?.instances.map((instance) => instance.instanceId)).toEqual(
+      layout.instances.map((instance) => instance.instanceId),
+    );
+  });
+
+  test("locks layout-changing mouse drags while fullscreen is active", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-fullscreen-drag-test");
+    const mainPane = requireLayoutInstance(config, "portfolio-list:main");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    const dockedLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      },
+      instances: [{ ...mainPane }, { ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    const { actions } = await renderShellForWindowModeTest(
+      createShellStateWithLayout(config, dockedLayout, "portfolio-list:main"),
+      { width: 80, height: 18 },
+    );
+
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+    await act(async () => {
+      await testSetup!.mockMouse.drag(4, 0, 32, 4);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Main Portfolio");
+    expect(frame).not.toContain("Ticker Research Body");
+    expect(actions.some((action) => action.type === "UPDATE_LAYOUT")).toBe(false);
+  });
+
+  test("keeps focused pane local detail state when maximizing a floating pane", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-fullscreen-local-state-test");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    let openDetail: (() => void) | null = null;
+    const registry = createShellPluginRegistry({
+      tickerDetailComponent: () => {
+        const [detailOpen, setDetailOpen] = useState(false);
+        openDetail = () => setDetailOpen(true);
+        return <text>{detailOpen ? "Detail State" : "Table State"}</text>;
+      },
+    });
+    const floatingLayout = {
+      dockRoot: null,
+      instances: [{ ...detailPane }],
+      floating: [{ instanceId: "ticker-detail:main", x: 4, y: 2, width: 40, height: 10, zIndex: 50 }],
+      detached: [],
+    };
+    await renderShellForWindowModeTest(
+      createShellStateWithLayout(config, floatingLayout, "ticker-detail:main"),
+      { registry, width: 80, height: 18 },
+    );
+
+    await act(async () => {
+      openDetail?.();
+      await testSetup!.renderOnce();
+    });
+    expect(testSetup.captureCharFrame()).toContain("etail State");
+
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("etail State");
+    expect(frame).not.toContain("able State");
+  });
+
+  test("allows pane fullscreen shortcut while text input is captured on desktop", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-fullscreen-captured-input-test");
+    const mainPane = requireLayoutInstance(config, "portfolio-list:main");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    const dockedLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      },
+      instances: [{ ...mainPane }, { ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    const { actions } = await renderShellForWindowModeTest(
+      {
+        ...createShellStateWithLayout(config, dockedLayout, "portfolio-list:main"),
+        inputCaptured: true,
+      },
+      { width: 80, height: 18 },
+    );
+
+    await emitKeypress({
+      name: "f",
+      key: "f",
+      meta: true,
+      super: true,
+      shift: true,
+      targetEditable: true,
+    } as any);
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Main Portfolio");
+    expect(frame).not.toContain("Ticker Research Body");
+    expect(actions.some((action) => action.type === "UPDATE_LAYOUT")).toBe(false);
+  });
+
+  test("keeps the transient focus layout available after switching saved layouts", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-transient-focus-layout-tab-test");
+    const mainPane = requireLayoutInstance(config, "portfolio-list:main");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    const defaultLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      },
+      instances: [{ ...mainPane }, { ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    const monitorLayout = {
+      dockRoot: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      instances: [{ ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    config.layout = cloneLayout(defaultLayout);
+    config.layouts = [
+      { name: "Default", layout: cloneLayout(defaultLayout), focusedPaneId: "portfolio-list:main" },
+      { name: "Monitor", layout: cloneLayout(monitorLayout), focusedPaneId: "ticker-detail:main" },
+    ];
+    config.activeLayoutIndex = 0;
+
+    const initialState = {
+      ...createInitialState(config),
+      focusedPaneId: "portfolio-list:main",
+      statusBarVisible: true,
+    };
+    const registry = createShellPluginRegistry();
+    const controls: {
+      dispatch?: (action: ShellTestAction) => void;
+      state?: ReturnType<typeof createInitialState>;
+      transientLayout: TransientLayoutState | null;
+    } = { transientLayout: null };
+
+    testSetup = await testRender(
+      <ShellTransientHarness initialState={initialState} registry={registry} controls={controls} />,
+      { width: 100, height: 18 },
+    );
+
+    await testSetup.renderOnce();
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+
+    let frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Main Portfolio");
+    expect(frame).not.toContain("Ticker Research Body");
+    expect(controls.transientLayout).toMatchObject({
+      id: "pane-focus",
+      active: true,
+    });
+
+    await act(async () => {
+      controls.transientLayout?.onDeactivate?.();
+      controls.dispatch?.({ type: "SWITCH_LAYOUT", index: 1 });
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(controls.transientLayout).toMatchObject({
+      id: "pane-focus",
+      active: false,
+    });
+
+    await act(async () => {
+      controls.transientLayout?.onActivate?.();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(controls.transientLayout).toMatchObject({
+      id: "pane-focus",
+      active: true,
+    });
+  });
+
+  test("restores the focus source layout state when reactivating transient focus", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-shell-transient-focus-state-test");
+    const mainPane = requireLayoutInstance(config, "portfolio-list:main");
+    const detailPane = requireLayoutInstance(config, "ticker-detail:main");
+    const defaultLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:main" },
+      },
+      instances: [{ ...mainPane }, { ...detailPane }],
+      floating: [],
+      detached: [],
+    };
+    const monitorLayout = cloneLayout(defaultLayout);
+    config.layout = cloneLayout(defaultLayout);
+    config.layouts = [
+      {
+        name: "Default",
+        layout: cloneLayout(defaultLayout),
+        focusedPaneId: "ticker-detail:main",
+        paneState: {
+          "portfolio-list:main": { collectionId: "main", cursorSymbol: "MSTR" },
+          "ticker-detail:main": { activeTabId: "overview" },
+        },
+      },
+      {
+        name: "Monitor",
+        layout: monitorLayout,
+        focusedPaneId: "ticker-detail:main",
+        paneState: {
+          "portfolio-list:main": { collectionId: "main", cursorSymbol: null },
+          "ticker-detail:main": { activeTabId: "overview" },
+        },
+      },
+    ];
+    config.activeLayoutIndex = 0;
+    const registry = createShellPluginRegistry({
+      tickerDetailComponent: () => {
+        const { symbol } = usePaneTicker();
+        return <text>{`Ticker:${symbol ?? "none"}`}</text>;
+      },
+    });
+    const controls: {
+      dispatch?: (action: ShellTestAction) => void;
+      state?: ReturnType<typeof createInitialState>;
+      transientLayout: TransientLayoutState | null;
+    } = { transientLayout: null };
+
+    testSetup = await testRender(
+      <ShellTransientHarness
+        initialState={createInitialState(config)}
+        registry={registry}
+        controls={controls}
+      />,
+      { width: 100, height: 18 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("icker:MSTR");
+
+    await emitKeypress({ name: "f", ctrl: true, shift: true });
+    expect(testSetup.captureCharFrame()).toContain("icker:MSTR");
+
+    await act(async () => {
+      controls.transientLayout?.onDeactivate?.();
+      controls.dispatch?.({ type: "SWITCH_LAYOUT", index: 1 });
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+    expect(controls.transientLayout).toMatchObject({
+      id: "pane-focus",
+      active: false,
+    });
+    expect(controls.state?.config.activeLayoutIndex).toBe(1);
+    expect(controls.state?.paneState["portfolio-list:main"]?.cursorSymbol).toBeNull();
+    expect(controls.state ? resolveTickerForPane(controls.state, "ticker-detail:main") : null).toBeNull();
+
+    await act(async () => {
+      controls.transientLayout?.onActivate?.();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(controls.transientLayout).toMatchObject({
+      id: "pane-focus",
+      active: true,
+    });
+    expect(controls.state?.config.activeLayoutIndex).toBe(0);
+    expect(controls.state?.paneState["portfolio-list:main"]?.cursorSymbol).toBe("MSTR");
+    expect(controls.state ? resolveTickerForPane(controls.state, "ticker-detail:main") : null).toBe("MSTR");
+  });
+
   test("exits window mode on Enter without changes", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-shell-window-mode-resize-shortcut-test");
     const mainPane = requireLayoutInstance(config, "portfolio-list:main");