gloomberb 0.9.2 → 0.9.4

package/src/components/layout/shell/terminal-pointer-runtime.ts

@@ -41,6 +41,7 @@ interface UseShellTerminalPointerRuntimeOptions {
   selectWindowModePane: (paneId: string) => void;
   setHoveredMenuItemId: Dispatch<SetStateAction<string | null>>;
   setMenuState: Dispatch<SetStateAction<ActionMenuState | null>>;
+  transientFocusActive: boolean;
   visibleFloatingPanes: VisibleFloatingPane[];
   width: number;
   windowMode: WindowEditState | null;
@@ -79,6 +80,7 @@ export function useShellTerminalPointerRuntime({
   selectWindowModePane,
   setHoveredMenuItemId,
   setMenuState,
+  transientFocusActive,
   visibleFloatingPanes,
   width,
   windowMode,
@@ -132,25 +134,27 @@ export function useShellTerminalPointerRuntime({
         return;
       }
 
-      for (const divider of dockDividerLayouts) {
-        if (!pointInRect(divider.rect, event.x, shellY)) continue;
-        dragRef.current = {
-          type: "divider",
-          path: divider.path,
-          axis: divider.axis,
-          startX: preciseX,
-          startY: preciseShellY,
-          startRatio: divider.ratio,
-          bounds: divider.bounds,
-        };
-        updateDividerPreview({
-          pathKey: divider.path.join("."),
-          rect: divider.rect,
-          ratio: divider.ratio,
-        });
-        event.stopPropagation();
-        event.preventDefault();
-        return;
+      if (!transientFocusActive) {
+        for (const divider of dockDividerLayouts) {
+          if (!pointInRect(divider.rect, event.x, shellY)) continue;
+          dragRef.current = {
+            type: "divider",
+            path: divider.path,
+            axis: divider.axis,
+            startX: preciseX,
+            startY: preciseShellY,
+            startRatio: divider.ratio,
+            bounds: divider.bounds,
+          };
+          updateDividerPreview({
+            pathKey: divider.path.join("."),
+            rect: divider.rect,
+            ratio: divider.ratio,
+          });
+          event.stopPropagation();
+          event.preventDefault();
+          return;
+        }
       }
 
       for (const leaf of dockLeafLayouts) {
@@ -279,6 +283,11 @@ export function useShellTerminalPointerRuntime({
           event.preventDefault();
           return;
         }
+        if (relativeY === 0 && transientFocusActive) {
+          event.stopPropagation();
+          event.preventDefault();
+          return;
+        }
         if (relativeY === 0) {
           dragRef.current = {
             type: "pane-drag",
@@ -317,6 +326,7 @@ export function useShellTerminalPointerRuntime({
     selectWindowModePane,
     setHoveredMenuItemId,
     setMenuState,
+    transientFocusActive,
     updateDividerPreview,
     updateDragFloatingRect,
     visibleFloatingPanes,

package/src/components/layout/shell/visible-layout.ts

@@ -0,0 +1,17 @@
+import {
+  removeUnavailablePaneTypes,
+  type PaneTypeAvailability,
+} from "../../../plugins/pane-manager";
+import type { LayoutConfig } from "../../../types/config";
+
+export function resolveShellVisibleLayout(
+  layout: LayoutConfig,
+  disabledPaneIds: ReadonlySet<string>,
+  registeredPaneIds: PaneTypeAvailability,
+): LayoutConfig {
+  return removeUnavailablePaneTypes(
+    layout,
+    registeredPaneIds,
+    { disabledPaneIds },
+  );
+}

package/src/components/layout/shell/window-mode/index.ts

@@ -13,6 +13,7 @@ import {
   applyWindowEditDirection,
   cycleWindowEditFocus,
   cycleWindowEditPane,
+  cycleWindowEditTarget,
   directionFromWindowEditKey,
   getWindowEditPaneIds,
   normalizeWindowEditFocus,
@@ -72,7 +73,10 @@ export function useShellWindowMode({
   );
   const windowModePaneId = windowMode?.paneId;
   const activeLayout = windowMode?.previewLayout ?? visibleLayout;
-  const windowModePaneIds = useMemo(() => getWindowEditPaneIds(activeLayout), [activeLayout]);
+  const windowModePaneIds = useMemo(
+    () => getWindowEditPaneIds(activeLayout, bounds, dockGeometryOptions),
+    [activeLayout, bounds, dockGeometryOptions],
+  );
   const windowModeDockMovePreview = useMemo(
     () => resolveWindowEditDockMovePreview(windowMode, bounds, dockGeometryOptions),
     [bounds, dockGeometryOptions, windowMode],
@@ -210,12 +214,16 @@ export function useShellWindowMode({
       }
     } else if (name === "w") {
       setWindowMode((current) => current
-        ? cycleWindowEditPane(current, windowModePaneIds, bounds, dockGeometryOptions, event.shift ? -1 : 1)
+        ? current.mode === "move" && current.focus.kind === "dock-move"
+          ? cycleWindowEditTarget(current, bounds, dockGeometryOptions, event.shift ? -1 : 1)
+          : cycleWindowEditPane(current, windowModePaneIds, bounds, dockGeometryOptions, event.shift ? -1 : 1)
         : current);
     } else if (name === "tab") {
       setWindowMode((current) => current
         ? current.mode === "move"
-          ? cycleWindowEditPane(current, windowModePaneIds, bounds, dockGeometryOptions, event.shift ? -1 : 1)
+          ? current.focus.kind === "dock-move"
+            ? cycleWindowEditTarget(current, bounds, dockGeometryOptions, event.shift ? -1 : 1)
+            : cycleWindowEditPane(current, windowModePaneIds, bounds, dockGeometryOptions, event.shift ? -1 : 1)
           : {
               ...current,
               focus: cycleWindowEditFocus(

package/src/components/layout/shell/window-mode/overlays.tsx

@@ -40,6 +40,13 @@ interface ShellWindowModeOverlaysProps {
   windowModeDockMovePreview: WindowEditDockMovePreview | null;
 }
 
+function getHighlightedPaneId(windowMode: WindowEditState | null, focusedPaneId: string | null): string | null {
+  if (windowMode?.mode === "move" && windowMode.focus.kind === "dock-move") {
+    return windowMode.focus.targetId;
+  }
+  return windowMode?.paneId ?? focusedPaneId;
+}
+
 function windowModeBannerKey(windowMode: WindowEditState): string {
   const focusKey = windowMode.focus.kind === "dock-move"
     ? `${windowMode.focus.targetId}:${windowMode.focus.position}`
@@ -69,7 +76,7 @@ export function ShellWindowModeOverlays({
   windowMode,
   windowModeDockMovePreview,
 }: ShellWindowModeOverlaysProps) {
-  const highlightedPaneId = windowMode?.paneId ?? focusedPaneId;
+  const highlightedPaneId = getHighlightedPaneId(windowMode, focusedPaneId);
   const highlightedFloatingPane = highlightedPaneId
     ? visibleFloatingPanes.find((entry) => entry.pane.instance.instanceId === highlightedPaneId)
     : null;

package/src/components/layout/status-bar.test.tsx

@@ -1,10 +1,12 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { AppContext, createInitialState } from "../../state/app/context";
-import { cloneLayout, createDefaultConfig, type LayoutConfig } from "../../types/config";
+import { cloneLayout, createDefaultConfig, TICKER_RESEARCH_PANE_ID, type LayoutConfig } from "../../types/config";
 import type { AppNotificationRequest } from "../../types/plugin";
 import { StatusBar } from "./status-bar";
 import { setSharedRegistryForTests } from "../../plugins/registry";
+import { useEffect, useState } from "react";
+import { TransientLayoutProvider, useTransientLayout } from "./transient-layout";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -17,6 +19,37 @@ afterEach(() => {
 });
 
 describe("StatusBar", () => {
+  function SeedTransientLayout({
+    onActivate,
+    onDeactivate,
+    onExit,
+  }: {
+    onActivate?: () => void;
+    onDeactivate?: () => void;
+    onExit?: () => void;
+  }) {
+    const { setTransientLayout } = useTransientLayout();
+    const [active, setActive] = useState(true);
+    useEffect(() => {
+      setTransientLayout({
+        id: "pane-focus",
+        label: "^F Focus",
+        active,
+        onActivate: () => {
+          onActivate?.();
+          setActive(true);
+        },
+        onDeactivate: () => {
+          onDeactivate?.();
+          setActive(false);
+        },
+        onExit,
+      });
+      return () => setTransientLayout(null);
+    }, [active, onActivate, onDeactivate, onExit, setTransientLayout]);
+    return null;
+  }
+
   test("opens the command bar from the shortcut hint", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     config.layouts = [{ name: "Home", layout: cloneLayout(config.layout) }];
@@ -45,6 +78,78 @@ describe("StatusBar", () => {
     expect(actions).toContainEqual({ type: "SET_COMMAND_BAR", open: true, query: "" });
   });
 
+  test("shows a transient focus layout tab without replacing saved layouts", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-transient-layout-test");
+    config.layouts = [
+      { name: "Default", layout: cloneLayout(config.layout) },
+      { name: "Monitor", layout: cloneLayout(config.layout) },
+    ];
+    const state = {
+      ...createInitialState(config),
+      statusBarVisible: true,
+    };
+    const actions: Array<{ type: string; index?: number }> = [];
+    let activateCount = 0;
+    let deactivateCount = 0;
+    let exitCount = 0;
+    const handleActivate = () => { activateCount += 1; };
+    const handleDeactivate = () => { deactivateCount += 1; };
+    const handleExit = () => { exitCount += 1; };
+
+    testSetup = await testRender(
+      <AppContext value={{ state, dispatch: (action) => actions.push(action as { type: string; index?: number }) }}>
+        <TransientLayoutProvider>
+          <SeedTransientLayout
+            onActivate={handleActivate}
+            onDeactivate={handleDeactivate}
+            onExit={handleExit}
+          />
+          <StatusBar />
+        </TransientLayoutProvider>
+      </AppContext>,
+      { width: 120, height: 1 },
+    );
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("^1 Default");
+    expect(frame).toContain("^2 Monitor");
+    expect(frame).toContain("^F Focus");
+
+    const monitorX = frame.split("\n")[0]?.indexOf("^2 Monitor") ?? -1;
+    expect(monitorX).toBeGreaterThanOrEqual(0);
+
+    await testSetup.mockMouse.click(monitorX + 1, 0);
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+
+    expect(deactivateCount).toBe(1);
+    expect(exitCount).toBe(0);
+    expect(actions).toContainEqual({ type: "SWITCH_LAYOUT", index: 1 });
+
+    const afterSwitchFrame = testSetup.captureCharFrame();
+    expect(afterSwitchFrame).toContain("^F Focus");
+
+    const focusX = afterSwitchFrame.split("\n")[0]?.indexOf("^F Focus") ?? -1;
+    expect(focusX).toBeGreaterThanOrEqual(0);
+
+    await testSetup.mockMouse.click(focusX + 1, 0);
+    await testSetup.renderOnce();
+
+    expect(activateCount).toBe(1);
+
+    const activeFocusFrame = testSetup.captureCharFrame();
+    const activeFocusX = activeFocusFrame.split("\n")[0]?.indexOf("^F Focus") ?? -1;
+    expect(activeFocusX).toBeGreaterThanOrEqual(0);
+
+    await testSetup.mockMouse.click(activeFocusX + 1, 0);
+    await testSetup.renderOnce();
+
+    expect(exitCount).toBe(1);
+  });
+
   test("shows a gridlock tip after a corner snap and runs gridlock on click", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const floatingLayout = cloneLayout(config.layout);
@@ -69,6 +174,10 @@ describe("StatusBar", () => {
     const notifications: AppNotificationRequest[] = [];
 
     setSharedRegistryForTests({
+      panes: new Map([
+        ["portfolio-list", {}],
+        [TICKER_RESEARCH_PANE_ID, {}],
+      ]),
       getLayoutFn: () => state.config.layout,
       getTermSizeFn: () => ({ width: 120, height: 40 }),
       updateLayoutFn: (layout: LayoutConfig) => { updatedLayout = layout; },
@@ -128,6 +237,7 @@ describe("StatusBar", () => {
     globalThis.clearTimeout = (() => {}) as typeof clearTimeout;
 
     setSharedRegistryForTests({
+      panes: new Map(),
       getLayoutFn: () => state.config.layout,
       getTermSizeFn: () => ({ width: 120, height: 40 }),
       updateLayoutFn: () => {},

package/src/components/layout/status-bar.tsx

@@ -16,6 +16,7 @@ import { notifyGridlockComplete } from "../../plugins/gridlock-notification";
 import { PluginSlot } from "../../react/plugins/plugin-slot";
 import type { ContextMenuItem } from "../../types/context-menu";
 import { Tabs } from "../ui/tabs";
+import { useTransientLayout } from "./transient-layout";
 
 const GRIDLOCK_TIP_DURATION_MS = 60_000;
 
@@ -31,6 +32,7 @@ type LayoutTabItem = {
 
 type StatusBarViewProps = {
   activeLayoutIdx: number;
+  activeLayoutValue: string;
   dismissGridlockTip: (event?: StatusBarEvent) => void;
   handleGridlockTip: (event?: StatusBarEvent) => void;
   handleLayoutSelect: (value: string) => void;
@@ -62,18 +64,40 @@ export function StatusBar() {
   const statusBarVisible = useAppSelector(selectStatusBarVisible);
   const gridlockTipVisible = useAppSelector(selectGridlockTipVisible);
   const gridlockTipSequence = useAppSelector(selectGridlockTipSequence);
+  const { transientLayout } = useTransientLayout();
   const [hoveredControl, setHoveredControl] = useState<string | null>(null);
 
-  const hasMultipleLayouts = layouts.length > 1;
+  const hasMultipleLayouts = layouts.length > 1 || !!transientLayout;
   const showGridlockTip = gridlockTipVisible && !!registry;
-  const layoutTabs = layouts.map((layout, index) => ({
+  const savedLayoutTabs = layouts.map((layout, index) => ({
     label: `^${index + 1} ${truncate(layout.name, 14)}`,
     value: String(index),
   }));
+  const layoutTabs = transientLayout
+    ? [
+      ...savedLayoutTabs,
+      {
+        label: transientLayout.label,
+        value: transientLayout.id,
+      },
+    ]
+    : savedLayoutTabs;
   const layoutTabsWidth = layoutTabs.reduce((sum, tab) => sum + tab.label.length + 2, 0);
+  const activeLayoutValue = transientLayout?.active ? transientLayout.id : String(activeLayoutIdx);
   const handleLayoutSelect = (value: string) => {
+    if (value === transientLayout?.id) {
+      if (transientLayout.active) {
+        transientLayout.onExit?.();
+      } else {
+        transientLayout.onActivate?.();
+      }
+      return;
+    }
     const index = Number(value);
     if (!Number.isInteger(index) || index < 0 || index >= layouts.length) return;
+    if (transientLayout?.active) {
+      transientLayout.onDeactivate?.();
+    }
     dispatch({ type: "SWITCH_LAYOUT", index });
   };
 
@@ -90,7 +114,11 @@ export function StatusBar() {
     event?.stopPropagation?.();
     if (!registry) return;
     const { width, height } = registry.getTermSizeFn();
-    registry.updateLayoutFn(gridlockAllPanes(registry.getLayoutFn(), { x: 0, y: 0, width, height }));
+    registry.updateLayoutFn(gridlockAllPanes(
+      registry.getLayoutFn(),
+      { x: 0, y: 0, width, height },
+      registry.panes,
+    ));
     notifyGridlockComplete(registry.notify.bind(registry), () => {
       dispatch({ type: "UNDO_LAYOUT" });
     });
@@ -184,11 +212,12 @@ export function StatusBar() {
     );
   }, [activeLayoutIdx, layoutContextMenuItems, layouts, showContextMenu]);
   const handleLayoutTabContextMenu = useCallback((value: string, event: any) => {
+    if (value === transientLayout?.id) return;
     const index = Number(value);
     if (!Number.isInteger(index) || index < 0 || index >= layouts.length) return;
     if (event?.type !== "contextmenu" && event?.button === 2 && nativeContextMenu === true) return;
     void openLayoutContextMenu(index, event);
-  }, [layouts.length, nativeContextMenu, openLayoutContextMenu]);
+  }, [layouts.length, nativeContextMenu, openLayoutContextMenu, transientLayout?.id]);
   const layoutTabItems = layoutTabs.map((tab) => ({
     ...tab,
     onContextMenu: handleLayoutTabContextMenu,
@@ -198,6 +227,7 @@ export function StatusBar() {
 
   const viewProps: StatusBarViewProps = {
     activeLayoutIdx,
+    activeLayoutValue,
     dismissGridlockTip,
     handleGridlockTip,
     handleLayoutSelect,
@@ -272,7 +302,7 @@ function TerminalStatusBar({
 }
 
 function StatusBarLayoutControl({
-  activeLayoutIdx,
+  activeLayoutValue,
   handleLayoutSelect,
   hasMultipleLayouts,
   hoveredControl,
@@ -283,7 +313,7 @@ function StatusBarLayoutControl({
   setHoveredControl,
 }: Pick<
   StatusBarViewProps,
-  | "activeLayoutIdx"
+  | "activeLayoutValue"
   | "handleLayoutSelect"
   | "hasMultipleLayouts"
   | "hoveredControl"
@@ -303,7 +333,7 @@ function StatusBarLayoutControl({
         <Box width={layoutTabsWidth} height={1}>
           <Tabs
             tabs={layoutTabItems}
-            activeValue={String(activeLayoutIdx)}
+            activeValue={activeLayoutValue}
             onSelect={handleLayoutSelect}
             compact
             variant="pill"

package/src/components/layout/transient-layout.tsx

@@ -0,0 +1,57 @@
+import { createContext, useCallback, useContext, useMemo, useState, type ReactNode } from "react";
+
+export interface TransientLayoutState {
+  id: "pane-focus";
+  label: string;
+  active: boolean;
+  onActivate?: () => void;
+  onDeactivate?: () => void;
+  onExit?: () => void;
+}
+
+interface TransientLayoutContextValue {
+  transientLayout: TransientLayoutState | null;
+  setTransientLayout: (layout: TransientLayoutState | null) => void;
+}
+
+const noop = () => {};
+
+const TransientLayoutContext = createContext<TransientLayoutContextValue>({
+  transientLayout: null,
+  setTransientLayout: noop,
+});
+
+function sameTransientLayout(
+  left: TransientLayoutState | null,
+  right: TransientLayoutState | null,
+): boolean {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return left.id === right.id
+    && left.label === right.label
+    && left.active === right.active
+    && left.onActivate === right.onActivate
+    && left.onDeactivate === right.onDeactivate
+    && left.onExit === right.onExit;
+}
+
+export function TransientLayoutProvider({ children }: { children: ReactNode }) {
+  const [transientLayout, setTransientLayoutState] = useState<TransientLayoutState | null>(null);
+  const setTransientLayout = useCallback((layout: TransientLayoutState | null) => {
+    setTransientLayoutState((current) => (sameTransientLayout(current, layout) ? current : layout));
+  }, []);
+  const value = useMemo(() => ({
+    transientLayout,
+    setTransientLayout,
+  }), [setTransientLayout, transientLayout]);
+
+  return (
+    <TransientLayoutContext.Provider value={value}>
+      {children}
+    </TransientLayoutContext.Provider>
+  );
+}
+
+export function useTransientLayout(): TransientLayoutContextValue {
+  return useContext(TransientLayoutContext);
+}

package/src/components/layout/window-edit/mode.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import type { LayoutConfig } from "../../../types/config";
-import { cycleWindowEditPane, getWindowEditPaneIds, type WindowEditState } from "./mode";
+import {
+  cycleWindowEditPane,
+  cycleWindowEditTarget,
+  getWindowEditPaneIds,
+  type WindowEditState,
+} from "./mode";
+import { resolveWindowEditDockMovePreview } from "./presentation";
 
 const bounds = { x: 0, y: 0, width: 120, height: 40 };
 
@@ -38,18 +44,83 @@ describe("window edit mode", () => {
       dirty: false,
     };
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("dock-b");
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("float-a");
     expect(state.previewLayout.floating.find((entry) => entry.instanceId === "float-a")?.zIndex)
       .toBeGreaterThan(state.previewLayout.floating.find((entry) => entry.instanceId === "float-b")?.zIndex ?? 0);
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("float-b");
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("dock-a");
   });
+
+  test("cycles dock move targets without changing the selected window", () => {
+    const layout: LayoutConfig = {
+      dockRoot: {
+        kind: "split",
+        axis: "horizontal",
+        ratio: 0.5,
+        first: { kind: "pane", instanceId: "source" },
+        second: {
+          kind: "split",
+          axis: "vertical",
+          ratio: 0.5,
+          first: { kind: "pane", instanceId: "target-a" },
+          second: { kind: "pane", instanceId: "target-b" },
+        },
+      },
+      instances: [
+        pane("source"),
+        pane("target-a"),
+        pane("target-b"),
+      ],
+      floating: [],
+      detached: [],
+    };
+    const state: WindowEditState = {
+      paneId: "source",
+      previewLayout: layout,
+      mode: "move",
+      focus: { kind: "dock-move", targetId: "target-a", position: "right" },
+      dirty: false,
+    };
+
+    const next = cycleWindowEditTarget(state, bounds, { reserveDividerGutters: true }, 1);
+
+    expect(next.paneId).toBe("source");
+    expect(next.focus).toEqual({ kind: "dock-move", targetId: "target-b", position: "right" });
+  });
+
+  test("uses dock geometry options for dock move preview rectangles", () => {
+    const layout: LayoutConfig = {
+      dockRoot: {
+        kind: "split",
+        axis: "horizontal",
+        ratio: 0.5,
+        first: { kind: "pane", instanceId: "left" },
+        second: { kind: "pane", instanceId: "right" },
+      },
+      instances: [
+        pane("left"),
+        pane("right"),
+      ],
+      floating: [],
+      detached: [],
+    };
+    const state: WindowEditState = {
+      paneId: "left",
+      previewLayout: layout,
+      mode: "move",
+      focus: { kind: "dock-move", targetId: "right", position: "right" },
+      dirty: false,
+    };
+
+    expect(resolveWindowEditDockMovePreview(state, bounds, { reserveDividerGutters: true })?.rect)
+      .toEqual({ x: 61, y: 0, width: 59, height: 40 });
+  });
 });

package/src/components/layout/window-edit/mode.ts

@@ -226,12 +226,57 @@ export function cycleWindowEditFocus(
   return targets[(currentIndex + delta + targets.length) % targets.length] ?? targets[0]!;
 }
 
-export function getWindowEditPaneIds(layout: LayoutConfig): string[] {
-  const dockedIds = getDockLeafLayouts(layout, { x: 0, y: 0, width: 120, height: 40 }).map((entry) => entry.instanceId);
+function getWindowEditDockPaneIds(
+  layout: LayoutConfig,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+): string[] {
+  return getDockLeafLayouts(layout, bounds, dockGeometryOptions).map((entry) => entry.instanceId);
+}
+
+export function getWindowEditPaneIds(
+  layout: LayoutConfig,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+): string[] {
+  const dockedIds = getWindowEditDockPaneIds(layout, bounds, dockGeometryOptions);
   const floatingIds = layout.floating.map((entry) => entry.instanceId);
   return [...dockedIds, ...floatingIds];
 }
 
+export function cycleWindowEditTarget(
+  state: WindowEditState,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+  delta: 1 | -1,
+): WindowEditState {
+  if (state.mode !== "move" || state.focus.kind !== "dock-move") {
+    return state;
+  }
+
+  const targetIds = getWindowEditDockPaneIds(state.previewLayout, bounds, dockGeometryOptions)
+    .filter((paneId) => paneId !== state.paneId);
+  if (targetIds.length === 0) {
+    return {
+      ...state,
+      focus: normalizeWindowEditFocus({ kind: "move" }, state.previewLayout, state.paneId, state.mode, bounds, dockGeometryOptions),
+    };
+  }
+
+  const currentIndex = targetIds.indexOf(state.focus.targetId);
+  const startIndex = currentIndex >= 0
+    ? currentIndex
+    : delta === 1
+      ? -1
+      : 0;
+  const targetId = targetIds[(startIndex + delta + targetIds.length) % targetIds.length] ?? targetIds[0]!;
+  return {
+    ...state,
+    focus: normalizeWindowEditFocus({ ...state.focus, targetId }, state.previewLayout, state.paneId, state.mode, bounds, dockGeometryOptions),
+    notice: undefined,
+  };
+}
+
 export function raiseWindowEditPane(layout: LayoutConfig, paneId: string): LayoutConfig {
   const floating = layout.floating.find((entry) => entry.instanceId === paneId);
   if (!floating) return layout;

package/src/components/layout/window-edit/presentation.ts

@@ -73,7 +73,7 @@ export function windowEditStatusLine(
 export function windowEditHelpText(state: WindowEditState): string {
   if (state.mode === "move") {
     if (state.focus.kind === "dock-move") {
-      return "arrows/hjkl choose side  m retarget  Tab/w window  d float  r resize  Enter commit/exit  Esc exit/cancel";
+      return "arrows/hjkl choose side  Tab/w target  m window  d float  r resize  Enter commit/exit  Esc exit/cancel";
     }
     return "Tab/w window  d dock/float  r resize  arrows/hjkl target/move  Shift fast  Enter commit/exit  Esc exit/cancel";
   }
@@ -100,6 +100,7 @@ export function resolveWindowEditDockMovePreview(
     state.paneId,
     leafDropTarget(focus.targetId, focus.position),
     bounds,
+    dockGeometryOptions,
   );
   if (!simulation.previewRect) return null;
   return {