Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

33.3 KB
Raw Blame
import { describe, expect, test } from 'vitest';
import {
  closeTabsInPane,
  createEmptyEditorPane,
  createEmptyEditorWorkspace,
  type EditorWorkspaceState,
  findPaneOwningTab,
  flattenWorkspacePinnedTabs,
  flattenWorkspaceTabs,
  focusEditorPane,
  hydrateEditorWorkspace,
  moveTabToPane,
  normalizeEditorWorkspace,
  parsePersistedEditorWorkspace,
  persistEditorWorkspace,
  preserveLivePreviewTabs,
  projectVisibleEditorWorkspace,
  pruneEmptyEditorPanes,
  recordRecentlyClosedTab,
  remapWorkspaceTabs,
  reorderPaneTabs,
  splitTabToPane,
  tabBucketIndexForVisibleInsertion,
  transitionEditorWorkspace,
} from './editor-panes';

function docTarget(docName: string) {
  return { kind: 'doc' as const, target: docName, docName };
}

function pane(
  id: string,
  openTabs: string[],
  activeTabId: string | null = openTabs[0] ?? null,
  size = 100,
) {
  return {
    ...createEmptyEditorPane(id, size),
    openTabs,
    activeTabId,
    activeTarget: activeTabId ? docTarget(activeTabId) : null,
  };
}

