Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

34.7 KB
Raw Blame
import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
import type { ReactNode } from 'react';
import { createPortal } from 'react-dom';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import type { EditorPaneState } from '@/editor/editor-panes';
import { OK_SIDEBAR_DRAG_MIME, serializeSidebarDragPayload } from '@/lib/sidebar-drag';
import { swapEditorSidebars } from '@/lib/sidebar-side-store';
import { renderLinguiTemplate } from '@/test-utils/lingui-mock';
import {
  expectVisualClassTokens,
  expectVisualClassTokensAbsent,
} from '@/test-utils/visual-contract';

const multiPaneFixture: EditorPaneState[] = [
  {
    id: 'pane-a',
    openTabs: ['docs/a', 'docs/b'],
    pinnedTabIds: [],
    activeTabId: 'docs/a',
    newTabIds: [],
    activeNewTabId: null,
    activeTarget: { kind: 'doc', target: 'docs/a', docName: 'docs/a' },
    size: 60,
  },
  {
    id: 'pane-b',
    openTabs: ['docs/c'],
    pinnedTabIds: [],
    activeTabId: 'docs/c',
    newTabIds: [],
    activeNewTabId: null,
    activeTarget: { kind: 'doc', target: 'docs/c', docName: 'docs/c' },
    size: 40,
  },
];
let panes = multiPaneFixture.map((pane) => ({ ...pane }));
let tabSessionLoaded = true;

const focusPane = vi.fn();
const moveTabToPane = vi.fn();
const openTarget = vi.fn();
const openTargetInPane = vi.fn();
const reorderTabsInPane = vi.fn();
const resizePanes = vi.fn();
const splitTab = vi.fn(() => 'pane-new');

let dndProps: Record<string, unknown> = {};
let dragOverlayProps: Record<string, unknown> = {};
let layoutChange: ((layout: Record<string, number>) => void) | undefined;
let layoutChanged:
  | ((layout: Record<string, number>, meta: { isUserInteraction: boolean }) => void)
  | undefined;
let overDroppableId: string | null = null;
const droppableData = new Map<string, unknown>();
const setLayout = vi.fn();

vi.doMock('@lingui/react/macro', async () => {
  const actual = await vi.importActual<typeof import('@lingui/react/macro')>('@lingui/react/macro');
  return {
    ...actual,
    Trans: ({ children }: { children?: ReactNode }) => <>{children}</>,
    useLingui: () => ({ t: renderLinguiTemplate }),
  };
});

vi.doMock('@dnd-kit/core', () => ({
  closestCenter: () => [],
  DndContext: (props: Record<string, unknown> & { children?: ReactNode }) => {
    dndProps = props;
    return <div data-testid="workspace-dnd">{props.children}</div>;
  },
  DragOverlay: (props: Record<string, unknown> & { children?: ReactNode }) => {
    dragOverlayProps = props;
    return <div data-testid="editor-tab-drag-overlay-host">{props.children}</div>;
  },
  KeyboardCode: {
    Enter: 'Enter',
    Esc: 'Escape',
    Space: 'Space',
  },
  KeyboardSensor: { name: 'KeyboardSensor' },
  PointerSensor: { name: 'PointerSensor' },
  useDroppable: ({ data, disabled, id }: { data: unknown; disabled?: boolean; id: string }) => {
    droppableData.set(id, data);
    return {
      isOver: !disabled && overDroppableId === id,
      setNodeRef: () => {},
    };
  },
  useSensor: (sensor: unknown, options: unknown) => ({ sensor, options }),
  useSensors: (...sensors: unknown[]) => sensors,
}));

vi.doMock('@dnd-kit/sortable', () => ({
  arrayMove: <T,>(items: T[], from: number, to: number) => {
    const next = [...items];
    const [item] = next.splice(from, 1);
    next.splice(to, 0, item);
    return next;
  },
  sortableKeyboardCoordinates: { name: 'sortableKeyboardCoordinates' },
}));

vi.doMock('react-resizable-panels', () => ({
  useGroupRef: () => ({ current: { setLayout } }),
}));

