@@ -0,0 +1,2 @@
+---
+---
@@ -0,0 +1,2 @@
+---
+---
@@ -2,6 +2,7 @@ import type { FloatingEvents, OpenChangeReason } from '@floating-ui/react';
 import { renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
+import { withInteractionOrigin } from '../utils/interaction-origin';
 import { useReturnFocus } from './use-return-focus';
 
 function createEvents(): FloatingEvents & { close: (event?: Event, reason?: OpenChangeReason) => void } {
@@ -26,7 +27,7 @@ function createEvents(): FloatingEvents & { close: (event?: Event, reason?: Open
   };
 }
 
-function renderReturnFocus(trigger: HTMLElement) {
+function renderReturnFocus(trigger: HTMLElement | null) {
   const events = createEvents();
 
   const { result, rerender } = renderHook(
@@ -35,7 +36,14 @@ function renderReturnFocus(trigger: HTMLElement) {
     { initialProps: { open: false } },
   );
 
-  return { events, result, open: (open: boolean) => rerender({ open }) };
+  return {
+    events,
+    result,
+    open: (open: boolean) => {
+      events.emit('openchange', { open });
+      rerender({ open });
+    },
+  };
 }
 
 let trigger: HTMLElement;
@@ -105,4 +113,59 @@ describe('useReturnFocus', () => {
 
     expect(result.current.current).toBe(trigger);
   });
+
+  describe('opened from inside another floating element', () => {
+    let menuTrigger: HTMLElement;
+
+    beforeEach(() => {
+      menuTrigger = document.createElement('button');
+      document.body.append(menuTrigger);
+    });
+
+    afterEach(() => menuTrigger.remove());
+
+    it('falls back to the interaction origin when it has no trigger of its own', () => {
+      const { result, open } = renderReturnFocus(null);
+
+      withInteractionOrigin(menuTrigger, () => open(true));
+
+      expect(result.current.current).toBe(menuTrigger);
+    });
+
+    it('prefers its own trigger over the interaction origin', () => {
+      const { result, open } = renderReturnFocus(trigger);
+
+      withInteractionOrigin(menuTrigger, () => open(true));
+
+      expect(result.current.current).toBe(trigger);
+    });
+
+    it('falls back to the origin once its own trigger has left the page', () => {
+      const { result, open } = renderReturnFocus(trigger);
+      withInteractionOrigin(menuTrigger, () => open(true));
+
+      trigger.remove();
+
+      expect(result.current.current).toBe(menuTrigger);
+    });
+
+    it('resolves to nothing once the origin has left the page too', () => {
+      const { result, open } = renderReturnFocus(null);
+      withInteractionOrigin(menuTrigger, () => open(true));
+
+      menuTrigger.remove();
+
+      expect(result.current.current).toBeNull();
+    });
+
+    it('forgets the origin on an open that has none', () => {
+      const { result, open } = renderReturnFocus(null);
+      withInteractionOrigin(menuTrigger, () => open(true));
+      open(false);
+
+      open(true);
+
+      expect(result.current.current).toBeNull();
+    });
+  });
 });
@@ -5,6 +5,7 @@ import { useFloatingParentNodeId, useFloatingTree } from '@floating-ui/react';
 import { useEffect, useMemo, useRef } from 'react';
 
 import { isKeyboardEvent } from '../utils/interaction-modality';
+import { currentInteractionOrigin } from '../utils/interaction-origin';
 
 /**
  * The element `FloatingFocusManager` restores focus to when the floating element closes.
@@ -18,8 +19,10 @@ import { isKeyboardEvent } from '../utils/interaction-modality';
  * A floating element opened from inside another one — a dialog from a menu item — may have no
  * trigger of its own, or one that is gone by the time it closes: the item unmounted with the menu.
  * Focus then goes to the nearest ancestor in the floating tree whose reference is still on the
- * page, which for a menu is its trigger. Resolved lazily, at restore time, since that is when it is
- * known whether the trigger survived.
+ * page, which for a menu is its trigger. A dialog mounted outside that tree — one instance at the
+ * end of a table, opened from any row's menu — has no ancestor to walk, so the interaction origin
+ * the menu item published while its `onClick` ran is recorded on open and used instead. Resolved
+ * lazily, at restore time, since that is when it is known whether the trigger survived.
  *
  * Pass the result to `FloatingFocusManager`'s `returnFocus`. On `null` it falls back to the
  * hidden guard element it keeps next to the trigger, so the tab position survives; verify that
@@ -32,6 +35,7 @@ export function useReturnFocus(
   const tree = useFloatingTree();
   const parentId = useFloatingParentNodeId();
   const triggerRef = useRef<HTMLElement | null>(null);
+  const originRef = useRef<HTMLElement | null>(null);
   const dismissedByPointerRef = useRef(false);
   const trigger = elements.domReference;
 
@@ -48,7 +52,9 @@ export function useReturnFocus(
     // forwarded without a reason — a Close button press — keeps the trigger, and programmatic
     // closes carry no event at all.
     function onOpenChange({ open, event, reason }: { open: boolean; event?: Event; reason?: OpenChangeReason }) {
-      if (!open && event && reason && !isKeyboardEvent(event)) {
+      if (open) {
+        originRef.current = currentInteractionOrigin();
+      } else if (event && reason && !isKeyboardEvent(event)) {
         dismissedByPointerRef.current = true;
       }
     }
@@ -67,6 +73,10 @@ export function useReturnFocus(
         if (own?.isConnected) {
           return own;
         }
+        const origin = originRef.current;
+        if (origin?.isConnected) {
+          return origin;
+        }
         return ancestorReference(tree, parentId);
       },
       set current(element: HTMLElement | null) {
 
@@ -814,6 +814,64 @@ describe('Dialog', () => {
       });
     });
 
+    describe('opened from a menu item into a dialog mounted elsewhere', () => {
+      function HoistedFixture() {
+        const handle = React.useMemo(() => Dialog.createHandle<string>(), []);
+        return (
+          <>
+            <Menu.Root>
+              <Menu.Trigger>Actions</Menu.Trigger>
+              <Menu.Positioner>
+                <Menu.Popup>
+                  <Menu.Item
+                    label='Remove'
+                    onClick={() => handle.open('item-1')}
+                  >
+                    Remove
+                  </Menu.Item>
+                </Menu.Popup>
+              </Menu.Positioner>
+            </Menu.Root>
+            <Dialog.Root handle={handle}>
+              {({ payload }) => (
+                <Dialog.Popup>
+                  <Dialog.Title>Remove {payload}?</Dialog.Title>
+                  <Dialog.Close>Cancel</Dialog.Close>
+                </Dialog.Popup>
+              )}
+            </Dialog.Root>
+          </>
+        );
+      }
+
+      it('returns focus to the menu trigger on Escape', async () => {
+        const user = userEvent.setup();
+        render(<HoistedFixture />);
+
+        const trigger = screen.getByRole('button', { name: 'Actions' });
+        trigger.focus();
+        await user.keyboard('{Enter}');
+        await user.keyboard('{Enter}');
+        expect(screen.getByRole('dialog', { name: 'Remove item-1?' })).toBeInTheDocument();
+
+        await user.keyboard('{Escape}');
+
+        expect(document.activeElement).toBe(trigger);
+      });
+
+      it('returns focus to the menu trigger on Close press', async () => {
+        const user = userEvent.setup();
+        render(<HoistedFixture />);
+
+        const trigger = screen.getByRole('button', { name: 'Actions' });
+        await user.click(trigger);
+        await user.click(screen.getByRole('menuitem', { name: 'Remove' }));
+        await user.click(screen.getByRole('button', { name: 'Cancel' }));
+
+        expect(document.activeElement).toBe(trigger);
+      });
+    });
+
     it('resolves the function form with an empty type on programmatic close', () => {
       const handle = Dialog.createHandle();
       const finalFocus = vi.fn(() => undefined);
 
@@ -4,6 +4,7 @@ import { useFloatingTree, useListItem } from '@floating-ui/react';
 import React from 'react';
 
 import { type ComponentProps, type DefaultProps, mergeProps, useRender } from '../../utils';
+import { withInteractionOrigin } from '../../utils/interaction-origin';
 import { useMenuContext } from './menu-context';
 
 export interface MenuItemProps extends ComponentProps<'button'> {
@@ -14,12 +15,21 @@ export interface MenuItemProps extends ComponentProps<'button'> {
 
 export const MenuItem = React.forwardRef<HTMLButtonElement, MenuItemProps>(function MenuItem(props, ref) {
   const { render, label, disabled, closeOnClick = true, onClick: consumerOnClick, ...otherProps } = props;
+  const { activeIndex, getItemProps, refs } = useMenuContext();
   // When disabled, omit the consumer onClick entirely so mergeProps doesn't chain it.
   // When not disabled, add it back only if it's a function (avoids spreading onClick: undefined
-  // which would overwrite the internal getItemProps handler via mergeProps).
+  // which would overwrite the internal getItemProps handler via mergeProps). It runs with the
+  // menu's trigger as the interaction origin, so a dialog it opens can return focus there.
   const safeOtherProps =
-    !disabled && typeof consumerOnClick === 'function' ? { ...otherProps, onClick: consumerOnClick } : otherProps;
-  const { activeIndex, getItemProps } = useMenuContext();
+    !disabled && typeof consumerOnClick === 'function'
+      ? {
+          ...otherProps,
+          onClick: (event: React.MouseEvent<HTMLButtonElement>) => {
+            const reference = refs.domReference.current;
+            withInteractionOrigin(reference instanceof HTMLElement ? reference : null, () => consumerOnClick(event));
+          },
+        }
+      : otherProps;
   const tree = useFloatingTree();
   const item = useListItem({ label: disabled ? null : label });
   const isActive = item.index === activeIndex;
 
@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+
+import { currentInteractionOrigin, withInteractionOrigin } from './interaction-origin';
+
+describe('withInteractionOrigin', () => {
+  it('exposes the element only while the callback runs', () => {
+    const trigger = document.createElement('button');
+    let seen: HTMLElement | null = null;
+
+    withInteractionOrigin(trigger, () => {
+      seen = currentInteractionOrigin();
+    });
+
+    expect(seen).toBe(trigger);
+    expect(currentInteractionOrigin()).toBeNull();
+  });
+
+  it('restores the enclosing origin when nested', () => {
+    const outer = document.createElement('button');
+    const inner = document.createElement('button');
+    let afterInner: HTMLElement | null = null;
+
+    withInteractionOrigin(outer, () => {
+      withInteractionOrigin(inner, () => undefined);
+      afterInner = currentInteractionOrigin();
+    });
+
+    expect(afterInner).toBe(outer);
+  });
+
+  it('clears the origin when the callback throws', () => {
+    const trigger = document.createElement('button');
+
+    expect(() =>
+      withInteractionOrigin(trigger, () => {
+        throw new Error('boom');
+      }),
+    ).toThrow('boom');
+
+    expect(currentInteractionOrigin()).toBeNull();
+  });
+
+  it('returns what the callback returns', () => {
+    expect(withInteractionOrigin(null, () => 'value')).toBe('value');
+  });
+});
@@ -0,0 +1,27 @@
+/**
+ * The element a user interaction is happening on behalf of, for the synchronous span of that
+ * interaction. A menu item sets its menu's trigger here around the consumer's `onClick`; a
+ * floating element opened during that span records it as somewhere focus can return to once its
+ * own trigger is gone — the item unmounts with the menu, the trigger does not.
+ *
+ * Module-level on purpose: the item and the dialog it opens share no ancestor, so no context or
+ * prop can carry this between them. It is only ever set inside {@link withInteractionOrigin} and
+ * is cleared before that returns, so anything read after an `await` sees nothing.
+ */
+let origin: HTMLElement | null = null;
+
+/** Runs `callback` with `element` as the current interaction origin, restoring the previous one after. */
+export function withInteractionOrigin<T>(element: HTMLElement | null, callback: () => T): T {
+  const previous = origin;
+  origin = element;
+  try {
+    return callback();
+  } finally {
+    origin = previous;
+  }
+}
+
+/** The element the current interaction is on behalf of, or `null` outside one. */
+export function currentInteractionOrigin(): HTMLElement | null {
+  return origin;
+}
@@ -83,6 +83,13 @@ trigger, no selection when personal is hidden and none is active, the account ot
   storyModule={UserButtonStories}
 />
 
+A user's avatar on its own rounds the trigger fully to match it.
+
+<Story
+  name='UserAvatarOnly'
+  storyModule={UserButtonStories}
+/>
+
 `renderTriggerBadge={false}` keeps the name. The badge is part of the label, so it needs both.
 
 <Story
 
@@ -278,6 +278,18 @@ export function AvatarOnly(_args: Record<string, unknown>) {
   );
 }
 
+export function UserAvatarOnly(_args: Record<string, unknown>) {
+  const prototype = usePrototype();
+
+  return (
+    <UserButtonView
+      {...prototype}
+      mode='user'
+      renderTriggerLabel={false}
+    />
+  );
+}
+
 export function WithoutTriggerBadge(_args: Record<string, unknown>) {
   const prototype = usePrototype();