Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Restore header actions after presence expiry (#7613)

Nick Gomez6c0e76217cf7
diff --git a/.changeset/header-actions-presence-expiry.md b/.changeset/header-actions-presence-expiry.md
new file mode 100644
index 000000000..d6f386297
--- /dev/null
+++ b/.changeset/header-actions-presence-expiry.md
@@ -0,0 +1,5 @@
+---
+'@inkeep/open-knowledge': patch
+---
+
+Header actions return inline when agent presence expires and there is room, without closing an open More actions menu.
diff --git a/packages/app/src/components/AppHeader.tsx b/packages/app/src/components/AppHeader.tsx
index e081d7efb..acfcbe29f 100644
--- a/packages/app/src/components/AppHeader.tsx
+++ b/packages/app/src/components/AppHeader.tsx
@@ -1,7 +1,7 @@
import { parseManagedArtifactName } from '@inkeep/open-knowledge-core/constants/cc1';
import { APP_HEADER_HEIGHT } from '@inkeep/open-knowledge-core/constants/chrome';
import { useLingui } from '@lingui/react/macro';
-import { lazy, Suspense, useRef, useState } from 'react';
+import { lazy, Suspense, useLayoutEffect, useRef, useState } from 'react';
import { ErrorBoundary } from 'react-error-boundary';
import { shouldShowAppMenubar } from '@/components/app-menubar-gate';
import { BetaBadge } from '@/components/BetaBadge';
@@ -33,6 +33,7 @@ import { useSingleFileMode } from '@/lib/single-file-mode';
import { cn } from '@/lib/utils';
import { PresenceBar } from '@/presence/PresenceBar';
import { SyncToastHost } from '@/presence/SyncToastHost';
+import { usePresence } from '@/presence/use-presence';
const AppMenubar = lazy(() =>
import('@/components/AppMenubar').then((m) => ({ default: m.AppMenubar })),
@@ -40,6 +41,9 @@ const AppMenubar = lazy(() =>
export { APP_HEADER_HEIGHT };
+const HEADER_FOCUSABLE_SELECTOR =
+ 'button:not([disabled]), a[href], input:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
function centreNaturalWidth(centre: HTMLElement): number {
let width = 0;
for (const child of centre.children) {
@@ -106,11 +110,13 @@ interface AppHeaderProps {
export function AppHeader({ onOpenSearch }: AppHeaderProps) {
const { t } = useLingui();
const singleFile = useSingleFileMode();
- const { activeDocName, activeTarget } = useDocumentContext();
+ const { activeDocName, activeTarget, activeProvider, systemProvider } = useDocumentContext();
+ const presence = usePresence(activeProvider, systemProvider, activeDocName);
const desktopBridge = typeof window !== 'undefined' ? window.okDesktop : undefined;
const isElectronHost = desktopBridge != null;
const foldsBadges = isElectronHost && desktopBridge.platform !== 'darwin';
const [publishOpen, setPublishOpen] = useState(false);
+ const [overflowOpen, setOverflowOpen] = useState(false);
const [badgeCompact, setBadgeCompact] = useState(false);
const badgeCompactRef = useRef(false);
const leadingBadgesRef = useRef({ width: 0, labelWidth: 0, hasLabel: false });
@@ -120,6 +126,7 @@ export function AppHeader({ onOpenSearch }: AppHeaderProps) {
const [centre, setCentre] = useState<HTMLDivElement | null>(null);
const shareButtonRef = useRef<HTMLButtonElement>(null);
const overflowTriggerRef = useRef<HTMLButtonElement>(null);
+ const overflowFocusRemovedRef = useRef(false);
const shareInput: ShareTargetInput | null = singleFile
? null
@@ -137,14 +144,17 @@ export function AppHeader({ onOpenSearch }: AppHeaderProps) {
String(shareInput != null),
gitSyncStatus?.hasRemote ? displayState(gitSyncStatus) : 'no-remote',
paneButtonSet.join(','),
+ presence.current.length,
+ presence.crossDoc.length,
].join('|');
- const actionsOverflowed = useTrailingOverflow({
+ const { overflowed: actionsOverflowed, remeasuring: actionsRemeasuring } = useTrailingOverflow({
header,
leading,
trailing,
centre,
signature: trailingContentSignature,
+ deferRemeasure: overflowOpen,
slack: HEADER_OVERFLOW_SLACK_PX,
measureTrailingWidth: (elements) =>
elements.trailing.offsetWidth +
@@ -181,11 +191,33 @@ export function AppHeader({ onOpenSearch }: AppHeaderProps) {
return headerWidth - leadingSettledWidth - (centre != null ? centreFloorWidth(centre) : 0);
},
});
+ useLayoutEffect(() => {
+ if (!actionsOverflowed) setOverflowOpen(false);
+ }, [actionsOverflowed]);
+ useLayoutEffect(() => {
+ if (actionsRemeasuring || !overflowFocusRemovedRef.current || !trailing) return;
+ overflowFocusRemovedRef.current = false;
+ const ownerDocument = trailing.ownerDocument;
+ if (
+ ownerDocument.activeElement !== null &&
+ ownerDocument.activeElement !== ownerDocument.body
+ ) {
+ return;
+ }
+ if (actionsOverflowed) {
+ overflowTriggerRef.current?.focus();
+ return;
+ }
+ for (const control of trailing.querySelectorAll<HTMLElement>(HEADER_FOCUSABLE_SELECTOR)) {
+ control.focus();
+ if (ownerDocument.activeElement === control) return;
+ }
+ });
const badgesFolded = (foldsBadges || singleFile) && actionsOverflowed;
const renderTrailingActions = (onClickWhenNoRemote: ShareButtonProps['onClickWhenNoRemote']) => (
<>
- <PresenceBar />
+ <PresenceBar {...presence} />
{!singleFile && (
<ShareButton
input={shareInput}
@@ -263,18 +295,18 @@ export function AppHeader({ onOpenSearch }: AppHeaderProps) {
)}
>
{actionsOverflowed ? (
- <HeaderOverflowActions syncStatus={gitSyncStatus} triggerRef={overflowTriggerRef}>
- {(close) => (
- <>
- {badgesFolded && (
- <AppHeaderBadges compact={false} isElectronHost={isElectronHost} />
- )}
- {renderTrailingActions(() => {
- close();
- setPublishOpen(true);
- })}
- </>
- )}
+ <HeaderOverflowActions
+ syncStatus={gitSyncStatus}
+ triggerRef={overflowTriggerRef}
+ open={overflowOpen}
+ onOpenChange={setOverflowOpen}
+ unmountedWhileFocusedRef={overflowFocusRemovedRef}
+ >
+ {badgesFolded && <AppHeaderBadges compact={false} isElectronHost={isElectronHost} />}
+ {renderTrailingActions(() => {
+ setOverflowOpen(false);
+ setPublishOpen(true);
+ })}
</HeaderOverflowActions>
) : (
renderTrailingActions(() => setPublishOpen(true))
diff --git a/packages/app/src/components/HeaderOverflowActions.tsx b/packages/app/src/components/HeaderOverflowActions.tsx
index 13b427bf9..9d36110ec 100644
--- a/packages/app/src/components/HeaderOverflowActions.tsx
+++ b/packages/app/src/components/HeaderOverflowActions.tsx
@@ -1,6 +1,6 @@
import { useLingui } from '@lingui/react/macro';
import { MoreHorizontalIcon } from 'lucide-react';
-import { type ReactNode, type Ref, useState } from 'react';
+import { type ReactNode, type RefObject, useLayoutEffect } from 'react';
import { Button } from '@/components/ui/button';
import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
import type { GitSyncStatus } from '@/hooks/use-git-sync-status';
@@ -8,6 +8,7 @@ import { cn } from '@/lib/utils';
import { displayState } from './SyncStatusBadge';
export const HEADER_OVERFLOW_SLACK_PX = 8;
+const HEADER_OVERFLOW_MENU_SELECTOR = '[data-header-overflow-actions]';
type SyncAttention = 'conflict' | 'offline' | 'auth-error' | 'paused';
@@ -21,17 +22,31 @@ function syncAttentionOf(status: GitSyncStatus | null): SyncAttention | null {
interface HeaderOverflowActionsProps {
syncStatus: GitSyncStatus | null;
- children: (close: () => void) => ReactNode;
- triggerRef?: Ref<HTMLButtonElement>;
+ children: ReactNode;
+ triggerRef: RefObject<HTMLButtonElement | null>;
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ unmountedWhileFocusedRef: RefObject<boolean>;
}
export function HeaderOverflowActions({
syncStatus,
children,
triggerRef,
+ open,
+ onOpenChange,
+ unmountedWhileFocusedRef,
}: HeaderOverflowActionsProps) {
const { t } = useLingui();
- const [open, setOpen] = useState(false);
+ useLayoutEffect(() => {
+ const trigger = triggerRef.current;
+ return () => {
+ const focused = trigger?.ownerDocument.activeElement;
+ if (focused && (focused === trigger || focused.closest(HEADER_OVERFLOW_MENU_SELECTOR))) {
+ unmountedWhileFocusedRef.current = true;
+ }
+ };
+ }, [triggerRef, unmountedWhileFocusedRef]);
const syncAttention = syncAttentionOf(syncStatus);
const syncAttentionLabel =
syncAttention === 'conflict'
@@ -48,7 +63,7 @@ export function HeaderOverflowActions({
: t`More actions`;
return (
- <Popover open={open} onOpenChange={setOpen}>
+ <Popover open={open} onOpenChange={onOpenChange}>
<PopoverTrigger asChild>
<Button
ref={triggerRef}
@@ -80,7 +95,7 @@ export function HeaderOverflowActions({
data-header-overflow-actions=""
className="flex w-auto max-w-[calc(100vw-1rem)] flex-wrap items-center justify-end gap-2 p-2"
>
- {children(() => setOpen(false))}
+ {children}
</PopoverContent>
</Popover>
);
diff --git a/packages/app/src/hooks/use-trailing-overflow.ts b/packages/app/src/hooks/use-trailing-overflow.ts
index c496d16a1..6113ac480 100644
--- a/packages/app/src/hooks/use-trailing-overflow.ts
+++ b/packages/app/src/hooks/use-trailing-overflow.ts
@@ -12,6 +12,7 @@ export interface TrailingOverflowOptions {
trailing: HTMLElement | null;
centre?: HTMLElement | null;
signature: string;
+ deferRemeasure: boolean;
slack: number;
measureTrailingWidth: (elements: TrailingOverflowElements) => number;
measureAvailableWidth: (
@@ -20,58 +21,60 @@ export interface TrailingOverflowOptions {
) => number;
}
+export interface TrailingOverflow {
+ readonly overflowed: boolean;
+ readonly remeasuring: boolean;
+}
+
export function useTrailingOverflow({
header,
leading,
trailing,
centre = null,
signature,
+ deferRemeasure,
slack,
measureTrailingWidth,
measureAvailableWidth,
-}: TrailingOverflowOptions): boolean {
- const [overflowed, setOverflowed] = useState(false);
- const overflowedRef = useRef(false);
- const measuredSignatureRef = useRef<string | null>(null);
+}: TrailingOverflowOptions): TrailingOverflow {
+ const [fit, setFit] = useState({ signature, overflowed: false });
+ const remeasuring = fit.overflowed && !deferRemeasure && fit.signature !== signature;
+ const overflowed = fit.overflowed && !remeasuring;
const latchedTrailingWidthRef = useRef(0);
- const measureRef = useRef({ measureTrailingWidth, measureAvailableWidth });
-
- useLayoutEffect(() => {
- measureRef.current = { measureTrailingWidth, measureAvailableWidth };
- });
+ const updateRef = useRef(() => {});
useLayoutEffect(() => {
if (!header || !leading || !trailing) return;
- if (measuredSignatureRef.current !== signature) {
- measuredSignatureRef.current = signature;
- overflowedRef.current = false;
- latchedTrailingWidthRef.current = 0;
- }
-
- const update = () => {
+ updateRef.current = () => {
if (header.offsetWidth <= 0) return;
const elements = { header, leading, trailing };
- if (!overflowedRef.current) {
- latchedTrailingWidthRef.current = measureRef.current.measureTrailingWidth(elements);
+ if (!overflowed) {
+ latchedTrailingWidthRef.current = measureTrailingWidth(elements);
}
- const available = measureRef.current.measureAvailableWidth(
- elements,
- latchedTrailingWidthRef.current,
- );
+ const available = measureAvailableWidth(elements, latchedTrailingWidthRef.current);
const next = latchedTrailingWidthRef.current + slack > available;
- overflowedRef.current = next;
- setOverflowed(next);
+ setFit((previous) => {
+ const measuredSignature = overflowed ? previous.signature : signature;
+ return previous.overflowed === next && previous.signature === measuredSignature
+ ? previous
+ : { signature: measuredSignature, overflowed: next };
+ });
};
- update();
+ updateRef.current();
+ });
+
+ useLayoutEffect(() => {
+ if (!header || !leading || !trailing) return;
- const observer = typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(update);
+ const observer =
+ typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(() => updateRef.current());
observer?.observe(header);
observer?.observe(leading);
observer?.observe(trailing);
if (centre) observer?.observe(centre);
return () => observer?.disconnect();
- }, [header, leading, trailing, centre, signature, slack]);
+ }, [header, leading, trailing, centre]);
- return overflowed;
+ return { overflowed, remeasuring };
}
diff --git a/packages/app/src/presence/PresenceBar-avatar-click.test.tsx b/packages/app/src/presence/PresenceBar-avatar-click.test.tsx
index 498026b5d..75b30a2c9 100644
--- a/packages/app/src/presence/PresenceBar-avatar-click.test.tsx
+++ b/packages/app/src/presence/PresenceBar-avatar-click.test.tsx
@@ -4,7 +4,6 @@ import { afterEach, describe, expect, test, vi } from 'vitest';
import { TooltipProvider } from '@/components/ui/tooltip';
import * as actualDocumentContext from '@/editor/DocumentContext';
import type { AgentParticipant } from './use-presence';
-import * as actualUsePresence from './use-presence';
import * as actualUseSyncStatus from './use-sync-status';
import * as actualUseSyncToasts from './use-sync-toasts';
@@ -31,11 +30,6 @@ vi.doMock('@/editor/DocumentContext', () => ({
}),
}));
-vi.doMock('./use-presence', () => ({
- ...actualUsePresence,
- usePresence: () => ({ current: currentAgents, crossDoc: crossDocAgents }),
-}));
-
vi.doMock('./use-sync-status', () => ({
...actualUseSyncStatus,
useSyncStatus: () => ({ state: 'clean' }),
@@ -76,7 +70,7 @@ describe('PresenceBar avatar click wiring', () => {
currentAgents = [agent('abc', 'claude', 'notes.md')];
const html = renderToString(
<TooltipProvider>
- <PresenceBar />
+ <PresenceBar current={currentAgents} crossDoc={crossDocAgents} />
</TooltipProvider>,
);
expect(html).toContain('data-presence-badge="agent"');
@@ -88,7 +82,7 @@ describe('PresenceBar avatar click wiring', () => {
crossDocAgents = [agent('zzz', 'cursor', 'other.md')];
const html = renderToString(
<TooltipProvider>
- <PresenceBar />
+ <PresenceBar current={currentAgents} crossDoc={crossDocAgents} />
</TooltipProvider>,
);
expect(html).toContain('data-presence-badge="agent"');
@@ -100,7 +94,7 @@ describe('PresenceBar avatar click wiring', () => {
crossDocAgents = [agent('idle', 'claude', '(connected)')];
const html = renderToString(
<TooltipProvider>
- <PresenceBar />
+ <PresenceBar current={currentAgents} crossDoc={crossDocAgents} />
</TooltipProvider>,
);
expect(html).toContain('data-presence-badge="agent"');
@@ -113,7 +107,7 @@ describe('PresenceBar avatar click wiring', () => {
crossDocAgents = [agent('idle', 'claude', '(connected)')];
const html = renderToString(
<TooltipProvider>
- <PresenceBar />
+ <PresenceBar current={currentAgents} crossDoc={crossDocAgents} />
</TooltipProvider>,
);
expect(html).toContain('<button');
@@ -130,7 +124,7 @@ describe('PresenceBar avatar click wiring', () => {
];
const html = renderToString(
<TooltipProvider>
- <PresenceBar />
+ <PresenceBar current={currentAgents} crossDoc={crossDocAgents} />
</TooltipProvider>,
);
expect(html).toContain('data-slot="presence-overflow"');
diff --git a/packages/app/src/presence/PresenceBar.tsx b/packages/app/src/presence/PresenceBar.tsx
index 2da06a057..ff9ed4014 100644
--- a/packages/app/src/presence/PresenceBar.tsx
+++ b/packages/app/src/presence/PresenceBar.tsx
@@ -26,12 +26,7 @@ import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover
import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
import { useDocumentContext } from '@/editor/DocumentContext';
import type { AwarenessUser } from './identity.ts';
-import {
- type AgentParticipant,
- type HumanParticipant,
- type Participant,
- usePresence,
-} from './use-presence';
+import type { AgentParticipant, HumanParticipant, Participant, usePresence } from './use-presence';
const M_CURRENT_PRIMARY = 4;
const K_CROSSDOC_PRIMARY = 3;
@@ -323,16 +318,8 @@ function renderParticipant(
);
}
-export function PresenceBar() {
- const {
- activeProvider,
- activeDocName,
- systemProvider,
- openActivityPanel,
- docPanelMode,
- docPanelAgentId,
- } = useDocumentContext();
- const { current, crossDoc } = usePresence(activeProvider, systemProvider, activeDocName);
+export function PresenceBar({ current, crossDoc }: ReturnType<typeof usePresence>) {
+ const { openActivityPanel, docPanelMode, docPanelAgentId } = useDocumentContext();
if (current.length === 0 && crossDoc.length === 0) return null;
diff --git a/packages/app/tests/stress/app-header-presence-expiry.e2e.ts b/packages/app/tests/stress/app-header-presence-expiry.e2e.ts
new file mode 100644
index 000000000..39b854bf6
--- /dev/null
+++ b/packages/app/tests/stress/app-header-presence-expiry.e2e.ts
@@ -0,0 +1,208 @@
+import type { Page } from '@playwright/test';
+import { AGENT_PRESENCE_STALE_MS } from '../../src/lib/agent-presence';
+import { type ApiHelpers, expect, test, waitForActiveProviderSynced } from './_helpers';
+
+const NARROW_VIEWPORT = { width: 320, height: 720 };
+const FOLDED_WITHOUT_PRESENCE_VIEWPORT = { width: 240, height: 720 };
+
+test.use({ locale: 'en-US' });
+
+async function recordInsertions(page: Page, selectors: readonly string[]) {
+ return page.evaluateHandle((targets) => {
+ const counts = targets.map(() => 0);
+ new MutationObserver((records) => {
+ for (const record of records) {
+ for (const node of record.addedNodes) {
+ if (!(node instanceof Element)) continue;
+ targets.forEach((target, index) => {
+ if (node.matches(target) || node.querySelector(target) !== null) counts[index] += 1;
+ });
+ }
+ }
+ }).observe(document.body, { childList: true, subtree: true });
+ return counts;
+ }, selectors);
+}
+
+async function collapseWithPresence(page: Page, api: ApiHelpers) {
+ const docName = `header-presence-${crypto.randomUUID()}`;
+ await api.seedDocs([{ name: docName, markdown: '# Header presence\n' }]);
+ await page.goto(`/#/${docName}`);
+ await waitForActiveProviderSynced(page);
+ await page.evaluate(() => document.fonts.ready);
+
+ const header = page.locator('[data-app-header]');
+ const settings = header.getByRole('button', { name: 'Settings', exact: true });
+ const trigger = header.getByTestId('header-overflow-actions-trigger');
+ const menu = page.locator('[data-header-overflow-actions]');
+ const badge = page.locator('[data-presence-badge="agent"]');
+ const share = header.getByRole('button', { name: 'Share doc', exact: true });
+ const presenceBar = header.locator('[data-slot="presence-bar"]');
+
+ await page.setViewportSize(NARROW_VIEWPORT);
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ await expect(badge).toHaveCount(0);
+
+ await page.setViewportSize({ width: 1280, height: 720 });
+ await page.clock.setFixedTime(Date.now());
+ await api.writeAsAgent(docName, '# Header presence\n\nAgent update.\n', {
+ agentId: `header-agent-${crypto.randomUUID()}`,
+ agentName: 'Header agent',
+ clientName: 'codex',
+ });
+ await expect(badge).toBeVisible();
+ await page.setViewportSize(NARROW_VIEWPORT);
+ await expect(trigger).toBeVisible();
+ await expect(settings).toHaveCount(0);
+ return { header, settings, trigger, menu, badge, share, presenceBar };
+}
+
+test('expired presence restores inline header actions with the menu closed', async ({
+ page,
+ api,
+}) => {
+ const { settings, trigger } = await collapseWithPresence(page, api);
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ expect(page.viewportSize()).toEqual(NARROW_VIEWPORT);
+});
+
+test('expired presence keeps the open header menu until dismissal then restores inline actions', async ({
+ page,
+ api,
+}) => {
+ const { settings, trigger, menu, badge } = await collapseWithPresence(page, api);
+ await trigger.click();
+ await expect(menu).toBeVisible();
+ await expect(badge).toBeVisible();
+ const openMenu = await menu.evaluateHandle((element) => element);
+ const menuSettings = menu.getByRole('button', { name: 'Settings', exact: true });
+ await menuSettings.focus();
+ await expect(menuSettings).toBeFocused();
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+ await expect(badge).toHaveCount(0);
+ await expect(menu).toBeVisible();
+ expect(await openMenu.evaluate((element) => element.isConnected)).toBe(true);
+ await expect(menuSettings).toBeFocused();
+
+ await trigger.click();
+ await expect(menu).toHaveCount(0);
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ expect(page.viewportSize()).toEqual(NARROW_VIEWPORT);
+ await openMenu.dispose();
+});
+
+test('unchanged fresh presence keeps header actions folded across menu and resize updates', async ({
+ page,
+ api,
+}) => {
+ const { settings, trigger, menu, badge } = await collapseWithPresence(page, api);
+ await trigger.click();
+ await expect(menu).toBeVisible();
+ await expect(badge).toBeVisible();
+ await trigger.click();
+ await expect(menu).toHaveCount(0);
+
+ for (const width of [319, 320]) {
+ await page.setViewportSize({ width, height: NARROW_VIEWPORT.height });
+ await expect(trigger).toBeVisible();
+ await expect(settings).toHaveCount(0);
+ }
+
+ await trigger.click();
+ await expect(menu).toBeVisible();
+ await expect(badge).toBeVisible();
+});
+
+test('expired presence keeps focus on the More actions trigger while the header stays folded', async ({
+ page,
+ api,
+}) => {
+ await page.clock.install();
+ const { settings, trigger, menu } = await collapseWithPresence(page, api);
+ await page.setViewportSize(FOLDED_WITHOUT_PRESENCE_VIEWPORT);
+ await expect(trigger).toBeVisible();
+ await expect(settings).toHaveCount(0);
+ await trigger.focus();
+ await expect(trigger).toBeFocused();
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+ await page.clock.runFor(AGENT_PRESENCE_STALE_MS);
+
+ await expect(trigger).toBeFocused();
+ await expect(trigger).toBeVisible();
+ await expect(settings).toHaveCount(0);
+
+ const insertions = await recordInsertions(page, [
+ '[data-header-overflow-actions]',
+ '[data-presence-badge="agent"]',
+ ]);
+ await page.keyboard.press('Enter');
+ await expect(menu).toBeVisible();
+ await expect(menu.getByRole('button', { name: 'Settings', exact: true })).toBeVisible();
+ const [menuInsertions, badgeInsertions] = await insertions.evaluate((counts) => counts);
+ expect(menuInsertions).toBeGreaterThan(0);
+ expect(badgeInsertions).toBe(0);
+ await insertions.dispose();
+});
+
+test('dismissing the header menu after presence expiry moves focus to the first restored header action', async ({
+ page,
+ api,
+}) => {
+ const { settings, trigger, menu, badge, share, presenceBar } = await collapseWithPresence(
+ page,
+ api,
+ );
+ await trigger.click();
+ await expect(menu).toBeVisible();
+ await expect(badge).toBeVisible();
+ const menuShare = menu.getByRole('button', { name: 'Share doc', exact: true });
+ await menuShare.focus();
+ await expect(menuShare).toBeFocused();
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+ await expect(badge).toHaveCount(0);
+ await expect(menu).toBeVisible();
+ await expect(menuShare).toBeFocused();
+
+ await page.keyboard.press('Escape');
+ await expect(menu).toHaveCount(0);
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ await expect(presenceBar).toHaveCount(0);
+ await expect(share).toBeFocused();
+});
+
+test('expired presence that unfolds the header moves trigger focus to the first restored header action', async ({
+ page,
+ api,
+}) => {
+ const { settings, trigger, share, presenceBar } = await collapseWithPresence(page, api);
+ await trigger.focus();
+ await expect(trigger).toBeFocused();
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ await expect(presenceBar).toHaveCount(0);
+ await expect(share).toBeFocused();
+});
+
+test('expired presence leaves focus outside the header where it was', async ({ page, api }) => {
+ const { settings, trigger } = await collapseWithPresence(page, api);
+ const editorView = page.locator('.ProseMirror:not(.composer-prosemirror)');
+ await editorView.getByText('Agent update.').click();
+ await expect(editorView).toBeFocused();
+
+ await page.clock.setFixedTime(Date.now() + AGENT_PRESENCE_STALE_MS);
+ await expect(settings).toBeVisible();
+ await expect(trigger).toHaveCount(0);
+ expect(await page.evaluate(() => window.__activeEditor?.view.hasFocus())).toBe(true);
+});