vi.doMock('@/components/ui/resizable', () => ({
  ResizablePanelGroup: ({
    children,
    onLayoutChange,
    onLayoutChanged,
    ...props
  }: {
    children?: ReactNode;
    onLayoutChange?: typeof layoutChange;
    onLayoutChanged?: typeof layoutChanged;
    [key: string]: unknown;
  }) => {
    layoutChange = onLayoutChange;
    layoutChanged = onLayoutChanged;
    return (
      <div data-testid="workspace-panel-group" data-orientation={String(props.orientation)}>
        {children}
      </div>
    );
  },
  ResizablePanel: ({
    children,
    id,
    minSize,
  }: {
    children?: ReactNode;
    id?: string;
    minSize?: string;
  }) => (
    <section data-panel-id={id} data-min-size={minSize}>
      {children}
    </section>
  ),
  ResizableHandle: (props: Record<string, unknown>) => (
    <div
      data-testid="pane-resize-handle"
      data-editor-pane-resize-handle={String(props['data-editor-pane-resize-handle'])}
      data-editor-pane-before={String(props['data-editor-pane-before'])}
      data-editor-pane-after={String(props['data-editor-pane-after'])}
    >
      {props.children as ReactNode}
    </div>
  ),
}));

vi.doMock('@/editor/DocumentContext', () => ({
  useDocumentContext: () => ({
    focusPane,
    focusedPaneId: 'pane-a',
    moveTabToPane,
    openTarget,
    openTargetInPane,
    panes,
    reorderTabsInPane,
    resizePanes,
    splitTab,
    tabSessionLoaded,
    visibleTabIdsByPane: new Map(
      panes.map((pane) => [pane.id, [...pane.openTabs, ...pane.newTabIds]]),
    ),
  }),
}));

vi.doMock('@/lib/single-file-mode', () => ({
  useSingleFileMode: () => false,
}));

vi.doMock('./EditorTabs', () => ({
  EditorTabs: ({
    dropIndicatorIndex,
    leading,
    paneId,
    trailing,
  }: {
    dropIndicatorIndex?: number | null;
    leading?: ReactNode;
    paneId: string;
    trailing?: ReactNode;
  }) => (
    <div data-editor-pane-tabs={paneId} data-drop-indicator-index={dropIndicatorIndex ?? undefined}>
      {leading}
      Tabs {paneId}
      {trailing}
    </div>
  ),
}));

vi.doMock('./FileListToggle', () => ({
  FileListToggle: ({ side }: { side?: 'start' | 'end' }) => (
    <button type="button" data-testid="file-list-toggle" data-side={side}>
      Files
    </button>
  ),
}));

const { EditorWorkspace } = await import('./EditorWorkspace');

function renderWorkspace(portaledPaneBody?: ReactNode) {
  return render(
    <EditorWorkspace
      renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
      renderPane={({ activityMount, pane }) => (
        <div data-testid={`pane-body-${pane.id}`}>{activityMount}</div>
      )}
      renderActivityPool={({ activityHosts, parkingHost, visibleDocNames }) => {
        const paneBActivityHost = activityHosts.get('docs/c');
        return (
          <>
            <div
              data-testid="activity-bindings"
              data-hosts={[...activityHosts.keys()].join(',')}
              data-visible={[...visibleDocNames].join(',')}
              data-parking={String(parkingHost !== null)}
            />
            {portaledPaneBody && paneBActivityHost
              ? createPortal(portaledPaneBody, paneBActivityHost)
              : null}
          </>
        );
      }}
    />,
  );
}

function latestDndProps() {
  type MockDragEvent = {
    active: {
      data: { current: unknown };
      rect?: { current: { translated: DOMRect | null } };
    };
    delta?: { x: number; y: number };
    over: { data: { current: unknown }; rect?: DOMRect } | null;
  };
  return dndProps as {
    accessibility?: {
      container?: HTMLElement;
      screenReaderInstructions?: { draggable?: string };
      announcements?: {
        onDragStart?: (event: { active: { data: { current: unknown } } }) => string | undefined;
        onDragOver?: (event: {
          active: { data: { current: unknown } };
          over: { data: { current: unknown } } | null;
        }) => string | undefined;
      };
    };
    modifiers?: unknown[];
    onDragStart?: (event: { active: { data: { current: unknown } } }) => void;
    onDragMove?: (event: MockDragEvent) => void;
    onDragOver?: (event: MockDragEvent) => void;
    onDragEnd?: (event: MockDragEvent) => void;
    onDragCancel?: () => void;
  };
}

function tabDrag(paneId: string, tabId: string) {
  return {
    kind: 'editor-tab' as const,
    paneId,
    tabId,
    splittable: true,
    label: tabId,
  };
}

