@@ -145,6 +145,15 @@ This covers what the browser doesn't restore: `manual`, `hint`, a `<dialog>` sho
 - Showing a modal closes open `auto` popovers. Content that must sit above a modal, like toasts, has to be shown after it.
 - Popovers opened without user activation in between share a close watcher, so one Escape closes them all. Tests need trusted input (`cypress-real-events`).
 
+## Consumers
+
+- **Popover / TeachingPopover / InfoLabel.** `usePopover` drives `contentRef` with `mode: trapFocus ? 'modal' : mode` and `returnFocus: triggerRef`, routes `onOpenChange` into its open state, and passes the hook's `onKeyDown` to the surface, so a `manual` surface closes on Escape. A custom surface without `contentRef` is mounted only while open.
+- **Dialog / Drawer.** `DialogSurface` uses `'modal'`, or `'manual'` when non-modal, with `preventEscapeClose` because `onOpenChange` can veto. Escape through the hook's `onKeyDown` is reported as `escapeKeyDown`; Escape inside a nested layer, or while an `auto` or `hint` popover such as a Tooltip is open inside, is left to that layer, and Escape from content portaled out of the surface still closes it. Every other browser open or close (`popovertarget`, `commandfor`, `<form method="dialog">`, `dialog.close()`, a close request that never reached the surface) is reported as `surfaceToggle`. A non-modal surface uses `returnFocus: 'always'`, as before. Backdrop clicks stay in a React handler.
+- **Tooltip.** `mode: 'hint'`, which acts as `manual` where unsupported, so it never closes an open `auto` popover. Stays mounted so `aria-labelledby` / `aria-describedby` resolve.
+- **Menu.** `MenuPopover` stays mounted with `mode: 'auto'`, focuses the first enabled item through `initialFocus`, re-applies `focusgroup` in `onShow`, and leaves focus return to `useMenu`. Browser closes are reported as `clickOutside`.
+- **Combobox / Dropdown / TagPicker listbox.** `mode: 'auto'`, rendered only while open. Focus stays on the trigger. Browser opens and closes go through `setOpen`.
+- **Toaster.** Each toast position is a `manual` popover, shown while it has toasts.
+
 ## Decisions
 
 **React owns `open`.** The hook reports every open and close the browser makes, and none made through `open`. A browser close is final: the element stays closed even if the consumer keeps `open`. Escape on a modal follows the platform: the browser closes it and `onOpenChange` reports it. `preventEscapeClose` keeps it open for consumers that can veto.
@@ -154,3 +163,20 @@ This covers what the browser doesn't restore: `manual`, `hint`, a `<dialog>` sho
 **Internal only.** A public hook would let consumers build overlays without roles, keyboard handling or focus behaviour. Custom overlays compose the components instead; where a component lacks a mode (e.g. `manual` or `hint` on Popover), the component gains it. The hook can become public later if a case comes up that composition cannot cover. Option shapes can change freely until then.
 
 **Focus follows the platform.** The hook doesn't move focus on open unless asked, doesn't wrap Tab, and returns focus only where the browser doesn't, including after light dismiss, so keyboard and screen reader users don't lose their place.
+
+## Changes from master
+
+Visible differences in the components moved onto `useTopLayer`. Everything else is unchanged.
+
+| Area                                                                         | Master                                                                       | Now                                                                        |
+| ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| Popover exit                                                                 | unmounted once the browser reported the close                                | also waits for exit animations, like `DialogSurface`                       |
+| Exiting Popover and Dialog                                                   | —                                                                            | `inert` and `aria-hidden="true"` while exiting                             |
+| Escape in a layer nested in a `DialogSurface`, or with a Tooltip open inside | the outer dialog closed too, unless the inner handler stopped the event      | only the inner one closes                                                  |
+| `popover="hint"` on Tooltip                                                  | `hint`; browsers without it treat it as `manual`                             | unchanged                                                                  |
+| Custom Popover surface                                                       | mounted only while open                                                      | unchanged                                                                  |
+| Popover kept `open` after a browser dismiss                                  | shown again                                                                  | stays closed, with a dev warning; use `mode="manual"` to prevent dismissal |
+| Modal Dialog native close (`<form method="dialog">`)                         | closes, not reported, so React state goes out of sync                        | closes, reported as `surfaceToggle`                                        |
+| Modal Dialog close request without a keydown on it (focus on `<body>`)       | ignored                                                                      | reported as `surfaceToggle`                                                |
+| Popover `trapFocus` Escape                                                   | browser closes the dialog, `onOpenChange` `type: 'close'`                    | unchanged                                                                  |
+| Native opens (`popovertarget`, `commandfor`, `showModal()`)                  | non-modal Dialog synced as `surfaceToggle`; Popover unreachable while closed | also modal Dialog, where dialogs fire `toggle` (Chromium 132+)             |
@@ -34,7 +34,7 @@ export const Popover: {
 };
 
 // @public
