Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

49.9 KB
Raw Blame
import { getParseHealth, resetParseHealth } from '@inkeep/open-knowledge-core';
import { act, cleanup, render, screen, waitFor, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import type { ComponentProps, ReactNode } from 'react';
import { afterEach, describe, expect, test, vi } from 'vitest';
import { APP_HEADER_HEIGHT, AppHeader } from '@/components/AppHeader';
import { TooltipProvider } from '@/components/ui/tooltip';
import type { GitSyncStatus } from '@/hooks/use-git-sync-status';
import { ConfigContext } from '@/lib/config-context';
import {
  __resetPaneVisibilityStoreForTests,
  type PaneVisibility,
  paneVisibilityStore,
} from '@/lib/pane-visibility-store';
import {
  configContextWithTerminal,
  type ProjectTerminalSetting,
  TERMINAL_SETTING_UNSET,
} from '@/test-utils/config-context';
import {
  expectVisualClassTokens,
  expectVisualClassTokensAbsent,
} from '@/test-utils/visual-contract';

const searchRender = vi.hoisted(() => ({ throws: false }));
const shell = vi.hoisted(() => ({
  singleFile: false,
  activeDocName: 'docs/notes' as string | null,
  activeTarget: { kind: 'doc' } as unknown,
  syncStatus: null as Partial<GitSyncStatus> | null,
  syncToastHosts: 0,
}));

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

vi.mock('@/editor/DocumentContext', () => ({
  useDocumentContext: () => ({
    activeDocName: shell.activeDocName,
    activeTarget: shell.activeTarget,
    activeProvider: null,
  }),
}));

vi.mock('@/hooks/use-git-sync-status', () => ({
  useGitSyncStatusDetailed: () => ({ status: shell.syncStatus, fetchError: null }),
  useGitSyncStatus: () => shell.syncStatus,
}));

vi.mock('@/presence/use-sync-toasts', async () => {
  const { useEffect } = await vi.importActual<typeof import('react')>('react');
  return {
    useSyncToasts: () => {
      useEffect(() => {
        shell.syncToastHosts += 1;
        return () => {
          shell.syncToastHosts -= 1;
        };
      }, []);
    },
  };
});

vi.mock('@/presence/PresenceBar', () => ({
  PresenceBar: () => <div data-testid="presence-bar" />,
}));

vi.mock('@/components/SyncStatusBadge', async () => ({
  ...(await vi.importActual<typeof import('@/components/SyncStatusBadge')>(
    '@/components/SyncStatusBadge',
  )),
  SyncStatusBadge: () => <div data-testid="sync-status-badge" />,
}));

vi.mock('@/components/HelpPopover', () => ({
  HelpPopover: () => <button type="button">Resources</button>,
}));

vi.mock('@/components/PublishToGitHubDialog', () => ({
  PublishToGitHubDialog: ({ open }: { open: boolean }) => (
    <div data-testid="publish-dialog" data-open={String(open)} />
  ),
}));

vi.mock('@/components/HeaderSearchBar', async () => {
  const actual = await vi.importActual<typeof import('@/components/HeaderSearchBar')>(
    '@/components/HeaderSearchBar',
  );
  return {
    ...actual,
    HeaderSearchBar: (props: ComponentProps<typeof actual.HeaderSearchBar>) => {
      if (searchRender.throws) throw new Error('search button render failed');
      return <actual.HeaderSearchBar {...props} />;
    },
  };
});

interface DesktopHostOptions {
  platform?: string;
  channel?: 'latest' | 'beta';
  instanceLabel?: string;
  menu?: { dispatch: (request: { kind: string }) => Promise<unknown> };
}

function setElectronHost(
  enabled: boolean,
  { platform, channel = 'latest', instanceLabel, menu }: DesktopHostOptions = {},
) {
  Object.defineProperty(window, 'okDesktop', {
    configurable: true,
    value: enabled
      ? {
          platform,
          instanceLabel,
          menu,
          config: {
            mode: 'editor',
            projectName: 'Field Notes',
            projectPath: '/projects/field-notes',
          },
          state: { query: () => Promise.resolve({ channel }) },
          project: { listRecent: () => Promise.resolve([]) },
          worktree: { list: () => Promise.resolve({ ok: false, reason: 'no-git' }) },
        }
      : undefined,
  });
}

const onOpenSearch = vi.fn(() => {});

let projectTerminal: ProjectTerminalSetting = TERMINAL_SETTING_UNSET;

function HeaderProviders({ children }: { children: ReactNode }) {
  return (
    <ConfigContext value={configContextWithTerminal(projectTerminal)}>
      <TooltipProvider>{children}</TooltipProvider>
    </ConfigContext>
  );
}

function renderHeader() {
  return render(<AppHeader onOpenSearch={onOpenSearch} />, { wrapper: HeaderProviders });
}

function centreGroup(): HTMLElement {
  return screen.getByRole('banner').querySelector('[data-app-header-center]') as HTMLElement;
}

function leadingGroup(): HTMLElement {
  return screen.getByRole('banner').querySelector('[data-app-header-leading]') as HTMLElement;
}

function trailingGroup(): HTMLElement {
  return screen.getByRole('banner').querySelector('[data-app-header-trailing]') as HTMLElement;
}

interface HeaderMetrics {
  header: number;
  leading: number;
  compactBadgeLeading?: number;
  badgeLabel?: number;
  badges?: { beta?: number; instance?: number };
  trailing: number;
  collapsedTrailing?: number;
  paneButton?: number;
  switcher?: number;
  switcherName?: number;
}

function mockHeaderMetrics(source: HeaderMetrics | (() => HeaderMetrics)) {
  const read = typeof source === 'function' ? source : () => source;
  const scrollWidth = vi
    .spyOn(Element.prototype, 'scrollWidth', 'get')
    .mockImplementation(function (this: Element) {
      const metrics = read();
      return this.hasAttribute('data-instance-badge-label') ? (metrics.badgeLabel ?? 0) : 0;
    });
  const offsetWidth = vi
    .spyOn(HTMLElement.prototype, 'offsetWidth', 'get')
    .mockImplementation(function (this: HTMLElement) {
      const metrics = read();
      if (this.hasAttribute('data-app-header')) return metrics.header;
      if (this.hasAttribute('data-app-header-leading')) {
        const badgeCompact = this.querySelector('[data-instance-badge-label].sr-only') !== null;
        const width =
          badgeCompact && metrics.compactBadgeLeading !== undefined
            ? metrics.compactBadgeLeading
            : metrics.leading;
        let foldedAway = 0;
        if (this.querySelector('[data-testid="beta-badge"]') === null) {
          foldedAway += metrics.badges?.beta ?? 0;
        }
        if (this.querySelector('[data-testid="instance-badge"]') === null) {
          foldedAway += metrics.badges?.instance ?? 0;
        }
        return width - foldedAway;
      }
      if (this.hasAttribute('data-app-header-badges')) {
        let width = 0;
        if (this.querySelector('[data-testid="beta-badge"]') !== null) {
          width += metrics.badges?.beta ?? 0;
        }
        if (this.querySelector('[data-testid="instance-badge"]') !== null) {
          const compact = this.querySelector('[data-instance-badge-label].sr-only') !== null;
          width += (metrics.badges?.instance ?? 0) - (compact ? (metrics.badgeLabel ?? 0) : 0);
        }
        return width;
      }
      if (this.hasAttribute('data-app-header-trailing')) {
        const collapsed =
          this.querySelector('[data-testid="header-overflow-actions-trigger"]') !== null;
        const paneRow =
          this.querySelectorAll('[data-testid^="header-pane-button-"]').length *
          (metrics.paneButton ?? 0);
        return (
          (collapsed && metrics.collapsedTrailing !== undefined
            ? metrics.collapsedTrailing
            : metrics.trailing) + paneRow
        );
      }
      if (this.getAttribute('data-testid') === 'project-switcher-trigger') {
        return metrics.switcher ?? 0;
      }
      if (this.getAttribute('data-testid') === 'project-switcher-name') {
        return metrics.switcherName ?? 0;
      }
      return 0;
    });
  return () => {
    offsetWidth.mockRestore();
    scrollWidth.mockRestore();
  };
}

function captureResizeObserver() {
  const observers: Array<{ callback: ResizeObserverCallback; targets: Set<Element> }> = [];
  const original = globalThis.ResizeObserver;
  class CapturingResizeObserver {
    private readonly entry: { callback: ResizeObserverCallback; targets: Set<Element> };
    constructor(callback: ResizeObserverCallback) {
      this.entry = { callback, targets: new Set<Element>() };
      observers.push(this.entry);
    }
    observe(target: Element) {
      this.entry.targets.add(target);
    }
    unobserve(target: Element) {
      this.entry.targets.delete(target);
    }
    disconnect() {
      this.entry.targets.clear();
    }
  }
  globalThis.ResizeObserver = CapturingResizeObserver as unknown as typeof ResizeObserver;
  return {
    flush(target?: Element) {
      for (const { callback, targets } of observers) {
        if (target !== undefined && !targets.has(target)) continue;
        act(() => {
          callback([], {} as ResizeObserver);
        });
      }
    },
    restore() {
      globalThis.ResizeObserver = original;
    },
  };
}

function overflowTrigger(): HTMLElement | null {
  return screen.queryByTestId('header-overflow-actions-trigger');
}

async function openOverflowPanel(): Promise<HTMLElement> {
  await userEvent.click(screen.getByTestId('header-overflow-actions-trigger'));
  return await waitFor(() => {
    const panel = document.querySelector('[data-header-overflow-actions]');
    expect(panel, 'the overflow trigger must open a panel').not.toBeNull();
    return panel as HTMLElement;
  });
}

const TRAILING_ACTION_QUERIES = [
  () => screen.queryByTestId('presence-bar'),
  () => screen.queryByRole('button', { name: /^Share / }),
  () => screen.queryByTestId('sync-status-badge'),
  () => screen.queryByRole('button', { name: 'Settings' }),
  () => screen.queryByRole('button', { name: 'Resources' }),
] as const;

const FOLDING_BADGES = '[data-testid="beta-badge"], [data-testid="instance-badge"]';

const PANE_HIDDEN: PaneVisibility = { open: false, onScreen: false };

function publishPanes({ terminal = true }: { terminal?: boolean } = {}) {
  act(() => {
    paneVisibilityStore.publish({
      editor: null,
      agents: PANE_HIDDEN,
      terminal: terminal ? PANE_HIDDEN : null,
    });
  });
}

function paneControls(): HTMLElement[] {
  return [
    screen.getByTestId('header-pane-divider'),
    screen.getByRole('button', { name: 'Agents' }),
    screen.getByRole('button', { name: 'Terminal' }),
  ];
}

const CRAMPED: HeaderMetrics = { header: 600, leading: 220, trailing: 420, collapsedTrailing: 44 };
const ROOMY: HeaderMetrics = { header: 1_280, leading: 220, trailing: 420 };
const BADGES_FOLD: HeaderMetrics = {
  header: 600,
  leading: 300,
  compactBadgeLeading: 200,
  badgeLabel: 100,
  badges: { beta: 40, instance: 150 },
  trailing: 480,
  collapsedTrailing: 44,
};
const BADGE_CRAMPED: HeaderMetrics = {
  header: 700,
  leading: 300,
  compactBadgeLeading: 200,
  badgeLabel: 100,
  trailing: 420,
};

function follows(earlier: Element, later: Element): boolean {
  return (earlier.compareDocumentPosition(later) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
}

afterEach(() => {
  cleanup();
  setElectronHost(false);
  onOpenSearch.mockClear();
  searchRender.throws = false;
  shell.activeDocName = 'docs/notes';
  shell.activeTarget = { kind: 'doc' };
  shell.syncStatus = null;
  shell.syncToastHosts = 0;
  shell.singleFile = false;
  __resetPaneVisibilityStoreForTests();
  projectTerminal = TERMINAL_SETTING_UNSET;
  vi.unstubAllGlobals();
});

describe('AppHeader', () => {
  test('a single-file window keeps global actions and the component selector above its cards', async () => {
    shell.singleFile = true;
    setElectronHost(true, { platform: 'win32', menu: { dispatch: async () => null } });
    act(() => {
      paneVisibilityStore.publish({
        editor: { open: true, onScreen: true },
        agents: PANE_HIDDEN,
        terminal: PANE_HIDDEN,
      });
    });
    renderHeader();

    expect(screen.getByRole('banner', { name: 'Application' })).toBeTruthy();
    expect(screen.getByTestId('presence-bar')).toBeTruthy();
    expect(screen.getByTestId('sync-status-badge')).toBeTruthy();
    expect(screen.getByRole('button', { name: 'Resources' })).toBeTruthy();
    expect(await screen.findByTestId('app-menubar')).toBeTruthy();
    expect(screen.getByRole('group', { name: 'Panels' })).toBeTruthy();
    expect(screen.getByRole('button', { name: 'Editor' })).toBeTruthy();
    expect(screen.getByRole('button', { name: 'Agents' })).toBeTruthy();
    expect(screen.getByRole('button', { name: 'Terminal' })).toBeTruthy();
    expect(screen.queryByTestId('project-switcher-trigger')).toBeNull();
    expect(screen.queryByRole('button', { name: /^Search/ })).toBeNull();
    expect(screen.queryByRole('button', { name: /^Share/ })).toBeNull();
    expect(screen.queryByRole('button', { name: 'Settings' })).toBeNull();
    expect(screen.queryByTestId('publish-dialog')).toBeNull();
    expect(screen.queryByTestId('navigation-history-controls')).toBeNull();
  });

  test('a narrow single-file header folds secondary actions while keeping the selector visible', async () => {
    shell.singleFile = true;
    setElectronHost(true, { platform: 'win32' });
    publishPanes();
    const restoreMetrics = mockHeaderMetrics(CRAMPED);
    try {
      renderHeader();
      const trailing = trailingGroup();
      const trigger = screen.getByTestId('header-overflow-actions-trigger');
      const selector = screen.getByRole('group', { name: 'Panels' });
      expect(trailing.contains(selector)).toBe(true);
      expect(follows(trigger, selector)).toBe(true);
      const panel = await openOverflowPanel();
      expect(panel.contains(screen.getByRole('button', { name: 'Resources' }))).toBe(true);
      expect(panel.querySelector('[data-testid="presence-bar"]')).not.toBeNull();
      expect(panel.querySelector('[data-testid="sync-status-badge"]')).not.toBeNull();
      expect(panel.contains(selector)).toBe(false);
    } finally {
      restoreMetrics();
    }
  });

  test('exposes a single banner landmark with an accessible name', () => {
    renderHeader();

    const banners = screen.getAllByRole('banner');
    expect(banners).toHaveLength(1);
    expect(screen.getByRole('banner', { name: 'Application' })).toBe(banners[0]);
  });

  test('lays out a leading, centre and trailing group in reading order', () => {
    renderHeader();

    const header = screen.getByRole('banner');
    const groups = Array.from(header.children).map((child) =>
      child.getAttributeNames().find((name) => name.startsWith('data-app-header-')),
    );

    expect(groups).toEqual([
      'data-app-header-leading',
      'data-app-header-center',
      'data-app-header-trailing',
    ]);
  });

  test('takes its height from the app-header height property the shell publishes', () => {
    renderHeader();

    expectVisualClassTokens(screen.getByRole('banner').className, [
      `h-[var(--ok-app-header-height,${APP_HEADER_HEIGHT})]`,
    ]);
  });

  test('paints the shell chrome surface with no rule under it', () => {
    renderHeader();

    const header = screen.getByRole('banner');
    expectVisualClassTokens(header.className, ['bg-desk']);
    expectVisualClassTokensAbsent(header.className, [
      'bg-background',
      'shadow-[inset_0_-1px_0_var(--border)]',
    ]);
  });

  test('reserves the macOS window buttons plus a 10px gap at its leading edge', () => {
    renderHeader();

    expectVisualClassTokens(leadingGroup().className, [
      'ps-[calc(var(--ok-titlebar-reserve-left,0px)+0.625rem)]',
    ]);
  });

  test('is a window-drag region on Electron and opts its controls out of dragging', () => {
    setElectronHost(true);
    renderHeader();

    const header = screen.getByRole('banner');
    expect(header.getAttribute('data-electron-drag')).toBe('');
    expectVisualClassTokens(header.className, [
      '[-webkit-app-region:drag]',
      '[&_button]:[-webkit-app-region:no-drag]',
      '[&_a]:[-webkit-app-region:no-drag]',
    ]);
  });

  test('on Electron the pane buttons opt out of dragging and the divider beside them stays draggable', () => {
    setElectronHost(true);
    publishPanes();
    renderHeader();

    const header = screen.getByRole('banner');
    for (const name of ['Agents', 'Terminal']) {
      const button = screen.getByRole('button', { name });
      expect(header.contains(button)).toBe(true);
      expect(button.tagName, `${name} must be a <button> for the header's no-drag rule`).toBe(
        'BUTTON',
      );
    }
    const divider = screen.getByTestId('header-pane-divider');
    expect(header.contains(divider)).toBe(true);
    for (
      let node: HTMLElement | null = divider;
      node && node !== header;
      node = node.parentElement
    ) {
      expect(['BUTTON', 'A']).not.toContain(node.tagName);
      expectVisualClassTokensAbsent(node.className, ['[-webkit-app-region:no-drag]']);
    }
  });

  test('reserves the Windows caption-button inset at its trailing edge on Electron', () => {
    setElectronHost(true, { platform: 'win32' });
    renderHeader();

    const trailing = screen.getByRole('banner').querySelector('[data-app-header-trailing]');
    expectVisualClassTokens(trailing?.className, ['me-[var(--ok-titlebar-reserve-right,0px)]']);
  });

  test('claims no drag region on a web host', () => {
    renderHeader();

    const header = screen.getByRole('banner');
    expect(header.getAttribute('data-electron-drag')).toBeNull();
    expectVisualClassTokensAbsent(header.className, ['[-webkit-app-region:drag]']);
    expectVisualClassTokensAbsent(header.querySelector('[data-app-header-trailing]')?.className, [
      'me-[var(--ok-titlebar-reserve-right,0px)]',
    ]);
  });

  describe('leading group', () => {
    test('puts back, forward and search in the leading group, in that order, on desktop', () => {
      setElectronHost(true);
      renderHeader();

      const leading = leadingGroup();
      const back = screen.getByRole('button', { name: 'Back' });
      const forward = screen.getByRole('button', { name: 'Forward' });
      const search = screen.getByRole('button', { name: 'Search' });

      expect(leading.contains(back)).toBe(true);
      expect(leading.contains(forward)).toBe(true);
      expect(leading.contains(search)).toBe(true);
      expect(follows(back, forward)).toBe(true);
      expect(follows(forward, search)).toBe(true);
    });

    test('a web host gets search alone, with no navigation history', () => {
      renderHeader();

      expect(leadingGroup().contains(screen.getByRole('button', { name: 'Search' }))).toBe(true);
      expect(screen.queryByRole('button', { name: 'Back' })).toBeNull();
      expect(screen.queryByRole('button', { name: 'Forward' })).toBeNull();
    });

    test('search opens the command palette and keeps its shortcut hint', async () => {
      const user = userEvent.setup();
      renderHeader();

      const search = screen.getByRole('button', { name: 'Search' });
      await user.hover(search);
      const tooltip = await screen.findByRole('tooltip');
      expect(tooltip.querySelector('[data-slot="kbd"]')).not.toBeNull();

      await user.click(search);
      expect(onOpenSearch).toHaveBeenCalledTimes(1);
    });

    test.each([
      { channel: 'latest', instanceLabel: undefined, expected: [] },
      { channel: 'beta', instanceLabel: undefined, expected: ['beta-badge'] },
      { channel: 'latest', instanceLabel: 'wt-header', expected: ['instance-badge'] },
      { channel: 'beta', instanceLabel: 'wt-header', expected: ['beta-badge', 'instance-badge'] },
    ] as const)(
      'channel $channel with instance label $instanceLabel shows $expected after search',
      async ({ channel, instanceLabel, expected }) => {
        setElectronHost(true, { channel, instanceLabel });
        renderHeader();

        const search = screen.getByRole('button', { name: 'Search' });
        const searchSlot = Array.from(leadingGroup().children).find((child) =>
          child.contains(search),
        ) as Element;
        await waitFor(() => {
          const badges = Array.from(leadingGroup().querySelectorAll('[data-testid$="-badge"]'));
          expect(badges.map((badge) => badge.getAttribute('data-testid'))).toEqual(expected);
        });
        const badgeGroup = searchSlot.nextElementSibling;
        expect(badgeGroup, 'the badge group must follow search').not.toBeNull();
        expect(badgeGroup?.nextElementSibling ?? null).toBeNull();
        expect(
          Array.from(badgeGroup?.children ?? []).map((badge) => badge.getAttribute('data-testid')),
        ).toEqual(expected);
      },
    );

    test('on Windows the app menu leads the header, before search and the badges, and opens from it', async () => {
      const user = userEvent.setup();
      const dispatch = vi.fn((request: { kind: string }) =>
        Promise.resolve(request.kind === 'query' ? null : undefined),
      );
      setElectronHost(true, {
        platform: 'win32',
        channel: 'beta',
        instanceLabel: 'wt-header',
        menu: { dispatch },
      });
      renderHeader();

      const menubar = await screen.findByTestId('app-menubar');
      expect(leadingGroup().firstElementChild).toBe(menubar);
      expect(follows(menubar, screen.getByRole('button', { name: 'Search' }))).toBe(true);
      expect(follows(menubar, await screen.findByTestId('beta-badge'))).toBe(true);
      expect(follows(menubar, screen.getByTestId('instance-badge'))).toBe(true);

      await user.click(screen.getByRole('menuitem', { name: 'File' }));
      expect(await screen.findByRole('menuitem', { name: /^New file/ })).toBeTruthy();
      expect(dispatch).toHaveBeenCalledWith({ kind: 'query' });
    });

    test('macOS leaves the app menu to the native menu bar', async () => {
      setElectronHost(true, {
        platform: 'darwin',
        menu: { dispatch: () => Promise.resolve(null) },
      });
      renderHeader();

      await screen.findByRole('button', { name: 'Search' });
      expect(screen.queryByTestId('app-menubar')).toBeNull();
    });

    test('a search button render failure is counted and leaves the rest of the header standing', () => {
      resetParseHealth();
      const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
      const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
      searchRender.throws = true;
      setElectronHost(true);
      try {
        renderHeader();

        expect(screen.queryByRole('button', { name: 'Search' })).toBeNull();
        expect(screen.getByRole('button', { name: 'Back' })).toBeTruthy();
        expect(screen.getByRole('banner', { name: 'Application' })).toBeTruthy();
        expect(getParseHealth().jsxRenderFailure.headerSearchPill).toBe(1);
      } finally {
        consoleError.mockRestore();
        consoleWarn.mockRestore();
      }
    });

    test('the search button comes back once the open document changes', () => {
      resetParseHealth();
      const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
      const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
      searchRender.throws = true;
      setElectronHost(true);
      try {
        const rendered = renderHeader();
        expect(screen.queryByRole('button', { name: 'Search' })).toBeNull();

        searchRender.throws = false;
        shell.activeDocName = 'docs/other';
        rendered.rerender(<AppHeader onOpenSearch={onOpenSearch} />);

        expect(
          screen.queryByRole('button', { name: 'Search' }),
          'one render failure removed the search button for the life of the window',
        ).not.toBeNull();
      } finally {
        consoleError.mockRestore();
        consoleWarn.mockRestore();
      }
    });
  });

  describe('centre track', () => {
    test('holds the project switcher, named for the open project, on desktop', () => {
      setElectronHost(true);
      renderHeader();

      const trigger = screen.getByRole('button', { name: 'Open project menu' });
      expect(centreGroup().contains(trigger)).toBe(true);
      expect(trigger.textContent).toContain('Field Notes');
    });

    test('stays empty on a web host', () => {
      renderHeader();

      expect(centreGroup().children).toHaveLength(0);
      expect(screen.queryByRole('button', { name: 'Open project menu' })).toBeNull();
    });
  });

  describe('trailing group', () => {
    test('holds presence, Share, sync, settings and resources, then a divider and the Agents and Terminal buttons, in that order', () => {
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      publishPanes();
      renderHeader();

      const controls = [...TRAILING_ACTION_QUERIES.map((query) => query()), ...paneControls()];
      for (const control of controls) {
        expect(control).not.toBeNull();
        expect(trailingGroup().contains(control)).toBe(true);
      }
      for (let index = 1; index < controls.length; index += 1) {
        expect(follows(controls[index - 1] as Element, controls[index] as Element)).toBe(true);
      }
    });

    test('Share opens the publish dialog from the header when the project has no remote', async () => {
      const user = userEvent.setup();
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: false };
      renderHeader();

      expect(screen.getByTestId('publish-dialog').getAttribute('data-open')).toBe('false');
      await user.click(screen.getByRole('button', { name: 'Share doc' }));

      expect(screen.getByTestId('publish-dialog').getAttribute('data-open')).toBe('true');
      expect(trailingGroup().contains(screen.getByTestId('publish-dialog'))).toBe(true);
    });

    test.each([
      {
        target: 'an open doc',
        activeDocName: 'docs/notes',
        activeTarget: { kind: 'doc' },
        button: 'Share doc',
        request: { kind: 'doc', docPath: 'docs/notes.md' },
      },
      {
        target: 'a selected folder',
        activeDocName: null,
        activeTarget: { kind: 'folder', folderPath: 'guides' },
        button: 'Share folder',
        request: { kind: 'folder', folderPath: 'guides' },
      },
      {
        target: 'nothing open or selected',
        activeDocName: null,
        activeTarget: null,
        button: 'Share folder',
        request: { kind: 'folder', folderPath: '' },
      },
    ])(
      'Share asks for a link to $target',
      async ({ activeDocName, activeTarget, button, request }) => {
        const user = userEvent.setup();
        const requests: unknown[] = [];
        vi.stubGlobal(
          'fetch',
          vi.fn(async (_url: string, init?: RequestInit) => {
            requests.push(JSON.parse(String(init?.body)));
            return new Response('unavailable', { status: 503 });
          }),
        );
        shell.activeDocName = activeDocName;
        shell.activeTarget = activeTarget;
        shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
        renderHeader();

        await user.click(screen.getByRole('button', { name: button }));

        await waitFor(() => expect(requests).toEqual([request]));
      },
    );

    test.each([
      {
        target: 'a skill or template',
        activeDocName: '__skill__/project/my-skill',
        activeTarget: { kind: 'doc' },
      },
      {
        target: 'an asset',
        activeDocName: null,
        activeTarget: { kind: 'asset', assetPath: 'img/logo.png' },
      },
    ])('Share stays disabled for $target', ({ activeDocName, activeTarget }) => {
      shell.activeDocName = activeDocName;
      shell.activeTarget = activeTarget;
      renderHeader();

      const share = within(trailingGroup()).getByRole('button', { name: /^Share / });
      expect((share as HTMLButtonElement).disabled).toBe(true);
    });

    test('mounts the sync-toast machine exactly once, outside the collapsible group', () => {
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        expect(overflowTrigger()).not.toBeNull();
        expect(screen.queryByTestId('presence-bar')).toBeNull();
        expect(shell.syncToastHosts).toBe(1);
      } finally {
        restoreMetrics();
      }
    });
  });

  describe('collapse', () => {
    test('when the trailing group does not fit, its five controls go behind "More actions" and the leading group keeps everything but the BETA and instance badges', async () => {
      setElectronHost(true, {
        platform: 'win32',
        channel: 'beta',
        instanceLabel: 'wt-header',
        menu: { dispatch: () => Promise.resolve(null) },
      });
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        const trigger = overflowTrigger();
        expect(trigger).not.toBeNull();
        expect(trailingGroup().contains(trigger)).toBe(true);
        for (const query of TRAILING_ACTION_QUERIES) expect(query()).toBeNull();
        const staying = [
          await screen.findByTestId('app-menubar'),
          ...['Back', 'Forward', 'Search'].map((name) => screen.getByRole('button', { name })),
        ];
        for (const control of staying) expect(leadingGroup().contains(control)).toBe(true);

        const panel = await openOverflowPanel();
        for (const query of TRAILING_ACTION_QUERIES) {
          expect(panel.contains(query())).toBe(true);
        }
        expect(panel.contains(await screen.findByTestId('beta-badge'))).toBe(true);
        expect(panel.contains(screen.getByTestId('instance-badge'))).toBe(true);
        for (const control of staying) {
          expect(panel.contains(control)).toBe(false);
          expect(leadingGroup().contains(control)).toBe(true);
        }
      } finally {
        restoreMetrics();
      }
    });

    test('the panel behind "More actions" is a dialog announced by that name, even while sync needs attention', async () => {
      shell.syncStatus = { state: 'conflict', conflictCount: 1, hasRemote: true };
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        const panel = await openOverflowPanel();
        expect(screen.getByRole('dialog', { name: 'More actions' })).toBe(panel);
      } finally {
        restoreMetrics();
      }
    });

    test('when folded, the divider and the pane buttons stay in the header after "More actions" and out of its panel, and keep their place when room returns', async () => {
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      publishPanes();
      const observer = captureResizeObserver();
      let restoreMetrics = mockHeaderMetrics({ ...CRAMPED, paneButton: 28 });
      try {
        renderHeader();

        const trigger = overflowTrigger() as HTMLElement;
        expect(trigger).not.toBeNull();
        for (const control of paneControls()) {
          expect(trailingGroup().contains(control)).toBe(true);
          expect(follows(trigger, control)).toBe(true);
        }
        const panel = await openOverflowPanel();
        for (const query of TRAILING_ACTION_QUERIES) {
          expect(panel.contains(query())).toBe(true);
        }
        for (const control of paneControls()) {
          expect(panel.contains(control)).toBe(false);
        }

        restoreMetrics();
        restoreMetrics = mockHeaderMetrics({ ...ROOMY, paneButton: 28 });
        observer.flush();

        expect(overflowTrigger()).toBeNull();
        const controls = [...TRAILING_ACTION_QUERIES.map((query) => query()), ...paneControls()];
        for (const control of controls) {
          expect(trailingGroup().contains(control)).toBe(true);
        }
        for (let index = 1; index < controls.length; index += 1) {
          expect(follows(controls[index - 1] as Element, controls[index] as Element)).toBe(true);
        }
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test.each(['win32', 'linux'] as const)(
      'on %s a folded header moves the BETA and instance badges into "More actions", and they return to the leading group when room returns',
      async (platform) => {
        setElectronHost(true, { platform, channel: 'beta', instanceLabel: 'wt-header' });
        const observer = captureResizeObserver();
        let restoreMetrics = mockHeaderMetrics(BADGES_FOLD);
        try {
          renderHeader();

          expect(overflowTrigger()).not.toBeNull();
          expect(leadingGroup().querySelector(FOLDING_BADGES)).toBeNull();
          const panel = await openOverflowPanel();
          expect(panel.contains(await screen.findByTestId('beta-badge'))).toBe(true);
          const folded = screen.getByTestId('instance-badge');
          expect(panel.contains(folded)).toBe(true);
          expectVisualClassTokensAbsent(
            folded.querySelector('[data-instance-badge-label]')?.className,
            ['sr-only'],
          );

          restoreMetrics();
          restoreMetrics = mockHeaderMetrics({ ...BADGES_FOLD, header: 1_280 });
          observer.flush();

          expect(overflowTrigger()).toBeNull();
          const beta = await screen.findByTestId('beta-badge');
          const instance = screen.getByTestId('instance-badge');
          expect(leadingGroup().contains(beta)).toBe(true);
          expect(leadingGroup().contains(instance)).toBe(true);
          expect(follows(screen.getByRole('button', { name: 'Search' }), beta)).toBe(true);
          expect(follows(beta, instance)).toBe(true);
        } finally {
          restoreMetrics();
          observer.restore();
        }
      },
    );

    test('on macOS a folded header keeps the BETA and instance badges in the leading group', async () => {
      setElectronHost(true, { platform: 'darwin', channel: 'beta', instanceLabel: 'wt-header' });
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        expect(overflowTrigger()).not.toBeNull();
        const beta = await screen.findByTestId('beta-badge');
        expect(leadingGroup().contains(beta)).toBe(true);
        expect(leadingGroup().contains(screen.getByTestId('instance-badge'))).toBe(true);
        const panel = await openOverflowPanel();
        expect(panel.querySelector(FOLDING_BADGES)).toBeNull();
      } finally {
        restoreMetrics();
      }
    });

    test('on macOS a folded single-file header moves the BETA and instance badges into its overflow', async () => {
      shell.singleFile = true;
      setElectronHost(true, { platform: 'darwin', channel: 'beta', instanceLabel: 'wt-header' });
      publishPanes();
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        expect(overflowTrigger()).not.toBeNull();
        const panel = await openOverflowPanel();
        expect(panel.contains(await screen.findByTestId('beta-badge'))).toBe(true);
        expect(panel.contains(screen.getByTestId('instance-badge'))).toBe(true);
        expect(leadingGroup().querySelector(FOLDING_BADGES)).toBeNull();
      } finally {
        restoreMetrics();
      }
    });

    test.each([
      { path: 'straight from a roomy header', widths: [600] },
      { path: 'after the instance badge shrank to its icon', widths: [680, 600] },
    ])(
      'with the badges folded out of the leading group $path, the fold holds though the leading group got narrower',
      async ({ widths }) => {
        setElectronHost(true, { platform: 'win32', channel: 'beta', instanceLabel: 'wt-header' });
        const observer = captureResizeObserver();
        let headerWidth = 1_280;
        const restoreMetrics = mockHeaderMetrics(() => ({
          ...BADGES_FOLD,
          header: headerWidth,
          trailing: 420,
        }));
        try {
          renderHeader();
          await waitFor(() =>
            expect(leadingGroup().contains(screen.queryByTestId('beta-badge'))).toBe(true),
          );
          observer.flush();
          expect(overflowTrigger()).toBeNull();

          for (const width of widths) {
            headerWidth = width;
            observer.flush();
          }
          expect(overflowTrigger()).not.toBeNull();
          expect(leadingGroup().querySelector(FOLDING_BADGES)).toBeNull();

          for (const pass of [1, 2, 3]) {
            observer.flush();
            expect(
              overflowTrigger(),
              `re-measurement pass ${pass} unfolded the header because the folded badges no longer counted against the room`,
            ).not.toBeNull();
          }
        } finally {
          restoreMetrics();
          observer.restore();
        }
      },
    );

    test('when room returns the five come back out and the trigger goes', () => {
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      const observer = captureResizeObserver();
      let restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();
        expect(overflowTrigger()).not.toBeNull();

        restoreMetrics();
        restoreMetrics = mockHeaderMetrics(ROOMY);
        observer.flush();

        expect(overflowTrigger()).toBeNull();
        for (const query of TRAILING_ACTION_QUERIES) {
          expect(trailingGroup().contains(query())).toBe(true);
        }
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('keeps the trailing group inline when it fits', () => {
      const restoreMetrics = mockHeaderMetrics(ROOMY);
      try {
        renderHeader();

        expect(overflowTrigger()).toBeNull();
        expect(trailingGroup().contains(screen.getByRole('button', { name: 'Settings' }))).toBe(
          true,
        );
      } finally {
        restoreMetrics();
      }
    });

    test('never collapses while the header is unmeasured', () => {
      const restoreMetrics = mockHeaderMetrics({ ...CRAMPED, header: 0 });
      try {
        renderHeader();

        expect(overflowTrigger()).toBeNull();
      } finally {
        restoreMetrics();
      }
    });

    test('the room left for the trailing group keeps the project switcher its icons, whatever the project is called', () => {
      setElectronHost(true);
      const verdicts = [110, 400].map((switcherName) => {
        const restoreMetrics = mockHeaderMetrics({
          header: 700,
          leading: 220,
          trailing: 420,
          switcher: switcherName + 64,
          switcherName,
        });
        try {
          renderHeader();
          return overflowTrigger() !== null;
        } finally {
          restoreMetrics();
          cleanup();
        }
      });

      expect(
        verdicts,
        'reserving the switcher icons leaves 416px, too little for a 420px group',
      ).toEqual([true, true]);
    });

    test('a group that fits beside the leading group and the switcher icons stays inline', () => {
      setElectronHost(true);
      const restoreMetrics = mockHeaderMetrics({
        header: 760,
        leading: 220,
        trailing: 420,
        switcher: 464,
        switcherName: 400,
      });
      try {
        renderHeader();

        expect(overflowTrigger()).toBeNull();
      } finally {
        restoreMetrics();
      }
    });

    test('counts the Windows caption-button inset against the room', () => {
      setElectronHost(true, { platform: 'win32' });
      const realGetComputedStyle = window.getComputedStyle.bind(window);
      const computedStyle = vi
        .spyOn(window, 'getComputedStyle')
        .mockImplementation((element: Element, pseudo?: string | null) => {
          const style = realGetComputedStyle(element, pseudo);
          if (element instanceof HTMLElement && element.hasAttribute('data-app-header-trailing')) {
            return new Proxy(style, {
              get: (target, property) =>
                property === 'marginInlineEnd' ? '138px' : Reflect.get(target, property),
            }) as CSSStyleDeclaration;
          }
          return style;
        });
      const restoreMetrics = mockHeaderMetrics({ header: 760, leading: 220, trailing: 420 });
      try {
        renderHeader();

        expect(
          overflowTrigger(),
          '420px of controls plus a 138px caption-button inset does not fit in 540px',
        ).not.toBeNull();
      } finally {
        restoreMetrics();
        computedStyle.mockRestore();
      }
    });

    test('an Electron host keeps the build label hoverable inside the draggable header', () => {
      setElectronHost(true, { instanceLabel: 'wt-header' });
      renderHeader();
      const header = screen.getByRole('banner');
      const badge = screen.getByTestId('instance-badge');

      expect(header.contains(badge)).toBe(true);
      expectVisualClassTokens(header.className, ['[-webkit-app-region:drag]']);
      expectVisualClassTokens(badge.className, ['[-webkit-app-region:no-drag]']);
    });

    test('when only the instance badge does not fit, it shrinks to its icon and the trailing group stays inline', () => {
      setElectronHost(true, { instanceLabel: 'wt-header' });
      const observer = captureResizeObserver();
      const restoreMetrics = mockHeaderMetrics(BADGE_CRAMPED);
      try {
        renderHeader();
        const badge = screen.getByTestId('instance-badge');

        for (const pass of [1, 2, 3]) {
          observer.flush();
          expectVisualClassTokens(badge.querySelector('[data-instance-badge-label]')?.className, [
            'sr-only',
          ]);
          expect(
            overflowTrigger(),
            `re-measurement pass ${pass} folded the trailing group though the compact badge left room for it`,
          ).toBeNull();
        }
        expect(within(badge).getByText('App instance: wt-header').classList).toContain('sr-only');
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('the pass that shrinks the instance badge already counts the room it frees', () => {
      setElectronHost(true, { instanceLabel: 'wt-header' });
      const observer = captureResizeObserver();
      const restoreMetrics = mockHeaderMetrics(BADGE_CRAMPED);
      try {
        renderHeader();

        expectVisualClassTokens(
          screen.getByTestId('instance-badge').querySelector('[data-instance-badge-label]')
            ?.className,
          ['sr-only'],
        );
        expect(
          overflowTrigger(),
          'the first paint folded the trailing group at a width where the compact badge leaves room for it',
        ).toBeNull();
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('a centre that fills in after mount re-drives the collapse verdict', () => {
      setElectronHost(true);
      const observer = captureResizeObserver();
      let centreWidth = 0;
      const restoreMetrics = mockHeaderMetrics(() => ({
        header: 700,
        leading: 220,
        trailing: 420,
        collapsedTrailing: 44,
        switcher: centreWidth,
        switcherName: centreWidth > 0 ? 100 : 0,
      }));
      try {
        renderHeader();
        expect(overflowTrigger()).toBeNull();

        centreWidth = 300;
        observer.flush(centreGroup());

        expect(
          overflowTrigger(),
          'the centre grew after mount and nothing re-measured, so the header kept the verdict it computed for an empty centre',
        ).not.toBeNull();
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('the instance badge keeps its name while the header has room for it', () => {
      setElectronHost(true, { instanceLabel: 'wt-header' });
      const observer = captureResizeObserver();
      const restoreMetrics = mockHeaderMetrics({ ...BADGE_CRAMPED, header: 1_280 });
      try {
        renderHeader();
        observer.flush();

        expectVisualClassTokensAbsent(
          screen.getByTestId('instance-badge').querySelector('[data-instance-badge-label]')
            ?.className,
          ['sr-only'],
        );
        expect(overflowTrigger()).toBeNull();
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('a collapsed group stays collapsed when its own collapsed width is re-measured', () => {
      const observer = captureResizeObserver();
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();
        expect(overflowTrigger()).not.toBeNull();

        for (const pass of [1, 2, 3]) {
          observer.flush();
          expect(
            overflowTrigger(),
            `re-measurement pass ${pass} re-expanded the group though the room never changed`,
          ).not.toBeNull();
        }
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('re-measures the remembered width when the trailing content changes', async () => {
      const observer = captureResizeObserver();
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      let restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        const view = renderHeader();
        expect(overflowTrigger()).not.toBeNull();

        restoreMetrics();
        restoreMetrics = mockHeaderMetrics({ ...CRAMPED, trailing: 200 });
        shell.syncStatus = { state: 'offline', conflictCount: 0, hasRemote: true };
        view.rerender(<AppHeader onOpenSearch={onOpenSearch} />);

        await waitFor(() => expect(overflowTrigger()).toBeNull());
        observer.flush();
        expect(overflowTrigger()).toBeNull();
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('a pane button that goes while folded resets the remembered width, and the header unfolds and stays unfolded', () => {
      const observer = captureResizeObserver();
      publishPanes();
      const restoreMetrics = mockHeaderMetrics({
        header: 600,
        leading: 220,
        trailing: 300,
        collapsedTrailing: 44,
        paneButton: 40,
      });
      try {
        renderHeader();
        expect(
          overflowTrigger(),
          '300px of controls and two 40px pane buttons do not fit in 380px',
        ).not.toBeNull();

        publishPanes({ terminal: false });

        expect(
          overflowTrigger(),
          'the header kept the width it remembered with the Terminal button though the button is gone',
        ).toBeNull();
        for (const pass of [1, 2, 3]) {
          observer.flush();
          expect(
            overflowTrigger(),
            `re-measurement pass ${pass} folded the header again`,
          ).toBeNull();
        }
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('a pane button that appears re-measures at once, and the header folds and stays folded', () => {
      const observer = captureResizeObserver();
      publishPanes({ terminal: false });
      const restoreMetrics = mockHeaderMetrics({
        header: 600,
        leading: 220,
        trailing: 300,
        collapsedTrailing: 44,
        paneButton: 40,
      });
      try {
        renderHeader();
        expect(overflowTrigger()).toBeNull();

        publishPanes();

        expect(
          overflowTrigger(),
          'the Terminal button appeared and the header kept a verdict measured without it',
        ).not.toBeNull();
        for (const pass of [1, 2, 3]) {
          observer.flush();
          expect(
            overflowTrigger(),
            `re-measurement pass ${pass} unfolded the header though the room never changed`,
          ).not.toBeNull();
        }
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test('turning the project terminal off and on re-measures the fold each time', () => {
      const observer = captureResizeObserver();
      publishPanes();
      const restoreMetrics = mockHeaderMetrics({
        header: 600,
        leading: 220,
        trailing: 300,
        collapsedTrailing: 44,
        paneButton: 40,
      });
      try {
        const view = renderHeader();
        expect(overflowTrigger()).not.toBeNull();

        projectTerminal = { synced: true, enabled: false };
        view.rerender(<AppHeader onOpenSearch={onOpenSearch} />);

        expect(screen.queryByRole('button', { name: 'Terminal' })).toBeNull();
        expect(
          overflowTrigger(),
          'the header kept the width it remembered with the Terminal button after the terminal was turned off',
        ).toBeNull();
        observer.flush();
        expect(overflowTrigger()).toBeNull();

        projectTerminal = { synced: true, enabled: true };
        view.rerender(<AppHeader onOpenSearch={onOpenSearch} />);

        expect(screen.getByRole('button', { name: 'Terminal' })).toBeTruthy();
        expect(
          overflowTrigger(),
          'the Terminal button came back and the header kept a verdict measured without it',
        ).not.toBeNull();
        observer.flush();
        expect(overflowTrigger()).not.toBeNull();
      } finally {
        restoreMetrics();
        observer.restore();
      }
    });

    test.each([
      { status: { state: 'idle', conflictCount: 2 }, attention: 'conflict', label: 'Conflict' },
      { status: { state: 'offline', conflictCount: 0 }, attention: 'offline', label: 'Offline' },
      {
        status: { state: 'auth-error', conflictCount: 0 },
        attention: 'auth-error',
        label: 'Reconnect required',
      },
      {
        status: { state: 'disabled', conflictCount: 0, pausedReason: 'git-operation-in-progress' },
        attention: 'paused',
        label: 'Sync paused',
      },
    ] as const)(
      'a collapsed group puts the $attention sync state on the trigger',
      ({ status, attention, label }) => {
        shell.syncStatus = { ...status, hasRemote: true } as Partial<GitSyncStatus>;
        const restoreMetrics = mockHeaderMetrics(CRAMPED);
        try {
          renderHeader();

          const trigger = overflowTrigger() as HTMLElement;
          expect(trigger.getAttribute('aria-label')).toBe(`More actions (${label})`);
          expect(
            trigger
              .querySelector('[data-testid="header-overflow-actions-sync-indicator"]')
              ?.getAttribute('data-sync-attention'),
          ).toBe(attention);
        } finally {
          restoreMetrics();
        }
      },
    );

    test('a collapsed group leaves the trigger unadorned while sync is healthy', () => {
      shell.syncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };
      const restoreMetrics = mockHeaderMetrics(CRAMPED);
      try {
        renderHeader();

        const trigger = overflowTrigger() as HTMLElement;
        expect(trigger.getAttribute('aria-label')).toBe('More actions');
        expect(
          trigger.querySelector('[data-testid="header-overflow-actions-sync-indicator"]'),
        ).toBeNull();
      } finally {
        restoreMetrics();
      }
    });
  });
});