describe('EditorWorkspace', () => {
  beforeEach(() => {
    panes = multiPaneFixture.map((pane) => ({ ...pane }));
    tabSessionLoaded = true;
    dndProps = {};
    dragOverlayProps = {};
    layoutChange = undefined;
    layoutChanged = undefined;
    overDroppableId = null;
    droppableData.clear();
    document.body.removeAttribute('data-editor-tab-dragging');
    for (const mock of [
      focusPane,
      moveTabToPane,
      openTarget,
      openTargetInPane,
      reorderTabsInPane,
      resizePanes,
      splitTab,
      setLayout,
    ]) {
      mock.mockClear();
    }
    splitTab.mockReturnValue('pane-new');
  });

  afterEach(() => {
    cleanup();
  });

  test('renders one flat horizontal panel per pane with stable resize selectors', () => {
    const { container } = renderWorkspace();

    expect(screen.getByTestId('workspace-panel-group').dataset.orientation).toBe('horizontal');
    expect(container.querySelector('[data-editor-workspace]')).toBeTruthy();
    expect(container.querySelector('[data-editor-workspace-canvas]')).toBeTruthy();
    expect(container.querySelectorAll('[data-editor-pane-id="pane-a"]')).not.toHaveLength(0);
    expect(container.querySelectorAll('[data-editor-pane-id="pane-b"]')).not.toHaveLength(0);
    expect(
      container
        .querySelector('[data-panel-id="editor-pane:pane-a"]')
        ?.getAttribute('data-min-size'),
    ).toBe('300px');
    expect(screen.getAllByTestId('pane-resize-handle')).toHaveLength(1);
    expect(screen.getByTestId('pane-resize-handle').dataset.editorPaneBefore).toBe('pane-a');
    expect(screen.getByTestId('pane-resize-handle').dataset.editorPaneAfter).toBe('pane-b');
    const header = screen.getByTestId('main-editor-header');
    expect(header.querySelector('[data-editor-pane-tabs="pane-a"]')).toBeTruthy();
    expect(header.querySelector('[data-editor-pane-tabs="pane-b"]')).toBeTruthy();
    expect(
      header
        .querySelector('[data-editor-pane-tabs="pane-a"]')
        ?.parentElement?.getAttribute('data-editor-pane-focused'),
    ).toBe('true');
    const focusedTabGroup = header.querySelector<HTMLElement>(
      '[data-editor-pane-tab-group="pane-a"]',
    );
    const unfocusedTabGroup = header.querySelector<HTMLElement>(
      '[data-editor-pane-tab-group="pane-b"]',
    );
    expectVisualClassTokensAbsent(focusedTabGroup?.className ?? '', ['after:bg-primary']);
    expectVisualClassTokensAbsent(unfocusedTabGroup?.className ?? '', ['after:bg-primary']);
    const firstPane = container.querySelector('[data-editor-pane-id="pane-a"]');
    const secondPane = container.querySelector('[data-editor-pane-id="pane-b"]');
    expect(firstPane?.querySelector('[data-editor-pane-tabs]')).toBeNull();
    expect(secondPane?.querySelector('[data-editor-pane-tabs]')).toBeNull();
    expect(screen.getByRole('region', { name: 'pane 1' })).toBe(firstPane);
    expect(firstPane?.getAttribute('aria-label')).toBe('pane 1');
    expect(firstPane?.getAttribute('aria-current')).toBe('true');
    expect(secondPane?.getAttribute('aria-label')).toBe('pane 2');
    expect(secondPane?.getAttribute('aria-current')).toBeNull();
  });

  test('does not paint a temporary desktop pane layout before session restore settles', () => {
    const previousDesktopBridge = window.okDesktop;
    Object.defineProperty(window, 'okDesktop', {
      configurable: true,
      writable: true,
      value: { config: { mode: 'editor' } },
    });
    tabSessionLoaded = false;

    const view = renderWorkspace();

    expect(screen.getByTestId('main-editor-header').children).toHaveLength(0);
    expect(view.container.querySelector('[data-editor-workspace-pending]')).toBeTruthy();
    expect(view.container.querySelector('[data-editor-pane-id]')).toBeNull();

    tabSessionLoaded = true;
    view.rerender(
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );

    expect(view.container.querySelector('[data-editor-workspace-pending]')).toBeNull();
    expect(view.container.querySelector('[data-editor-pane-id="pane-a"]')).toBeTruthy();
    Object.defineProperty(window, 'okDesktop', {
      configurable: true,
      writable: true,
      value: previousDesktopBridge,
    });
  });

  test('keeps header tab groups on the pane canvas geometry and scroll position', () => {
    const { container } = renderWorkspace();
    const workspace = container.querySelector<HTMLElement>('[data-editor-workspace]');
    const headerCanvas = container.querySelector<HTMLElement>('[data-editor-header-tab-canvas]');
    const headerGroups = [
      ...container.querySelectorAll<HTMLElement>('[data-editor-pane-tab-group]'),
    ];

    expect(headerCanvas).toBeTruthy();
    expect(headerCanvas?.classList.contains('min-w-(--editor-workspace-min-width)')).toBe(true);
    expect(headerCanvas?.style.getPropertyValue('--editor-workspace-min-width')).toBe(
      'max(100%, 600px)',
    );
    expect(headerGroups).toHaveLength(2);
    expect(headerGroups[0]?.classList.contains('basis-0')).toBe(true);
    expect(headerGroups[0]?.style.flexGrow).toBe('60');
    expect(headerGroups[1]?.classList.contains('basis-0')).toBe(true);
    expect(headerGroups[1]?.style.flexGrow).toBe('40');
    expect(
      headerGroups[0]?.classList.contains('[&>*]:pe-[var(--editor-header-trailing-width,0px)]'),
    ).toBe(false);
    expect(
      headerGroups[1]?.classList.contains('[&>*]:pe-[var(--editor-header-trailing-width,0px)]'),
    ).toBe(true);
    expect(container.querySelectorAll('[data-editor-header-pane-separator]')).toHaveLength(1);
    expect(screen.getAllByTestId('file-list-toggle')).toHaveLength(1);
    expect(headerGroups[0]?.contains(screen.getByTestId('file-list-toggle'))).toBe(true);

    if (!workspace || !headerCanvas) throw new Error('Expected workspace and header canvas');
    workspace.scrollLeft = 96;
    fireEvent.scroll(workspace);
    expect(headerCanvas.style.transform).toBe('translateX(-96px)');
  });

  test('with the file sidebar at the end, the one Files toggle closes the last pane strip', () => {
    swapEditorSidebars();
    try {
      const { container } = renderWorkspace();
      const toggles = screen.getAllByTestId('file-list-toggle');
      expect(toggles).toHaveLength(1);
      expect(toggles[0]?.dataset.side).toBe('end');
      const lastStrip = container.querySelector('[data-editor-pane-tabs="pane-b"]');
      expect(lastStrip?.lastElementChild).toBe(toggles[0]);
      expect(
        container.querySelector(
          '[data-editor-pane-tabs="pane-a"] [data-testid="file-list-toggle"]',
        ),
      ).toBeNull();
    } finally {
      swapEditorSidebars();
    }
  });

  test('resizes header tab groups continuously before persisting the panel layout', () => {
    const { container } = renderWorkspace();
    const headerGroups = [
      ...container.querySelectorAll<HTMLElement>('[data-editor-pane-tab-group]'),
    ];

    act(() => layoutChange?.({ 'editor-pane:pane-a': 72, 'editor-pane:pane-b': 28 }));

    expect(headerGroups[0]?.style.flexGrow).toBe('72');
    expect(headerGroups[1]?.style.flexGrow).toBe('28');
    expect(resizePanes).not.toHaveBeenCalled();

    act(() =>
      layoutChanged?.(
        { 'editor-pane:pane-a': 72, 'editor-pane:pane-b': 28 },
        { isUserInteraction: true },
      ),
    );
    expect(resizePanes).toHaveBeenCalledWith(
      new Map([
        ['pane-a', 72],
        ['pane-b', 28],
      ]),
    );
  });

  test('adopts the resolved pane layout on a header canvas that mounts after it', () => {
    const view = render(
      <EditorWorkspace
        renderHeader={() => <header data-testid="main-editor-header" />}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );
    expect(view.container.querySelector('[data-editor-pane-tab-group]')).toBeNull();

    act(() => layoutChange?.({ 'editor-pane:pane-a': 45, 'editor-pane:pane-b': 55 }));

    view.rerender(
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );

    const headerGroups = [
      ...view.container.querySelectorAll<HTMLElement>('[data-editor-pane-tab-group]'),
    ];
    expect(headerGroups).toHaveLength(2);
    expect(headerGroups[0]?.style.flexGrow).toBe('45');
    expect(headerGroups[1]?.style.flexGrow).toBe('55');
  });

  test('does not replay a resolved layout onto a different pane set', () => {
    const workspace = () => (
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />
    );
    const view = render(workspace());
    act(() => layoutChange?.({ 'editor-pane:pane-a': 45, 'editor-pane:pane-b': 55 }));
    expect(
      view.container.querySelector<HTMLElement>('[data-editor-pane-tab-group]')?.style.flexGrow,
    ).toBe('45');

    panes = [
      { ...multiPaneFixture[0], size: 70 },
      { ...multiPaneFixture[1], id: 'pane-c', size: 30 },
    ];
    view.rerender(workspace());

    const groups = [
      ...view.container.querySelectorAll<HTMLElement>('[data-editor-pane-tab-group]'),
    ];
    expect(groups.map((group) => group.dataset.editorPaneTabGroup)).toEqual(['pane-a', 'pane-c']);
    expect(groups[0]?.style.flexGrow).toBe('70');
    expect(groups[1]?.style.flexGrow).toBe('30');
  });

  test('omits the focused tab-strip accent in single-pane mode', () => {
    panes = [
      {
        id: 'pane-a',
        openTabs: ['docs/a'],
        pinnedTabIds: [],
        activeTabId: 'docs/a',
        newTabIds: [],
        activeNewTabId: null,
        activeTarget: { kind: 'doc', target: 'docs/a', docName: 'docs/a' },
        size: 100,
      },
    ];

    const { container } = renderWorkspace();
    const pane = container.querySelector('[data-editor-pane-id="pane-a"]');
    const tabGroup = container.querySelector<HTMLElement>('[data-editor-pane-tab-group="pane-a"]');

    expect(pane?.getAttribute('aria-current')).toBe('true');
    expect(pane?.getAttribute('data-editor-pane-focused')).toBe('true');
    expectVisualClassTokensAbsent(tabGroup?.className ?? '', ['after:bg-primary']);
  });

  test('keeps a dragged tab visible outside the clipped header until the drag ends', () => {
    renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');

    expect(screen.queryByTestId('editor-tab-drag-overlay')).toBeNull();
    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    const overlay = screen.getByTestId('editor-tab-drag-overlay');
    expect(overlay.textContent).toBe('docs/b');
    expect(overlay.className).toContain('w-44');
    expect(overlay.className).toContain('cursor-grabbing');
    expectVisualClassTokens(overlay.className, [
      'bg-sidebar-selected',
      'text-sidebar-selected-foreground',
    ]);
    expectVisualClassTokensAbsent(overlay.className, ['text-foreground']);
    expect(dragOverlayProps.dropAnimation).toBeNull();
    expect(document.body.hasAttribute('data-editor-tab-dragging')).toBe(true);

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: active } },
        over: null,
      }),
    );
    expect(screen.queryByTestId('editor-tab-drag-overlay')).toBeNull();
    expect(document.body.hasAttribute('data-editor-tab-dragging')).toBe(false);
    expect(moveTabToPane).not.toHaveBeenCalled();
    expect(reorderTabsInPane).not.toHaveBeenCalled();
    expect(splitTab).not.toHaveBeenCalled();
  });

  test('moves a primary insertion boundary without moving the tab row', () => {
    const { container } = renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');

    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    act(() =>
      latestDndProps().onDragMove?.({
        active: {
          data: { current: active },
          rect: { current: { translated: { left: 180, width: 40 } as DOMRect } },
        },
        over: {
          data: { current: tabDrag('pane-b', 'docs/c') },
          rect: { left: 100, width: 100 } as DOMRect,
        },
      }),
    );

    expect(
      container
        .querySelector('[data-editor-pane-tabs="pane-b"]')
        ?.getAttribute('data-drop-indicator-index'),
    ).toBe('1');
    expect(
      container
        .querySelector('[data-editor-pane-tabs="pane-a"]')
        ?.getAttribute('data-drop-indicator-index'),
    ).toBeNull();

    act(() => latestDndProps().onDragCancel?.());
    expect(container.querySelector('[data-drop-indicator-index]')).toBeNull();
  });

  test('shows the separator before an earlier tab as soon as a leftward drag enters it', () => {
    const { container } = renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');

    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    act(() =>
      latestDndProps().onDragMove?.({
        active: {
          data: { current: active },
          rect: { current: { translated: { left: 80, width: 40 } as DOMRect } },
        },
        delta: { x: -2, y: 0 },
        over: {
          data: { current: tabDrag('pane-a', 'docs/a') },
          rect: { left: 0, width: 100 } as DOMRect,
        },
      }),
    );

    expect(
      container
        .querySelector('[data-editor-pane-tabs="pane-a"]')
        ?.getAttribute('data-drop-indicator-index'),
    ).toBe('0');
  });

  test('hides separators for no-op boundaries around the dragged tab', () => {
    const { container } = renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');

    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    for (const x of [-2, 2]) {
      act(() =>
        latestDndProps().onDragMove?.({
          active: {
            data: { current: active },
            rect: { current: { translated: { left: 100 + x, width: 100 } as DOMRect } },
          },
          delta: { x, y: 0 },
          over: {
            data: { current: active },
            rect: { left: 100, width: 100 } as DOMRect,
          },
        }),
      );
      expect(container.querySelector('[data-drop-indicator-index]')).toBeNull();
    }

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: active } },
        delta: { x: 2, y: 0 },
        over: { data: { current: active } },
      }),
    );
    expect(reorderTabsInPane).not.toHaveBeenCalled();
  });

  test('exposes visible document hosts and one hidden parking mount', async () => {
    const { container } = renderWorkspace();
    await act(async () => {});

    expect(
      container
        .querySelector('[data-editor-activity-mount="pane-a"]')
        ?.getAttribute('data-doc-name'),
    ).toBe('docs/a');
    expect(
      container
        .querySelector('[data-editor-activity-mount="pane-b"]')
        ?.getAttribute('data-doc-name'),
    ).toBe('docs/c');
    expect(container.querySelectorAll('[data-editor-activity-parking]')).toHaveLength(1);
    expect(screen.getByTestId('activity-bindings').dataset.visible).toBe('docs/a,docs/c');
  });

  test('focuses a pane from pointer and keyboard focus capture', () => {
    const { container } = renderWorkspace();
    const pane = container.querySelector<HTMLElement>('[data-editor-pane-id="pane-b"]');
    const activityMount = container.querySelector<HTMLElement>(
      '[data-editor-activity-mount="pane-b"]',
    );
    expect(pane).toBeTruthy();
    expect(activityMount).toBeTruthy();

    fireEvent.pointerDown(pane as HTMLElement);
    fireEvent.focusIn(pane as HTMLElement);
    expect(focusPane).toHaveBeenCalledTimes(2);

    focusPane.mockClear();
    fireEvent.pointerDown(activityMount as HTMLElement);

    expect(focusPane).toHaveBeenCalled();
    expect(focusPane).toHaveBeenLastCalledWith('pane-b');
  });

  test('accepts a sidebar file before its drag payload is readable and opens it on drop', () => {
    panes = [
      multiPaneFixture[0],
      {
        ...multiPaneFixture[1],
        activeTabId: null,
        newTabIds: ['new-tab:1'],
        activeNewTabId: 'new-tab:1',
        activeTarget: null,
      },
    ];
    const { container } = renderWorkspace();
    const pane = container.querySelector<HTMLElement>('[data-editor-pane-id="pane-b"]');
    let payloadReadable = false;
    const dataTransfer = {
      types: [OK_SIDEBAR_DRAG_MIME],
      getData: (type: string) =>
        type === OK_SIDEBAR_DRAG_MIME && payloadReadable
          ? serializeSidebarDragPayload({
              v: 1,
              kind: 'doc',
              docName: 'notes/Dragged',
              size: null,
            })
          : '',
      dropEffect: 'none',
    };

    fireEvent.dragOver(pane as HTMLElement, { dataTransfer });
    expect(pane?.getAttribute('data-sidebar-drop-active')).toBe('true');
    expect(dataTransfer.dropEffect).toBe('copy');
    expectVisualClassTokens(pane?.className ?? '', [
      'after:bg-primary/5',
      'after:ring-2',
      'after:ring-primary/70',
      'after:ring-inset',
    ]);
    expectVisualClassTokensAbsent(pane?.className ?? '', [
      'after:border-muted-foreground/35',
      'after:bg-muted/15',
    ]);

    payloadReadable = true;
    fireEvent.drop(pane as HTMLElement, { dataTransfer });

    expect(openTargetInPane).toHaveBeenCalledWith(
      'pane-b',
      { kind: 'doc', target: 'notes/Dragged', docName: 'notes/Dragged' },
      { disposition: 'permanent', consumeActiveNewTab: true },
    );
    expect(pane?.getAttribute('data-sidebar-drop-active')).toBeNull();
  });

  test('captures a sidebar drop from portaled editor DOM before the editor consumes it', () => {
    const consumeDrop = vi.fn((event: Event) => {
      event.preventDefault();
      event.stopPropagation();
    });
    const { container } = renderWorkspace(<div data-testid="portaled-pane-body" />);
    const portaledPaneBody = screen.getByTestId('portaled-pane-body');
    portaledPaneBody.addEventListener('drop', consumeDrop);
    const dataTransfer = {
      types: [OK_SIDEBAR_DRAG_MIME],
      getData: (type: string) =>
        type === OK_SIDEBAR_DRAG_MIME
          ? serializeSidebarDragPayload({
              v: 1,
              kind: 'doc',
              docName: 'notes/Nested',
              size: null,
            })
          : '',
      dropEffect: 'none',
    };

    expect(portaledPaneBody.closest('[data-editor-activity-mount="pane-b"]')).not.toBeNull();
    fireEvent.drop(portaledPaneBody, { dataTransfer });

    expect(openTargetInPane).toHaveBeenCalledTimes(1);
    expect(openTargetInPane).toHaveBeenCalledWith(
      'pane-b',
      { kind: 'doc', target: 'notes/Nested', docName: 'notes/Nested' },
      { disposition: 'permanent', consumeActiveNewTab: false },
    );
    expect(consumeDrop).not.toHaveBeenCalled();
    expect(
      container
        .querySelector('[data-editor-pane-id="pane-b"]')
        ?.getAttribute('data-sidebar-drop-active'),
    ).toBeNull();
    portaledPaneBody.removeEventListener('drop', consumeDrop);
  });

  test('clears the sidebar preview without consuming a malformed custom drop', () => {
    const { container } = renderWorkspace();
    const pane = container.querySelector<HTMLElement>('[data-editor-pane-id="pane-b"]');
    const nestedPaneBody = screen.getByTestId('pane-body-pane-b');
    const nestedDrop = vi.fn();
    nestedPaneBody.addEventListener('drop', nestedDrop);
    const dataTransfer = {
      types: [OK_SIDEBAR_DRAG_MIME],
      getData: () => '{',
      dropEffect: 'none',
    };

    fireEvent.dragOver(nestedPaneBody, { dataTransfer });
    expect(pane?.getAttribute('data-sidebar-drop-active')).toBe('true');

    fireEvent.drop(nestedPaneBody, { dataTransfer });

    expect(nestedDrop).toHaveBeenCalledTimes(1);
    expect(openTarget).not.toHaveBeenCalled();
    expect(pane?.getAttribute('data-sidebar-drop-active')).toBeNull();

    nestedPaneBody.removeEventListener('drop', nestedDrop);
  });

  test('clears the sidebar preview when the source drag ends outside the pane', () => {
    const { container } = renderWorkspace();
    const pane = container.querySelector<HTMLElement>('[data-editor-pane-id="pane-b"]');
    const dataTransfer = {
      types: [OK_SIDEBAR_DRAG_MIME],
      getData: () => '',
      dropEffect: 'none',
    };

    fireEvent.dragOver(pane as HTMLElement, { dataTransfer });
    expect(pane?.getAttribute('data-sidebar-drop-active')).toBe('true');

    fireEvent.dragEnd(window);

    expect(pane?.getAttribute('data-sidebar-drop-active')).toBeNull();
    expectVisualClassTokensAbsent(pane?.className ?? '', [
      'after:bg-primary/5',
      'after:ring-2',
      'after:ring-primary/70',
      'after:ring-inset',
    ]);
  });

  test('prioritizes edge splits and clears the preview after drop', () => {
    const { container, rerender } = renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');

    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    overDroppableId = 'editor-pane-edge:pane-b:right';
    rerender(
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );

    expect(
      container
        .querySelector('[data-pane-edge="right"][data-editor-pane-id="pane-b"]')
        ?.getAttribute('data-pane-drop-side'),
    ).toBe('right');
    const highlightedEdge = container.querySelector(
      '[data-pane-edge="right"][data-editor-pane-id="pane-b"]',
    );
    expect(highlightedEdge?.textContent).toBe('');
    expect(highlightedEdge?.querySelector('svg')).toBeNull();

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: active } },
        over: {
          data: {
            current: { kind: 'pane-edge', paneId: 'pane-b', side: 'right' },
          },
        },
      }),
    );

    expect(splitTab).toHaveBeenCalledWith('docs/b', 'pane-b', 'right');
    expect(
      container
        .querySelector('[data-pane-edge="right"][data-editor-pane-id="pane-b"]')
        ?.getAttribute('data-pane-drop-side'),
    ).toBeNull();
  });

  test('shows one monolithic split highlight across an internal pane boundary', () => {
    const { container, rerender } = renderWorkspace();
    const active = tabDrag('pane-a', 'docs/b');
    const boundary = () => container.querySelector<HTMLElement>('[data-pane-boundary-drop]');

    act(() => latestDndProps().onDragStart?.({ active: { data: { current: active } } }));
    overDroppableId = 'editor-pane-edge:pane-a:right';
    rerender(
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );

    expect(container.querySelectorAll('[data-pane-drop-side]')).toHaveLength(1);
    expect(boundary()?.getAttribute('data-pane-drop-side')).toBe('right');
    expectVisualClassTokens(boundary()?.className ?? '', [
      'w-24',
      '-translate-x-1/2',
      'bg-primary/15',
      'ring-primary',
    ]);
    expect(boundary()?.textContent).toBe('');
    expect(boundary()?.querySelector('svg')).toBeNull();

    overDroppableId = 'editor-pane-edge:pane-b:left';
    rerender(
      <EditorWorkspace
        renderHeader={(tabs) => <header data-testid="main-editor-header">{tabs}</header>}
        renderPane={({ pane }) => <div data-testid={`pane-body-${pane.id}`} />}
      />,
    );

    expect(container.querySelectorAll('[data-pane-drop-side]')).toHaveLength(1);
    expect(boundary()?.getAttribute('data-pane-drop-side')).toBe('left');
    expectVisualClassTokensAbsent(boundary()?.className ?? '', ['transition-opacity']);
  });

  test('lets a blank tab drag to a pane edge and participate in combined tab order', () => {
    panes = [
      {
        ...multiPaneFixture[0],
        newTabIds: ['new-tab:1'],
        activeNewTabId: 'new-tab:1',
        activeTabId: null,
        activeTarget: null,
      },
      multiPaneFixture[1],
    ];
    renderWorkspace();
    const active = tabDrag('pane-a', 'new-tab:1');

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: active } },
        over: {
          data: {
            current: { kind: 'pane-edge', paneId: 'pane-b', side: 'left' },
          },
        },
      }),
    );

    expect(splitTab).toHaveBeenCalledWith('new-tab:1', 'pane-b', 'left');

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: active } },
        over: { data: { current: tabDrag('pane-a', 'docs/a') } },
      }),
    );
    expect(reorderTabsInPane).toHaveBeenCalledWith(
      'pane-a',
      ['new-tab:1', 'docs/a', 'docs/b'],
      'new-tab:1',
    );
  });

  test('moves across panes, reorders in one strip, and ignores cancellation', () => {
    renderWorkspace();

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: tabDrag('pane-a', 'docs/b') } },
        over: { data: { current: tabDrag('pane-b', 'docs/c') } },
      }),
    );
    expect(moveTabToPane).toHaveBeenCalledWith('docs/b', 'pane-b', 0);

    act(() =>
      latestDndProps().onDragEnd?.({
        active: { data: { current: tabDrag('pane-a', 'docs/b') } },
        over: { data: { current: tabDrag('pane-a', 'docs/a') } },
      }),
    );
    expect(reorderTabsInPane).toHaveBeenCalledWith('pane-a', ['docs/b', 'docs/a'], 'docs/b');

    latestDndProps().onDragCancel?.();
    expect(splitTab).not.toHaveBeenCalled();
  });

  test('persists only user-authored pane resize layouts', () => {
    renderWorkspace();

    act(() => {
      layoutChanged?.(
        { 'editor-pane:pane-a': 45, 'editor-pane:pane-b': 55 },
        { isUserInteraction: false },
      );
    });
    expect(resizePanes).not.toHaveBeenCalled();

    act(() => {
      layoutChanged?.(
        { 'editor-pane:pane-a': 45, 'editor-pane:pane-b': 55 },
        { isUserInteraction: true },
      );
    });
    expect(resizePanes).toHaveBeenCalledWith(
      new Map([
        ['pane-a', 45],
        ['pane-b', 55],
      ]),
    );
  });

  test('portals dnd accessibility output to document.body', () => {
    renderWorkspace();
    const accessibility = latestDndProps().accessibility;
    expect(accessibility?.container).toBe(document.body);
    expect(accessibility?.screenReaderInstructions?.draggable).toContain('Shift+F10');
    expect(accessibility?.screenReaderInstructions?.draggable).toContain('Menu key');
    expect(accessibility?.screenReaderInstructions?.draggable).toContain('close');
    expect(accessibility?.screenReaderInstructions?.draggable).toContain('pin');
    expect(
      accessibility?.announcements?.onDragStart?.({
        active: { data: { current: tabDrag('pane-a', 'docs/a') } },
      }),
    ).toBe('Picked up docs/a from pane 1.');
    expect(
      accessibility?.announcements?.onDragOver?.({
        active: { data: { current: tabDrag('pane-a', 'docs/a') } },
        over: {
          data: { current: { kind: 'pane-edge', paneId: 'pane-b', side: 'right' } },
        },
      }),
    ).toBe('docs/a is over a new pane to the right of pane 2.');
  });
});