describe('editor pane workspace', () => {
  test('rejects malformed workspaces and drops legacy occurrence ids', () => {
    const malformed = parsePersistedEditorWorkspace({ panes: [{ id: '', openTabs: ['a'] }] });
    const legacy = parsePersistedEditorWorkspace({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['a', 'a\u0000doc-tab:1', 'b', 42],
          pinnedTabIds: ['a\u0000doc-tab:1', 'missing'],
          activeTabId: 'a\u0000doc-tab:1',
          size: 0,
        },
      ],
      focusedPaneId: 'missing-pane',
    });

    expect(malformed).toEqual({
      panes: [{ id: 'pane-main', openTabs: [], pinnedTabIds: [], activeTabId: null, size: 100 }],
      focusedPaneId: 'pane-main',
    });
    expect(legacy).toEqual({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['a', 'b'],
          pinnedTabIds: [],
          activeTabId: 'a',
          size: 100,
        },
      ],
      focusedPaneId: 'pane-a',
    });
  });

  test('hydrates persisted panes with empty runtime-only state', () => {
    expect(
      hydrateEditorWorkspace({
        panes: [
          {
            id: 'pane-a',
            openTabs: ['a'],
            pinnedTabIds: ['a'],
            activeTabId: 'a',
            size: 100,
          },
        ],
        focusedPaneId: 'pane-a',
      }),
    ).toEqual({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['a'],
          pinnedTabIds: ['a'],
          activeTabId: 'a',
          previewTabId: null,
          newTabIds: [],
          activeNewTabId: null,
          activeTarget: null,
          size: 100,
        },
      ],
      focusedPaneId: 'pane-a',
    });
  });

  test('preserves live preview markers while merging restored tabs', () => {
    const restored = hydrateEditorWorkspace({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['other'],
          pinnedTabIds: [],
          activeTabId: 'other',
          size: 100,
        },
      ],
      focusedPaneId: 'pane-a',
    });
    const live = {
      panes: [
        {
          ...pane('pane-a', ['other', 'preview'], 'preview'),
          previewTabId: 'preview',
        },
      ],
      focusedPaneId: 'pane-a',
    };

    const merged = preserveLivePreviewTabs(
      {
        ...restored,
        panes: restored.panes.map((item) => ({
          ...item,
          openTabs: ['other', 'preview'],
          activeTabId: 'preview',
        })),
      },
      live,
      { panes: [{ ...restored.panes[0], openTabs: ['other'] }] },
    );

    expect(merged.panes[0]?.previewTabId).toBe('preview');
  });

  test('keeps persisted tabs permanent when a live preview marker overlaps them', () => {
    const persisted = {
      panes: [
        {
          id: 'pane-a',
          openTabs: ['saved'],
          pinnedTabIds: [],
          activeTabId: 'saved',
          size: 100,
        },
      ],
      focusedPaneId: 'pane-a',
    };
    const restored = hydrateEditorWorkspace(persisted);
    const live = {
      panes: [{ ...pane('pane-a', ['saved'], 'saved'), previewTabId: 'saved' }],
      focusedPaneId: 'pane-a',
    };

    const merged = preserveLivePreviewTabs(restored, live, persisted);

    expect(merged.panes[0]?.previewTabId).toBeNull();
  });

  test('matches duplicate independent preview ids to their live panes', () => {
    const folderTabId = '\u0000folder:foo';
    const workspace = {
      panes: [
        { ...pane('pane-a', [folderTabId], folderTabId, 50), previewTabId: null },
        { ...pane('pane-b', [folderTabId], folderTabId, 50), previewTabId: null },
      ],
      focusedPaneId: 'pane-b',
    };
    const live = {
      panes: [
        { ...pane('pane-a', [folderTabId], folderTabId, 50), previewTabId: folderTabId },
        { ...pane('pane-b', [folderTabId], folderTabId, 50), previewTabId: folderTabId },
      ],
      focusedPaneId: 'pane-b',
    };

    const merged = preserveLivePreviewTabs(workspace, live, { panes: [] });

    expect(merged.panes.map((item) => item.previewTabId)).toEqual([folderTabId, folderTabId]);
  });

  test('falls back to a restored pane when a live preview pane id differs', () => {
    const previewTabId = '\u0000folder:foo';
    const workspace = {
      panes: [{ ...pane('restored-pane', [previewTabId], previewTabId), previewTabId: null }],
      focusedPaneId: 'restored-pane',
    };
    const live = {
      panes: [{ ...pane('live-pane', [previewTabId], previewTabId), previewTabId }],
      focusedPaneId: 'live-pane',
    };

    const merged = preserveLivePreviewTabs(workspace, live, { panes: [] });

    expect(merged.panes[0]?.previewTabId).toBe(previewTabId);
  });

  test('normalizes current ids, target ownership, pins, focus, and size percentages', () => {
    const workspace = normalizeEditorWorkspace({
      panes: [
        {
          ...pane('pane-a', ['a', 'a\u0000doc-tab:1', 'b'], 'missing', 1),
          pinnedTabIds: ['a', 'missing'],
        },
        { ...pane('pane-a', ['c'], 'c', 1) },
        { ...pane('pane-b', ['b', 'c'], 'c', 3) },
      ],
      focusedPaneId: 'missing',
    });

    expect(workspace).toEqual({
      panes: [
        {
          ...pane('pane-a', ['a', 'b'], 'a', 25),
          pinnedTabIds: ['a'],
          activeTarget: null,
        },
        { ...pane('pane-b', ['c'], 'c', 75) },
      ],
      focusedPaneId: 'pane-a',
    });
    expect(flattenWorkspaceTabs(workspace)).toEqual(['a', 'b', 'c']);
    expect(flattenWorkspacePinnedTabs(workspace)).toEqual(['a']);
    expect(findPaneOwningTab(workspace, 'a')?.id).toBe('pane-a');
    expect(findPaneOwningTab(workspace, 'a\u0000doc-tab:7')).toBeNull();
  });

  test('falls back to the first tab when a persisted pane has no valid active tab', () => {
    const workspace = parsePersistedEditorWorkspace({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['a', 'b'],
          pinnedTabIds: [],
          activeTabId: null,
          size: 50,
        },
        {
          id: 'pane-b',
          openTabs: ['c', 'd'],
          pinnedTabIds: [],
          activeTabId: 'missing',
          size: 50,
        },
      ],
      focusedPaneId: 'pane-b',
    });

    expect(workspace.panes.map(({ id, activeTabId }) => ({ id, activeTabId }))).toEqual([
      { id: 'pane-a', activeTabId: 'a' },
      { id: 'pane-b', activeTabId: 'c' },
    ]);
  });

  test('normalizes every non-empty runtime pane to exactly one active tab', () => {
    const workspace = normalizeEditorWorkspace({
      panes: [
        { ...pane('pane-a', ['a'], null, 50), activeTarget: docTarget('stale') },
        {
          ...pane('pane-b', [], null, 50),
          newTabIds: ['new-tab:1'],
          activeNewTabId: null,
        },
      ],
      focusedPaneId: 'pane-a',
    });

    expect(workspace.panes[0]).toMatchObject({
      activeTabId: 'a',
      activeNewTabId: null,
      activeTarget: null,
    });
    expect(workspace.panes[1]).toMatchObject({
      activeTabId: null,
      activeNewTabId: 'new-tab:1',
      activeTarget: null,
    });
  });

  test('lets the focused pane claim document tabs first, prunes empty panes, and normalizes sizes', () => {
    const workspace = parsePersistedEditorWorkspace({
      panes: [
        {
          id: 'pane-a',
          openTabs: ['a', 'b'],
          pinnedTabIds: ['a'],
          activeTabId: 'b',
          size: 25,
        },
        {
          id: 'pane-b',
          openTabs: ['a'],
          pinnedTabIds: ['a'],
          activeTabId: 'a',
          size: 50,
        },
        {
          id: 'pane-c',
          openTabs: ['a', 'c'],
          pinnedTabIds: [],
          activeTabId: 'c',
          size: 25,
        },
        {
          id: 'pane-d',
          openTabs: ['a'],
          pinnedTabIds: [],
          activeTabId: 'a',
          size: 100,
        },
      ],
      focusedPaneId: 'pane-b',
    });

    expect(workspace).toEqual({
      panes: [
        { id: 'pane-a', openTabs: ['b'], pinnedTabIds: [], activeTabId: 'b', size: 25 },
        { id: 'pane-b', openTabs: ['a'], pinnedTabIds: ['a'], activeTabId: 'a', size: 50 },
        { id: 'pane-c', openTabs: ['c'], pinnedTabIds: [], activeTabId: 'c', size: 25 },
      ],
      focusedPaneId: 'pane-b',
    });
    expect(parsePersistedEditorWorkspace(workspace)).toEqual(workspace);
  });

  test('splits a tab into a new side-by-side pane, clears the new selection target, and preserves the old selection', () => {
    const workspace: EditorWorkspaceState = {
      panes: [pane('pane-a', ['a', 'b'], 'a')],
      focusedPaneId: 'pane-a',
    };

    const split = splitTabToPane(workspace, 'b', 'pane-a', 'right', () => 'pane-b');

    expect(split.panes).toEqual([
      { ...pane('pane-a', ['a'], 'a', 50) },
      { ...pane('pane-b', ['b'], 'b', 50), activeTarget: null },
    ]);
    expect(split.focusedPaneId).toBe('pane-b');
    expect(splitTabToPane(split, 'b', 'pane-b', 'left', () => 'pane-c')).toEqual(split);
    expect(splitTabToPane(workspace, 'b', 'pane-a', 'right', () => 'pane-a')).toBe(workspace);
  });

  test('splits folder and blank tabs when they share a pane', () => {
    const folderTabId = '\u0000folder:New Folder 5';
    const newTabId = 'new-tab:1';
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', [folderTabId], folderTabId),
          newTabIds: [newTabId],
        },
      ],
      focusedPaneId: 'pane-a',
    };

    const folderSplit = splitTabToPane(
      workspace,
      folderTabId,
      'pane-a',
      'left',
      () => 'pane-folder',
    );
    expect(folderSplit.panes[0]).toMatchObject({
      id: 'pane-folder',
      openTabs: [folderTabId],
      activeTabId: folderTabId,
      newTabIds: [],
      activeNewTabId: null,
    });
    expect(folderSplit.panes[1]).toMatchObject({
      id: 'pane-a',
      openTabs: [],
      newTabIds: [newTabId],
      activeNewTabId: newTabId,
    });

    const blankSplit = splitTabToPane(workspace, newTabId, 'pane-a', 'right', () => 'pane-blank');
    expect(blankSplit.panes[0]).toMatchObject({
      id: 'pane-a',
      openTabs: [folderTabId],
      newTabIds: [],
    });
    expect(blankSplit.panes[1]).toMatchObject({
      id: 'pane-blank',
      openTabs: [],
      activeTabId: null,
      newTabIds: [newTabId],
      activeNewTabId: newTabId,
    });
    expect(findPaneOwningTab(workspace, newTabId)?.id).toBe('pane-a');
  });

  test('moves tabs between panes, maintains pins, and clears any stale active target', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        { ...pane('pane-a', ['a', 'b'], 'b'), pinnedTabIds: ['b'] },
        pane('pane-b', ['c'], 'c'),
      ],
      focusedPaneId: 'pane-a',
    };

    const moved = moveTabToPane(workspace, 'b', 'pane-b', 1);

    expect(moved.panes).toEqual([
      { ...pane('pane-a', ['a'], 'a', 50), activeTarget: null },
      { ...pane('pane-b', ['c', 'b'], 'b', 50), pinnedTabIds: ['b'], activeTarget: null },
    ]);
    expect(moved.focusedPaneId).toBe('pane-b');
  });

  test('translates a visible insertion around interleaved blank tabs to its bucket index', () => {
    const visibleOrder = ['doc-a', 'new-tab:1', 'doc-b', 'new-tab:2'];

    expect(tabBucketIndexForVisibleInsertion([], [], 0)).toBe(0);
    expect(tabBucketIndexForVisibleInsertion(visibleOrder, ['doc-a', 'doc-b'], 0)).toBe(0);
    expect(tabBucketIndexForVisibleInsertion(visibleOrder, ['doc-a', 'doc-b'], 2)).toBe(1);
    expect(tabBucketIndexForVisibleInsertion(visibleOrder, ['new-tab:1', 'new-tab:2'], 3)).toBe(1);
    expect(tabBucketIndexForVisibleInsertion(visibleOrder, ['doc-a', 'doc-b'], 99)).toBe(2);
  });

  test('moves blank tabs between panes and activates them at the destination', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        { ...pane('pane-a', ['a'], null), newTabIds: ['new-tab:1'], activeNewTabId: 'new-tab:1' },
        pane('pane-b', ['b'], 'b'),
      ],
      focusedPaneId: 'pane-a',
    };

    const moved = moveTabToPane(workspace, 'new-tab:1', 'pane-b', 0);

    expect(moved.panes[0]).toMatchObject({
      id: 'pane-a',
      openTabs: ['a'],
      activeTabId: 'a',
      newTabIds: [],
      activeNewTabId: null,
    });
    expect(moved.panes[1]).toMatchObject({
      id: 'pane-b',
      openTabs: ['b'],
      activeTabId: null,
      newTabIds: ['new-tab:1'],
      activeNewTabId: 'new-tab:1',
      activeTarget: null,
    });
    expect(moved.focusedPaneId).toBe('pane-b');
  });

  test('reorders a tab within its current pane through the move operation', () => {
    const workspace: EditorWorkspaceState = {
      panes: [{ ...pane('pane-a', ['a', 'b', 'c'], 'b'), pinnedTabIds: ['a'] }],
      focusedPaneId: 'pane-a',
    };

    expect(moveTabToPane(workspace, 'c', 'pane-a', 0).panes[0]).toEqual({
      ...pane('pane-a', ['c', 'a', 'b'], 'b'),
      pinnedTabIds: ['c', 'a'],
    });
    expect(moveTabToPane(workspace, 'a', 'pane-a', 99).panes[0]).toEqual({
      ...pane('pane-a', ['b', 'c', 'a'], 'b'),
      pinnedTabIds: [],
    });
  });

  test('reorders tabs in one pane and adjusts only the dragged tab pin state', () => {
    const workspace: EditorWorkspaceState = {
      panes: [{ ...pane('pane-a', ['pinned', 'a', 'b'], 'a'), pinnedTabIds: ['pinned'] }],
      focusedPaneId: 'pane-a',
    };

    expect(reorderPaneTabs(workspace, 'pane-a', ['b', 'pinned', 'a'], 'b').panes[0]).toEqual({
      ...pane('pane-a', ['b', 'pinned', 'a'], 'a'),
      pinnedTabIds: ['b', 'pinned'],
    });
  });

  test('prunes empty panes, preserves one empty workspace, and focuses a surviving pane', () => {
    const workspace: EditorWorkspaceState = {
      panes: [pane('pane-a', [], null), pane('pane-b', ['b'], 'b', 25), pane('pane-c', [], null)],
      focusedPaneId: 'pane-a',
    };

    expect(pruneEmptyEditorPanes(workspace)).toEqual({
      panes: [{ ...pane('pane-b', ['b'], 'b', 100) }],
      focusedPaneId: 'pane-b',
    });
    expect(
      pruneEmptyEditorPanes({ panes: [pane('pane-a', [], null)], focusedPaneId: 'pane-a' }),
    ).toEqual(createEmptyEditorWorkspace(() => 'pane-a'));
  });

  test('projects only panes with visible tabs without deleting the saved workspace', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        pane('pane-files', ['file-a'], 'file-a', 25),
        {
          ...pane('pane-mixed', ['file-b', 'skill-b'], 'file-b', 50),
          pinnedTabIds: ['file-b', 'skill-b'],
          previewTabId: 'file-b',
        },
        pane('pane-skills', ['skill-c'], 'skill-c', 25),
      ],
      focusedPaneId: 'pane-files',
    };

    const projected = projectVisibleEditorWorkspace(
      workspace,
      new Map([
        ['pane-files', []],
        ['pane-mixed', ['skill-b']],
        ['pane-skills', ['skill-c']],
      ]),
    );

    expect(projected).toEqual({
      panes: [
        {
          ...pane('pane-mixed', ['skill-b'], 'skill-b', 100 * (2 / 3)),
          pinnedTabIds: ['skill-b'],
          activeTarget: null,
        },
        pane('pane-skills', ['skill-c'], 'skill-c', 100 * (1 / 3)),
      ],
      focusedPaneId: 'pane-mixed',
    });
    expect(workspace.panes.map((candidate) => candidate.openTabs)).toEqual([
      ['file-a'],
      ['file-b', 'skill-b'],
      ['skill-c'],
    ]);
  });

  test('projects a valid empty workspace when no pane has visible tabs', () => {
    const workspace: EditorWorkspaceState = {
      panes: [pane('pane-skills', ['skill-a'], 'skill-a')],
      focusedPaneId: 'pane-skills',
    };

    expect(projectVisibleEditorWorkspace(workspace, new Map([['pane-skills', []]]))).toEqual(
      createEmptyEditorWorkspace(() => 'pane-skills'),
    );
  });

  test('preserves a preview tab when it remains visible in the projected pane', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-files', ['file-a', 'file-preview'], 'file-a'),
          previewTabId: 'file-preview',
        },
      ],
      focusedPaneId: 'pane-files',
    };

    expect(
      projectVisibleEditorWorkspace(
        workspace,
        new Map([['pane-files', ['file-a', 'file-preview']]]),
      ),
    ).toEqual(workspace);
  });

  test('closes and remaps tabs without retaining a target for a changed selection', () => {
    const workspace: EditorWorkspaceState = {
      panes: [pane('pane-a', ['a', 'b'], 'a')],
      focusedPaneId: 'pane-a',
    };

    const closed = closeTabsInPane(workspace, 'pane-a', ['a']);
    expect(closed.panes[0]).toEqual({ ...pane('pane-a', ['b'], 'b', 100), activeTarget: null });

    const remapped = remapWorkspaceTabs(
      { panes: [pane('pane-a', ['a', 'b'], 'b')], focusedPaneId: 'pane-a' },
      (tabId) => (tabId === 'b' ? 'renamed-b' : tabId),
    );
    expect(remapped.panes[0]).toEqual({
      ...pane('pane-a', ['a', 'renamed-b'], 'renamed-b', 100),
      activeTarget: null,
    });

    const duplicates = remapWorkspaceTabs(
      {
        panes: [pane('pane-a', ['a']), pane('pane-b', ['b'])],
        focusedPaneId: 'pane-a',
      },
      () => 'renamed',
    );
    expect(duplicates.panes).toEqual([
      { ...pane('pane-a', ['renamed'], 'renamed', 100), activeTarget: null },
    ]);
  });

  test('replaces only the pane preview and reports displacement without closing history', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', ['permanent', 'preview-old'], 'permanent'),
          previewTabId: 'preview-old',
        },
      ],
      focusedPaneId: 'pane-a',
    };

    const transition = transitionEditorWorkspace(workspace, {
      type: 'open-target',
      paneId: 'pane-a',
      tabId: 'preview-new',
      target: docTarget('preview-new'),
      disposition: 'preview',
      consumeActiveNewTab: false,
    });

    expect(transition).toMatchObject({
      openedTabId: 'preview-new',
      replacedPreviewTabId: 'preview-old',
      consumedNewTabId: null,
    });
    expect(transition.workspace.panes[0]).toMatchObject({
      openTabs: ['permanent', 'preview-new'],
      activeTabId: 'preview-new',
      previewTabId: 'preview-new',
      activeTarget: docTarget('preview-new'),
    });
  });

  test('an edited preview tab survives opening the next file; an untouched one is replaced', () => {
    const opened: EditorWorkspaceState = transitionEditorWorkspace(
      { panes: [pane('pane-a', [], null)], focusedPaneId: 'pane-a' },
      {
        type: 'open-target',
        paneId: 'pane-a',
        tabId: 'first',
        target: docTarget('first'),
        disposition: 'preview',
        consumeActiveNewTab: false,
      },
    ).workspace;
    expect(opened.panes[0]?.previewTabId).toBe('first');

    const openSecond = (workspace: EditorWorkspaceState) =>
      transitionEditorWorkspace(workspace, {
        type: 'open-target',
        paneId: 'pane-a',
        tabId: 'second',
        target: docTarget('second'),
        disposition: 'preview',
        consumeActiveNewTab: false,
      }).workspace;

    expect(openSecond(opened).panes[0]?.openTabs).toEqual(['second']);

    const edited = transitionEditorWorkspace(opened, {
      type: 'promote-preview',
      paneId: 'pane-a',
      tabId: 'first',
    }).workspace;
    expect(edited.panes[0]?.previewTabId).toBeNull();

    const afterSecond = openSecond(edited).panes[0];
    expect(afterSecond?.openTabs).toEqual(['first', 'second']);
    expect(afterSecond?.activeTabId).toBe('second');
    expect(afterSecond?.previewTabId).toBe('second');
  });

  test('promoting a tab that is not the pane preview leaves the preview alone', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', ['permanent', 'preview'], 'permanent'),
          previewTabId: 'preview',
        },
      ],
      focusedPaneId: 'pane-a',
    };

    const after = transitionEditorWorkspace(workspace, {
      type: 'promote-preview',
      paneId: 'pane-a',
      tabId: 'permanent',
    }).workspace;

    expect(after.panes[0]?.previewTabId).toBe('preview');
  });

  test('promotes an existing preview for permanent intent and never demotes a permanent tab', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', ['preview'], 'preview', 50),
          previewTabId: 'preview',
        },
        pane('pane-b', ['permanent'], 'permanent', 50),
      ],
      focusedPaneId: 'pane-a',
    };

    const promoted = transitionEditorWorkspace(workspace, {
      type: 'open-target',
      paneId: 'pane-a',
      tabId: 'preview',
      target: docTarget('preview'),
      disposition: 'permanent',
      consumeActiveNewTab: false,
    });
    expect(promoted.workspace.panes[0]?.previewTabId).toBeNull();

    const existingPermanent = transitionEditorWorkspace(promoted.workspace, {
      type: 'open-target',
      paneId: 'pane-a',
      tabId: 'permanent',
      target: docTarget('permanent'),
      disposition: 'preview',
      consumeActiveNewTab: false,
    });
    expect(existingPermanent.workspace.focusedPaneId).toBe('pane-b');
    expect(existingPermanent.workspace.panes[1]).toMatchObject({
      openTabs: ['permanent'],
      activeTabId: 'permanent',
      previewTabId: null,
    });
  });

  test('opens an existing folder tab in an explicitly targeted pane without removing the other pane copy', () => {
    const fooFolderTabId = '\u0000folder:foo';
    const barFolderTabId = '\u0000folder:bar';
    const workspace: EditorWorkspaceState = {
      panes: [
        pane('pane-a', ['foo.md'], 'foo.md', 50),
        pane('pane-b', [fooFolderTabId, barFolderTabId], barFolderTabId, 50),
      ],
      focusedPaneId: 'pane-b',
    };
    const fooFolderTarget = { kind: 'folder' as const, target: 'foo', folderPath: 'foo' };

    const transition = transitionEditorWorkspace(workspace, {
      type: 'open-target',
      paneId: 'pane-a',
      tabId: fooFolderTabId,
      target: fooFolderTarget,
      disposition: 'permanent',
      consumeActiveNewTab: false,
      existingTabBehavior: 'open-in-pane',
    });

    expect(transition.workspace.focusedPaneId).toBe('pane-a');
    expect(transition.workspace.panes[0]).toMatchObject({
      id: 'pane-a',
      openTabs: ['foo.md', fooFolderTabId],
      activeTabId: fooFolderTabId,
      activeTarget: fooFolderTarget,
    });
    expect(transition.workspace.panes[1]).toMatchObject({
      id: 'pane-b',
      openTabs: [fooFolderTabId, barFolderTabId],
      activeTabId: barFolderTabId,
    });
  });

  test('preserves independent view tabs across panes while keeping document tabs unique', () => {
    const folderTabId = '\u0000folder:foo';
    const folderTarget = { kind: 'folder' as const, target: 'foo', folderPath: 'foo' };
    const workspace = normalizeEditorWorkspace({
      panes: [
        {
          ...pane('pane-a', ['foo.md', folderTabId], folderTabId, 50),
          pinnedTabIds: [folderTabId],
          activeTarget: folderTarget,
        },
        {
          ...pane('pane-b', ['foo.md', folderTabId], folderTabId, 50),
          activeTarget: folderTarget,
        },
      ],
      focusedPaneId: 'pane-b',
    });

    expect(workspace.panes).toEqual([
      {
        ...pane('pane-a', ['foo.md', folderTabId], folderTabId, 50),
        pinnedTabIds: [folderTabId],
        activeTarget: folderTarget,
      },
      {
        ...pane('pane-b', [folderTabId], folderTabId, 50),
        activeTarget: folderTarget,
      },
    ]);
    expect(parsePersistedEditorWorkspace(persistEditorWorkspace(workspace))).toEqual({
      panes: workspace.panes.map(({ id, openTabs, pinnedTabIds, activeTabId, size }) => ({
        id,
        openTabs,
        pinnedTabIds,
        activeTabId,
        size,
      })),
      focusedPaneId: 'pane-b',
    });

    const renamedFolderTabId = '\u0000folder:renamed';
    const remapped = remapWorkspaceTabs(workspace, (tabId) =>
      tabId === folderTabId ? renamedFolderTabId : tabId,
    );
    expect(
      remapped.panes.map(({ openTabs, pinnedTabIds }) => ({ openTabs, pinnedTabIds })),
    ).toEqual([
      { openTabs: ['foo.md', renamedFolderTabId], pinnedTabIds: [renamedFolderTabId] },
      { openTabs: [renamedFolderTabId], pinnedTabIds: [] },
    ]);
  });

  test('appends a permanent tab without promoting an unrelated preview', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', ['preview'], 'preview'),
          previewTabId: 'preview',
        },
      ],
      focusedPaneId: 'pane-a',
    };

    const transition = transitionEditorWorkspace(workspace, {
      type: 'open-target',
      paneId: 'pane-a',
      tabId: 'permanent',
      target: docTarget('permanent'),
      disposition: 'permanent',
      consumeActiveNewTab: false,
    });

    expect(transition.workspace.panes[0]).toMatchObject({
      openTabs: ['preview', 'permanent'],
      activeTabId: 'permanent',
      previewTabId: 'preview',
    });
  });

  test.each(['preview', 'permanent'] as const)(
    'consumes an active blank independently of %s disposition',
    (disposition) => {
      const workspace: EditorWorkspaceState = {
        panes: [
          {
            ...pane('pane-a', ['existing'], null),
            newTabIds: ['new-tab:1'],
            activeNewTabId: 'new-tab:1',
          },
        ],
        focusedPaneId: 'pane-a',
      };

      const transition = transitionEditorWorkspace(workspace, {
        type: 'open-target',
        paneId: 'pane-a',
        tabId: 'opened',
        target: docTarget('opened'),
        disposition,
        consumeActiveNewTab: true,
      });

      expect(transition.consumedNewTabId).toBe('new-tab:1');
      expect(transition.workspace.panes[0]).toMatchObject({
        openTabs: ['existing', 'opened'],
        newTabIds: [],
        activeNewTabId: null,
        previewTabId: disposition === 'preview' ? 'opened' : null,
      });
    },
  );

  test('activates, creates, closes, pins, and promotes tabs through the command boundary', () => {
    let workspace: EditorWorkspaceState = {
      panes: [pane('pane-a', ['a'], 'a')],
      focusedPaneId: 'pane-a',
    };

    workspace = transitionEditorWorkspace(workspace, {
      type: 'open-new-tab',
      paneId: 'pane-a',
      tabId: 'new-tab:1',
    }).workspace;
    expect(workspace.panes[0]?.activeNewTabId).toBe('new-tab:1');

    workspace = transitionEditorWorkspace(workspace, {
      type: 'activate-tab',
      paneId: 'pane-a',
      tabId: 'a',
    }).workspace;
    expect(workspace.panes[0]).toMatchObject({ activeTabId: 'a', activeNewTabId: null });

    workspace = transitionEditorWorkspace(
      {
        ...workspace,
        panes: workspace.panes.map((pane) => ({ ...pane, previewTabId: 'a' })),
      },
      { type: 'pin-tab', paneId: 'pane-a', tabId: 'a' },
    ).workspace;
    expect(workspace.panes[0]).toMatchObject({ pinnedTabIds: ['a'], previewTabId: null });

    workspace = transitionEditorWorkspace(workspace, {
      type: 'unpin-tab',
      paneId: 'pane-a',
      tabId: 'a',
    }).workspace;
    expect(workspace.panes[0]?.pinnedTabIds).toEqual([]);

    workspace = transitionEditorWorkspace(
      {
        ...workspace,
        panes: workspace.panes.map((pane) => ({ ...pane, previewTabId: 'a' })),
      },
      { type: 'promote-preview', paneId: 'pane-a', tabId: 'a' },
    ).workspace;
    expect(workspace.panes[0]?.previewTabId).toBeNull();

    workspace = transitionEditorWorkspace(workspace, {
      type: 'close-tabs',
      paneId: 'pane-a',
      tabIds: ['new-tab:1'],
    }).workspace;
    expect(workspace.panes[0]?.newTabIds).toEqual([]);
  });

  test('routes organization commands through normalized workspace invariants', () => {
    let workspace: EditorWorkspaceState = {
      panes: [
        { ...pane('pane-a', ['a', 'b'], 'a', 50), previewTabId: 'b' },
        pane('pane-b', ['c'], 'c', 50),
      ],
      focusedPaneId: 'pane-a',
    };

    workspace = transitionEditorWorkspace(workspace, {
      type: 'reorder-tabs',
      paneId: 'pane-a',
      tabIds: ['b', 'a'],
      draggedTabId: 'b',
    }).workspace;
    expect(workspace.panes[0]).toMatchObject({
      openTabs: ['b', 'a'],
      pinnedTabIds: [],
      previewTabId: null,
    });

    workspace = transitionEditorWorkspace(workspace, {
      type: 'move-tab',
      tabId: 'b',
      paneId: 'pane-b',
      index: 1,
    }).workspace;
    expect(workspace.panes[1]?.openTabs).toEqual(['c', 'b']);

    workspace = transitionEditorWorkspace(workspace, {
      type: 'split-tab',
      tabId: 'b',
      paneId: 'pane-b',
      side: 'right',
      newPaneId: 'pane-c',
    }).workspace;
    expect(workspace.panes.map((item) => item.id)).toEqual(['pane-a', 'pane-b', 'pane-c']);

    workspace = transitionEditorWorkspace(workspace, {
      type: 'resize-panes',
      sizes: [20, 30, 50],
    }).workspace;
    expect(workspace.panes.map((item) => item.size)).toEqual([20, 30, 50]);

    workspace = transitionEditorWorkspace(workspace, {
      type: 'remap-tabs',
      remap: (tabId) => (tabId === 'b' ? 'renamed-b' : tabId),
    }).workspace;
    expect(flattenWorkspaceTabs(workspace)).toEqual(['a', 'c', 'renamed-b']);

    workspace = transitionEditorWorkspace(workspace, {
      type: 'prune-tabs',
      keep: (tabId) => tabId !== 'c',
    }).workspace;
    expect(flattenWorkspaceTabs(workspace)).toEqual(['a', 'renamed-b']);
    expect(workspace.panes.reduce((sum, item) => sum + item.size, 0)).toBeCloseTo(100);
  });

  test('promotes every preview without closing tabs', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        { ...pane('pane-a', ['a'], 'a', 50), previewTabId: 'a' },
        { ...pane('pane-b', ['b'], 'b', 50), previewTabId: 'b' },
      ],
      focusedPaneId: 'pane-a',
    };

    const promoted = transitionEditorWorkspace(workspace, { type: 'promote-all-previews' });
    expect(promoted.workspace.panes.map((item) => item.previewTabId)).toEqual([null, null]);
    expect(flattenWorkspaceTabs(promoted.workspace)).toEqual(['a', 'b']);
    expect(promoted.replacedPreviewTabId).toBeNull();
  });

  test('records recently closed tabs once per tab and bounds history', () => {
    const entries = recordRecentlyClosedTab(
      recordRecentlyClosedTab([], { paneId: 'pane-a', tabId: 'a' }),
      { paneId: 'pane-b', tabId: 'a' },
      2,
    );

    expect(entries).toEqual([{ paneId: 'pane-b', tabId: 'a' }]);
    expect(recordRecentlyClosedTab(entries, { paneId: 'pane-a', tabId: 'b' }, 1)).toEqual([
      { paneId: 'pane-a', tabId: 'b' },
    ]);
  });

  test('accepts 25 persisted panes without applying an editor-count cap', () => {
    const restored = parsePersistedEditorWorkspace({
      panes: Array.from({ length: 25 }, (_, index) => ({
        id: `pane-${index}`,
        openTabs: [`doc-${index}`],
        pinnedTabIds: [],
        activeTabId: `doc-${index}`,
        size: 1,
      })),
      focusedPaneId: 'pane-24',
    });

    expect(restored.panes).toHaveLength(25);
    expect(restored.focusedPaneId).toBe('pane-24');
    expect(restored.panes.reduce((sum, item) => sum + item.size, 0)).toBeCloseTo(100);
    expect(
      persistEditorWorkspace({
        ...restored,
        panes: restored.panes.map((item) => ({
          ...item,
          previewTabId: null,
          newTabIds: [],
          activeNewTabId: null,
          activeTarget: null,
        })),
      }),
    ).toEqual(restored);
  });

  test('does not focus an unknown pane', () => {
    const workspace = createEmptyEditorWorkspace(() => 'pane-a');
    expect(focusEditorPane(workspace, 'missing')).toBe(workspace);
  });

  test('clears previewTabId when the preview tab is renamed to a different id', () => {
    const workspace: EditorWorkspaceState = {
      panes: [
        {
          ...pane('pane-a', ['preview', 'other'], 'preview'),
          previewTabId: 'preview',
        },
      ],
      focusedPaneId: 'pane-a',
    };
    const remapped = remapWorkspaceTabs(workspace, (tabId) =>
      tabId === 'preview' ? 'renamed-preview' : tabId,
    );
    expect(remapped.panes[0]?.previewTabId).toBeNull();
    expect(remapped.panes[0]?.openTabs).toContain('renamed-preview');
  });

  test('resize-panes returns unchanged workspace on mismatched count or invalid sizes', () => {
    const workspace: EditorWorkspaceState = {
      panes: [pane('pane-a', ['a'], 'a', 50), pane('pane-b', ['b'], 'b', 50)],
      focusedPaneId: 'pane-a',
    };

    const mismatch = transitionEditorWorkspace(workspace, {
      type: 'resize-panes',
      sizes: [100],
    });
    expect(mismatch.workspace).toBe(workspace);

    const nanSizes = transitionEditorWorkspace(workspace, {
      type: 'resize-panes',
      sizes: [NaN, 50],
    });
    expect(nanSizes.workspace).toBe(workspace);

    const zeroSize = transitionEditorWorkspace(workspace, {
      type: 'resize-panes',
      sizes: [0, 50],
    });
    expect(zeroSize.workspace).toBe(workspace);
  });
});