-export type PopoverContextValue = Pick<PopoverState, 'open' | 'setOpen' | 'toggleOpen' | 'triggerRef' | 'contentRef' | 'arrowRef' | 'openOnHover' | 'openOnContext' | 'withArrow' | 'surfaceId' | 'trapFocus' | 'mode'> & {
+export type PopoverContextValue = Pick<PopoverState, 'open' | 'setOpen' | 'toggleOpen' | 'triggerRef' | 'contentRef' | 'arrowRef' | 'openOnHover' | 'openOnContext' | 'withArrow' | 'surfaceId' | 'trapFocus' | 'mode' | 'onSurfaceKeyDown'> & {
     positioning: {
         targetRef: React_2.RefCallback<HTMLElement>;
         containerRef: React_2.RefCallback<HTMLElement>;
@@ -80,6 +80,7 @@ export type PopoverState = Required<Pick<PopoverProps, 'open' | 'trapFocus' | 'm
     positioning: PositioningReturn;
     surfaceId: string;
     shouldRenderSurface: boolean;
+    onSurfaceKeyDown: (event: React_2.KeyboardEvent<HTMLElement>) => void;
 };
 
 // @public
 
@@ -260,6 +260,7 @@ export type TeachingPopoverState = Required<Pick<TeachingPopoverProps, 'open' |
     positioning: PositioningReturn;
     surfaceId: string;
     shouldRenderSurface: boolean;
+    onSurfaceKeyDown: (event: React_2.KeyboardEvent<HTMLElement>) => void;
 };
 
 // @public
 
@@ -125,6 +125,49 @@ describe('Dialog', () => {
     );
   });
 
+  it('reports Escape once as escapeKeyDown and keeps the dialog open for the consumer to decide', () => {
+    const onOpenChange = jest.fn();
+    const { getByRole, getByText } = render(
+      <Dialog open onOpenChange={onOpenChange}>
+        <DialogSurface aria-label="Dialog">
+          <button>Inside</button>
+        </DialogSurface>
+      </Dialog>,
+    );
+    const surface = getByRole('dialog', { hidden: true });
+
+    fireEvent.keyDown(getByText('Inside'), { key: 'Escape' });
+    const cancelEvent = new Event('cancel', { cancelable: true });
+    fireEvent(surface, cancelEvent);
+
+    expect(cancelEvent.defaultPrevented).toBe(true);
+    expect(onOpenChange).toHaveBeenCalledTimes(1);
+    expect(onOpenChange).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ type: 'escapeKeyDown', open: false }),
+    );
+  });
+
+  it('reports a close request that never reached the surface as surfaceToggle', () => {
+    const onOpenChange = jest.fn();
+    const { getByRole } = render(
+      <Dialog open onOpenChange={onOpenChange}>
+        <DialogSurface aria-label="Dialog">Content</DialogSurface>
+      </Dialog>,
+    );
+    const surface = getByRole('dialog', { hidden: true });
+
+    // Escape with focus on <body>, or the Android back button: `cancel` without a keydown on the surface.
+    const cancelEvent = new Event('cancel', { cancelable: true });
+    fireEvent(surface, cancelEvent);
+
+    expect(cancelEvent.defaultPrevented).toBe(true);
+    expect(onOpenChange).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ type: 'surfaceToggle', open: false }),
+    );
+  });
+
   it('returns focus to the element focused before opening a non-modal dialog, even if focus moved outside', () => {
     const Example = ({ open }: { open: boolean }) => (
       <>
 
@@ -13,7 +13,6 @@ import { useDialogContext } from '../dialogContext';
 import { toDataAttributeValue } from '../../../utils';
 import { lockDocumentScroll, unlockDocumentScroll } from '../utils/scroll';
 import { useTopLayer } from '../../../hooks/useTopLayer/useTopLayer';
-import { isEscapeForLayer } from '../../../utils/topLayer';
 import type { DialogSurfaceProps, DialogSurfaceState } from './DialogSurface.types';
 
 /**
@@ -33,38 +32,30 @@ export const useDialogSurface = (props: DialogSurfaceProps, ref: React.Ref<HTMLD
 
   const isNonModal = modalType === 'non-modal';
 
-  // Non-modal: always return focus to the element focused before opening. Declared before `useTopLayer` so the
-  // snapshot is taken before the surface is shown.
-  const previouslyFocusedElement = React.useRef<HTMLElement | null>(null);
-  useIsomorphicLayoutEffect(() => {
-    if (!isNonModal) {
-      return;
-    }
-    if (open) {
-      previouslyFocusedElement.current = targetDocument?.activeElement as HTMLElement | null;
-      return;
-    }
-    const elementToFocus = previouslyFocusedElement.current;
-    previouslyFocusedElement.current = null;
-    if (elementToFocus && targetDocument?.contains(elementToFocus)) {
-      elementToFocus.focus();
-    }
-  }, [open, isNonModal, targetDocument]);
-
-  // A `popovertarget` invoker can toggle a non-modal surface; it is reported as `surfaceToggle`.
-  const { shouldRender, phase } = useTopLayer(dialogRef, {
+  // Escape goes through the hook's `onKeyDown`, so it is reported as `escapeKeyDown` with the React event. A browser
+  // open or close (`popovertarget`, `commandfor`, `<form method="dialog">`) is reported as `surfaceToggle`.
+  const { shouldRender, phase, onKeyDown } = useTopLayer(dialogRef, {
     open,
     mode: isNonModal ? 'manual' : 'modal',
     unmountOnClose,
-    restoreFocus: !isNonModal,
+    // Non-modal: always return focus to the element focused before opening.
+    returnFocus: isNonModal ? 'always' : true,
     // `onOpenChange` can veto Escape, so the browser must not close the dialog first.
     preventEscapeClose: true,
-    onOpen: isNonModal ? event => requestOpenChange({ type: 'surfaceToggle', open: true, event }) : undefined,
-    // Escape is reported by the keydown handler below.
-    onClose: ({ type, event }) => {
-      if (type !== 'escape') {
-        requestOpenChange({ type: 'surfaceToggle', open: false, event });
+    onOpenChange: (nextOpen, { type, event }) => {
+      if (!nextOpen && type === 'escape' && 'nativeEvent' in event) {
+        requestOpenChange({
+          type: 'escapeKeyDown',
+          open: false,
+          event: event as React.KeyboardEvent<HTMLDialogElement>,
+        });
+        return;
       }
+      requestOpenChange({
+        type: 'surfaceToggle',
+        open: nextOpen,
+        event: 'nativeEvent' in event ? event.nativeEvent : event,
+      });
     },
   });
 
@@ -78,17 +69,8 @@ export const useDialogSurface = (props: DialogSurfaceProps, ref: React.Ref<HTMLD
 
   const handleKeyDown = useEventCallback((event: React.KeyboardEvent<HTMLDialogElement>) => {
     props.onKeyDown?.(event);
-    // Escape inside a nested popover or dialog closes that layer first.
-    if (
-      event.key === 'Escape' &&
-      !event.isDefaultPrevented() &&
-      isEscapeForLayer(event.currentTarget, event.target as Element)
-    ) {
-      requestOpenChange({ type: 'escapeKeyDown', open: false, event });
-      // Stop propagation to avoid closing parent dialogs simultaneously.
-      event.stopPropagation();
-      return;
-    }
+    // Escape, unless it belongs to a layer nested inside.
+    onKeyDown(event);
 
     // When the non-modal surface itself is focused, move Tab to the first
     // focusable descendant explicitly.
 
@@ -106,9 +106,8 @@ export function useListboxSlot(
     open,
     mode: 'auto',
     unmountOnClose: false,
-    restoreFocus: false,
-    onClose: ({ event }) => setOpen(event as unknown as DropdownOpenEvents, false),
-    onOpen: event => setOpen(event as unknown as DropdownOpenEvents, true),
+    returnFocus: false,
+    onOpenChange: (nextOpen, { event }) => setOpen(event as unknown as DropdownOpenEvents, nextOpen),
   });
 
   return listboxSlot;
 
@@ -3,7 +3,6 @@
 import type * as React from 'react';
 import { useMenuPopoverBase_unstable } from '@fluentui/react-menu';
 import type { MenuPopoverProps, MenuPopoverState } from '@fluentui/react-menu';
-import { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';
 import { useMenuContext } from '../menuContext';
 import { useTopLayer } from '../../../hooks/useTopLayer';
 
@@ -22,35 +21,28 @@ export const useMenuPopover = (props: MenuPopoverProps, ref: React.Ref<HTMLEleme
   const setOpen = useMenuContext(ctx => ctx.setOpen);
   const menuPopoverRef = useMenuContext(ctx => ctx.menuPopoverRef);
 
-  // Before `useTopLayer` shows the popover, so the browser focuses the `autofocus` item.
-  useIsomorphicLayoutEffect(() => {
-    if (open) {
-      menuPopoverRef.current?.querySelector<HTMLElement>(MENU_ITEM_SELECTOR)?.setAttribute('autofocus', '');
-    }
-  }, [menuPopoverRef, open]);
-
-  // Stays mounted; `useMenu` restores focus.
+  // Stays mounted; `useMenu` restores focus. The first enabled item takes focus, and `focusgroup` is re-applied once
+  // shown, so the polyfill sees the visible items.
   useTopLayer(menuPopoverRef as React.RefObject<HTMLElement | null>, {
     open,
     mode: 'auto',
     unmountOnClose: false,
-    restoreFocus: false,
-    onClose: ({ event }) =>
-      setOpen(event as unknown as MouseEvent, {
-        open: false,
-        type: 'clickOutside',
-        event: event as unknown as MouseEvent,
-      }),
+    returnFocus: false,
+    initialFocus: element => element.querySelector<HTMLElement>(MENU_ITEM_SELECTOR),
+    onShow: element => {
+      const menuListEl = element.querySelector<HTMLElement>('[focusgroup]');
+      menuListEl?.setAttribute('focusgroup', menuListEl.getAttribute('focusgroup') ?? '');
+    },
+    onOpenChange: (nextOpen, { event }) => {
+      if (!nextOpen) {
+        setOpen(event as unknown as MouseEvent, {
+          open: false,
+          type: 'clickOutside',
+          event: event as unknown as MouseEvent,
+        });
+      }
+    },
   });
 
-  // Re-apply `focusgroup` once shown, so the polyfill sees the visible items.
-  useIsomorphicLayoutEffect(() => {
-    if (!open) {
-      return;
-    }
-    const menuListEl = menuPopoverRef.current?.querySelector<HTMLElement>('[focusgroup]');
-    menuListEl?.setAttribute('focusgroup', menuListEl.getAttribute('focusgroup') ?? '');
-  }, [menuPopoverRef, open]);
-
   return state;
 };
@@ -311,7 +311,10 @@ describe('Popover', () => {
     const onRender = jest.fn();
     const MeasuredPopover = () => {
       const state = usePopover({ children: <div /> });
-      onRender();
+      // Count commits: `useTopLayer` adjusts state during render, which re-runs the body but doesn't commit twice.
+      React.useEffect(() => {
+        onRender();
+      });
       return (
         <>
           <button aria-expanded={state.open} onClick={event => state.setOpen(event, true)}>
 
@@ -133,6 +133,8 @@ export type PopoverState = Required<Pick<PopoverProps, 'open' | 'trapFocus' | 'm
     surfaceId: string;
     /** Determines whether the surface is present in the DOM. */
     shouldRenderSurface: boolean;
+    /** Merged into the surface's `onKeyDown`; closes a `manual` surface on Escape. */
+    onSurfaceKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
   };
 
 /**
@@ -152,6 +154,7 @@ export type PopoverContextValue = Pick<
   | 'surfaceId'
   | 'trapFocus'
   | 'mode'
+  | 'onSurfaceKeyDown'
 > & {
   positioning: {
     targetRef: React.RefCallback<HTMLElement>;
 
@@ -1,11 +1,9 @@
 'use client';
 
 import type * as React from 'react';
-import { Escape } from '@fluentui/keyboard-keys';
 import { useMergedRefs, slot, useEventCallback } from '@fluentui/react-utilities';
 import { usePopoverContext } from '../popoverContext';
 import { toDataAttributeValue } from '../../../utils';
-import { isEscapeForLayer } from '../../../utils/topLayer';
 import type { PopoverSurfaceProps, PopoverSurfaceState } from './PopoverSurface.types';
 
 /**
@@ -25,6 +23,7 @@ export const usePopoverSurface = (
   const surfaceId = usePopoverContext(context => context.surfaceId);
   const trapFocus = usePopoverContext(context => context.trapFocus);
   const mode = usePopoverContext(context => context.mode);
+  const onSurfaceKeyDown = usePopoverContext(context => context.onSurfaceKeyDown);
 
   if (process.env.NODE_ENV !== 'production' && trapFocus && props.as === 'div') {
     // eslint-disable-next-line no-console
@@ -63,18 +62,10 @@ export const usePopoverSurface = (
     onKeyDown: onKeyDownOriginal,
   } = state.root;
 
-  // The browser ignores Escape on `manual` popovers (and on `hint` where unsupported); close it from React instead.
+  // The browser ignores Escape on `manual` popovers (and on `hint` where unsupported); `useTopLayer` closes it.
   state.root.onKeyDown = useEventCallback((e: React.KeyboardEvent<HTMLDialogElement & HTMLDivElement>) => {
     onKeyDownOriginal?.(e);
-    const popoverMode = (e.currentTarget as HTMLElement & { popover?: string | null }).popover;
-    if (
-      e.key === Escape &&
-      !e.isDefaultPrevented() &&
-      popoverMode === 'manual' &&
-      isEscapeForLayer(e.currentTarget, e.target as Element)
-    ) {
-      setOpen(e, false);
-    }
+    onSurfaceKeyDown(e);
   });
 
   state.root.onMouseEnter = useEventCallback((e: React.MouseEvent<HTMLDialogElement & HTMLDivElement>) => {