diff --git a/apps/ssr-testing/app/document-context/child.tsx b/apps/ssr-testing/app/document-context/child.tsx
new file mode 100644
index 000000000..70555b017
--- /dev/null
+++ b/apps/ssr-testing/app/document-context/child.tsx
@@ -0,0 +1,11 @@
+'use client';
+import * as React from 'react';
+import { DocumentContext } from 'radix-ui/internal';
+
+export function Child() {
+  const document = DocumentContext.useDocument();
+  React.useEffect(() => {
+    console.log(document);
+  }, [document]);
+  return <p>Open the console to see the document context.</p>;
+}
diff --git a/apps/ssr-testing/app/document-context/page.tsx b/apps/ssr-testing/app/document-context/page.tsx
new file mode 100644
index 000000000..f73599ebf
--- /dev/null
+++ b/apps/ssr-testing/app/document-context/page.tsx
@@ -0,0 +1,13 @@
+import * as React from 'react';
+
+import { Parent } from './parent';
+import { Child } from './child';
+
+export default function Page() {
+  return (
+    <Parent>
+      <h1>Document Context</h1>
+      <Child />
+    </Parent>
+  );
+}
diff --git a/apps/ssr-testing/app/document-context/parent.tsx b/apps/ssr-testing/app/document-context/parent.tsx
new file mode 100644
index 000000000..0ae8d0c9d
--- /dev/null
+++ b/apps/ssr-testing/app/document-context/parent.tsx
@@ -0,0 +1,29 @@
+'use client';
+import * as React from 'react';
+import { DocumentContext } from 'radix-ui/internal';
+
+export function Parent({ children }: { children: React.ReactNode }) {
+  const [document, setDocument] = React.useState<Document | null>(null);
+  React.useEffect(() => {
+    console.log(document);
+  }, [document]);
+  return (
+    <DocumentContext.DocumentProvider document={document}>
+      {children}
+      <div>
+        <iframe
+          onLoad={(event) => {
+            const iframeDocument = event.currentTarget.contentDocument;
+            setDocument(iframeDocument);
+          }}
+          title="Radix UI webiste"
+          src="https://www.radix-ui.com"
+          style={{
+            width: '100%',
+            height: '1000px',
+          }}
+        />
+      </div>
+    </DocumentContext.DocumentProvider>
+  );
+}
diff --git a/apps/ssr-testing/app/layout.tsx b/apps/ssr-testing/app/layout.tsx
index d197088b3..17b0ed86c 100644
--- a/apps/ssr-testing/app/layout.tsx
+++ b/apps/ssr-testing/app/layout.tsx
@@ -43,6 +43,7 @@ export default function Layout({ children }: { children: React.ReactNode }) {
               <Link href="/toolbar">Toolbar</Link>
               <Link href="/tooltip">Tooltip</Link>
               <Link href="/visually-hidden">VisuallyHidden</Link>
+              <Link href="/document-context">DocumentContext</Link>
             </div>
 
             <div>{children}</div>
diff --git a/apps/storybook/stories/accordion.stories.tsx b/apps/storybook/stories/accordion.stories.tsx
index 6ebe7e99c..26d9b5e65 100644
--- a/apps/storybook/stories/accordion.stories.tsx
+++ b/apps/storybook/stories/accordion.stories.tsx
@@ -257,7 +257,7 @@ export const Animated = () => {
         });
       }, 3000);
       return () => {
-        clearTimeout(timerRef.current);
+        window.clearTimeout(timerRef.current);
       };
     }
   }, [count, hasDynamicContent]);
diff --git a/apps/storybook/stories/document-context.stories.module.css b/apps/storybook/stories/document-context.stories.module.css
new file mode 100644
index 000000000..5eaa6b3a4
--- /dev/null
+++ b/apps/storybook/stories/document-context.stories.module.css
@@ -0,0 +1,64 @@
+.trigger {
+  border: 1px solid black;
+  border-radius: 6px;
+  background-color: transparent;
+  padding: 5px 10px;
+  font-family: apple-system, BlinkMacSystemFont, helvetica, arial, sans-serif;
+  font-size: 13px;
+
+  &:focus {
+    outline: none;
+    box-shadow: 0 0 0 2px rgb(0 0 0 / 0.5);
+  }
+}
+
+.content {
+  display: inline-block;
+  box-sizing: border-box;
+  min-width: 130px;
+  background-color: var(--color-white);
+  border: 1px solid var(--color-gray100);
+  border-radius: 6px;
+  padding: 5px;
+  box-shadow: 0 5px 10px 0 rgba(0, 0, 0, 0.1);
+  font-family: apple-system, BlinkMacSystemFont, helvetica, arial, sans-serif;
+  font-size: 13px;
+  &:focus-within {
+    border-color: var(--color-black);
+  }
+}
+
+.item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  line-height: 1;
+  cursor: default;
+  user-select: none;
+  white-space: nowrap;
+  height: 25px;
+  padding: 0 10px;
+  color: var(--color-black);
+  border-radius: 3px;
+
+  outline: none;
+
+  &[data-highlighted] {
+    background-color: var(--color-black);
+    color: var(--color-white);
+  }
+
+  &[data-disabled] {
+    color: var(--color-gray100);
+  }
+}
+
+.dialog {
+  position: fixed;
+  background: white;
+  border: 1px solid black;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  padding: 30px;
+}
diff --git a/apps/storybook/stories/document-context.stories.tsx b/apps/storybook/stories/document-context.stories.tsx
new file mode 100644
index 000000000..5a1f16772
--- /dev/null
+++ b/apps/storybook/stories/document-context.stories.tsx
@@ -0,0 +1,146 @@
+import * as React from 'react';
+import { createPortal } from 'react-dom';
+import { DocumentContext } from 'radix-ui/internal';
+import { Dialog, DropdownMenu, Tooltip } from 'radix-ui';
+import styles from './document-context.stories.module.css';
+
+export default { title: 'Utilities/DocumentContext' };
+
+export const Default = () => {
+  const [portalElement, setPortalElement] = React.useState<HTMLElement | null>(null);
+  const [count, setCount] = React.useState(0);
+
+  const openContentInPopup = async () => {
+    const popup = window.open(
+      '',
+      'Popup Test',
+      'height=600,width=600,left=300,top=300,resizable=yes,scrollbars=yes,toolbar=no,menubar=no,location=no,directories=no,status=no'
+    );
+    if (!popup) return;
+
+    // Copy all parent window styles and fonts
+    // https://developer.chrome.com/docs/web-platform/document-picture-in-picture/#copy-style-sheets-to-the-picture-in-picture-window
+    [...document.styleSheets].forEach((styleSheet) => {
+      try {
+        const cssRules = [...styleSheet.cssRules].map((rule) => rule.cssText).join('');
+        const style = document.createElement('style');
+
+        style.textContent = cssRules;
+        popup.document.head.appendChild(style);
+      } catch (e) {
+        console.error(e);
+        const link = document.createElement('link');
+        if (styleSheet.href === null) {
+          return;
+        }
+
+        link.rel = 'stylesheet';
+        link.type = styleSheet.type;
+        link.media = styleSheet.media.toString();
+        link.href = styleSheet.href;
+        popup.document.head.appendChild(link);
+      }
+    });
+
+    setPortalElement(popup.document.body);
+
+    // Detect when window is closed by user
+    popup.addEventListener('pagehide', () => {
+      setPortalElement(null);
+    });
+  };
+
+  const content = (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 40 }}>
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          gap: 32,
+          padding: 32,
+          background: 'yellow',
+        }}
+      >
+        <h1>This section will be portalled to another document/window</h1>
+        <button onClick={() => setCount(count + 1)}>Increment</button>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger className={styles.trigger}>
+            Dropdown with dialog test
+          </DropdownMenu.Trigger>
+          <DropdownMenu.Portal>
+            <DropdownMenu.Content className={styles.content} sideOffset={5}>
+              <Dialog.Root>
+                <Dialog.Trigger className={styles.item} asChild>
+                  <DropdownMenu.Item onSelect={(event) => event.preventDefault()}>
+                    Open dialog
+                  </DropdownMenu.Item>
+                </Dialog.Trigger>
+
+                <Dialog.Portal>
+                  <Dialog.Content className={styles.dialog}>
+                    <Dialog.Title>Nested dropdown</Dialog.Title>
+                    <DropdownMenu.Root>
+                      <DropdownMenu.Trigger
+                        className={styles.trigger}
+                        style={{ width: '100%', marginBottom: 20 }}
+                      >
+                        Open
+                      </DropdownMenu.Trigger>
+                      <DropdownMenu.Portal>
+                        <DropdownMenu.Content className={styles.content} sideOffset={5}>
+                          <DropdownMenu.Item
+                            className={styles.item}
+                            onSelect={() => console.log('undo')}
+                          >
+                            Undo
+                          </DropdownMenu.Item>
+                          <DropdownMenu.Item
+                            className={styles.item}
+                            onSelect={() => console.log('redo')}
+                          >
+                            Redo
+                          </DropdownMenu.Item>
+                          <DropdownMenu.Arrow />
+                        </DropdownMenu.Content>
+                      </DropdownMenu.Portal>
+                    </DropdownMenu.Root>
+                    <Dialog.Close>Close</Dialog.Close>
+                  </Dialog.Content>
+                </Dialog.Portal>
+              </Dialog.Root>
+              <DropdownMenu.Item className={styles.item}>Test</DropdownMenu.Item>
+              <DropdownMenu.Arrow />
+            </DropdownMenu.Content>
+          </DropdownMenu.Portal>
+        </DropdownMenu.Root>
+
+        <Tooltip.Provider>
+          <Tooltip.Root>
+            <Tooltip.Trigger asChild>
+              <button>Tooltip test</button>
+            </Tooltip.Trigger>
+            <Tooltip.Content>Tooltip content</Tooltip.Content>
+          </Tooltip.Root>
+        </Tooltip.Provider>
+      </div>
+    </div>
+  );
+
+  return (
+    <div>
+      <button onClick={openContentInPopup} type="button">
+        Open in Popup
+      </button>
+      <mark>{count}</mark>
+
+      {portalElement
+        ? createPortal(
+            <DocumentContext.DocumentProvider document={portalElement.ownerDocument}>
+              {content}
+            </DocumentContext.DocumentProvider>,
+            portalElement
+          )
+        : content}
+    </div>
+  );
+};
diff --git a/apps/storybook/stories/dropdown-menu.stories.module.css b/apps/storybook/stories/dropdown-menu.stories.module.css
index 3b342bb2f..499d8692d 100644
--- a/apps/storybook/stories/dropdown-menu.stories.module.css
+++ b/apps/storybook/stories/dropdown-menu.stories.module.css
@@ -1,5 +1,5 @@
 .trigger {
-  border: 1px solid $black;
+  border: 1px solid black;
   border-radius: 6px;
   background-color: transparent;
   padding: 5px 10px;
diff --git a/apps/storybook/stories/hover-card.stories.tsx b/apps/storybook/stories/hover-card.stories.tsx
index f305925b5..811509db8 100644
--- a/apps/storybook/stories/hover-card.stories.tsx
+++ b/apps/storybook/stories/hover-card.stories.tsx
@@ -174,7 +174,7 @@ export const AsyncUpdate = () => {
 
   React.useEffect(() => {
     return () => {
-      clearTimeout(timerRef.current);
+      window.clearTimeout(timerRef.current);
     };
   }, []);
 
diff --git a/packages/react/alert-dialog/package.json b/packages/react/alert-dialog/package.json
index bdec19838..263467fab 100644
--- a/packages/react/alert-dialog/package.json
+++ b/packages/react/alert-dialog/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-dialog": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-slot": "workspace:*"
   },
diff --git a/packages/react/alert-dialog/src/alert-dialog.tsx b/packages/react/alert-dialog/src/alert-dialog.tsx
index 866a3f4a7..503466b78 100644
--- a/packages/react/alert-dialog/src/alert-dialog.tsx
+++ b/packages/react/alert-dialog/src/alert-dialog.tsx
@@ -7,6 +7,7 @@ import { composeEventHandlers } from '@radix-ui/primitive';
 import { createSlottable } from '@radix-ui/react-slot';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * AlertDialog
@@ -244,6 +245,7 @@ type DescriptionWarningProps = {
 };
 
 const DescriptionWarning: React.FC<DescriptionWarningProps> = ({ contentRef }) => {
+  const providedDocument = useDocument();
   const MESSAGE = `\`${CONTENT_NAME}\` requires a description for the component to be accessible for screen reader users.
 
 You can add a description to the \`${CONTENT_NAME}\` by passing a \`${DESCRIPTION_NAME}\` component as a child, which also benefits sighted users by adding visible context to the dialog.
@@ -253,11 +255,12 @@ Alternatively, you can use your own component as a description by assigning it a
 For more information, see https://radix-ui.com/primitives/docs/components/alert-dialog`;
 
   React.useEffect(() => {
-    const hasDescription = document.getElementById(
+    if (!providedDocument) return;
+    const hasDescription = providedDocument.getElementById(
       contentRef.current?.getAttribute('aria-describedby')!
     );
     if (!hasDescription) console.warn(MESSAGE);
-  }, [MESSAGE, contentRef]);
+  }, [MESSAGE, contentRef, providedDocument]);
 
   return null;
 };
diff --git a/packages/react/avatar/package.json b/packages/react/avatar/package.json
index 240c46013..78f4c310e 100644
--- a/packages/react/avatar/package.json
+++ b/packages/react/avatar/package.json
@@ -35,6 +35,7 @@
   },
   "dependencies": {
     "@radix-ui/react-context": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*",
     "@radix-ui/react-use-is-hydrated": "workspace:*",
diff --git a/packages/react/avatar/src/avatar.tsx b/packages/react/avatar/src/avatar.tsx
index c57505320..d339cdf97 100644
--- a/packages/react/avatar/src/avatar.tsx
+++ b/packages/react/avatar/src/avatar.tsx
@@ -6,6 +6,7 @@ import { Primitive } from '@radix-ui/react-primitive';
 import { useIsHydrated } from '@radix-ui/react-use-is-hydrated';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * Avatar
@@ -99,11 +100,10 @@ const AvatarFallback = React.forwardRef<AvatarFallbackElement, AvatarFallbackPro
     const { __scopeAvatar, delayMs, ...fallbackProps } = props;
     const context = useAvatarContext(FALLBACK_NAME, __scopeAvatar);
     const [canRender, setCanRender] = React.useState(delayMs === undefined);
-
     React.useEffect(() => {
       if (delayMs !== undefined) {
-        const timerId = window.setTimeout(() => setCanRender(true), delayMs);
-        return () => window.clearTimeout(timerId);
+        const timerId = globalThis.window.setTimeout(() => setCanRender(true), delayMs);
+        return () => globalThis.window.clearTimeout(timerId);
       }
     }, [delayMs]);
 
@@ -136,10 +136,12 @@ function useImageLoadingStatus(
 ) {
   const isHydrated = useIsHydrated();
   const imageRef = React.useRef<HTMLImageElement | null>(null);
+  const providedDocument = useDocument();
+  const documentWindow = providedDocument?.defaultView;
   const image = (() => {
     if (!isHydrated) return null;
     if (!imageRef.current) {
-      imageRef.current = new window.Image();
+      imageRef.current = new (documentWindow ?? globalThis.window).Image();
     }
     return imageRef.current;
   })();
diff --git a/packages/react/context-menu/src/context-menu.tsx b/packages/react/context-menu/src/context-menu.tsx
index 55d6241b6..e7f1093e6 100644
--- a/packages/react/context-menu/src/context-menu.tsx
+++ b/packages/react/context-menu/src/context-menu.tsx
@@ -6,7 +6,6 @@ import * as MenuPrimitive from '@radix-ui/react-menu';
 import { createMenuScope } from '@radix-ui/react-menu';
 import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
 import { useControllableState } from '@radix-ui/react-use-controllable-state';
-
 import type { Scope } from '@radix-ui/react-context';
 
 type Direction = 'ltr' | 'rtl';
@@ -97,9 +96,10 @@ const ContextMenuTrigger = React.forwardRef<ContextMenuTriggerElement, ContextMe
     const virtualRef = React.useRef({
       getBoundingClientRect: () => DOMRect.fromRect({ width: 0, height: 0, ...pointRef.current }),
     });
+
     const longPressTimerRef = React.useRef(0);
     const clearLongPress = React.useCallback(
-      () => window.clearTimeout(longPressTimerRef.current),
+      () => globalThis.window.clearTimeout(longPressTimerRef.current),
       []
     );
     const handleOpen = (event: React.MouseEvent | React.PointerEvent) => {
@@ -140,7 +140,10 @@ const ContextMenuTrigger = React.forwardRef<ContextMenuTriggerElement, ContextMe
                   whenTouchOrPen((event) => {
                     // clear the long press here in case there's multiple touch points
                     clearLongPress();
-                    longPressTimerRef.current = window.setTimeout(() => handleOpen(event), 700);
+                    longPressTimerRef.current = globalThis.window.setTimeout(
+                      () => handleOpen(event),
+                      700
+                    );
                   })
                 )
           }
diff --git a/packages/react/dialog/package.json b/packages/react/dialog/package.json
index 2f2cd889b..63a39ee7d 100644
--- a/packages/react/dialog/package.json
+++ b/packages/react/dialog/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-focus-guards": "workspace:*",
     "@radix-ui/react-focus-scope": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
diff --git a/packages/react/dialog/src/dialog.tsx b/packages/react/dialog/src/dialog.tsx
index a1ca70d73..f2a2f577c 100644
--- a/packages/react/dialog/src/dialog.tsx
+++ b/packages/react/dialog/src/dialog.tsx
@@ -15,6 +15,7 @@ import { hideOthers } from 'aria-hidden';
 import { createSlot } from '@radix-ui/react-slot';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * Dialog
@@ -506,6 +507,7 @@ const [WarningProvider, useWarningContext] = createContext(TITLE_WARNING_NAME, {
 type TitleWarningProps = { titleId?: string };
 
 const TitleWarning: React.FC<TitleWarningProps> = ({ titleId }) => {
+  const providedDocument = useDocument();
   const titleWarningContext = useWarningContext(TITLE_WARNING_NAME);
 
   const MESSAGE = `\`${titleWarningContext.contentName}\` requires a \`${titleWarningContext.titleName}\` for the component to be accessible for screen reader users.
@@ -515,11 +517,12 @@ If you want to hide the \`${titleWarningContext.titleName}\`, you can wrap it wi
 For more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`;
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     if (titleId) {
-      const hasTitle = document.getElementById(titleId);
+      const hasTitle = providedDocument.getElementById(titleId);
       if (!hasTitle) console.error(MESSAGE);
     }
-  }, [MESSAGE, titleId]);
+  }, [MESSAGE, titleId, providedDocument]);
 
   return null;
 };
@@ -532,17 +535,19 @@ type DescriptionWarningProps = {
 };
 
 const DescriptionWarning: React.FC<DescriptionWarningProps> = ({ contentRef, descriptionId }) => {
+  const providedDocument = useDocument();
   const descriptionWarningContext = useWarningContext(DESCRIPTION_WARNING_NAME);
   const MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${descriptionWarningContext.contentName}}.`;
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     const describedById = contentRef.current?.getAttribute('aria-describedby');
     // if we have an id and the user hasn't set aria-describedby={undefined}
     if (descriptionId && describedById) {
-      const hasDescription = document.getElementById(descriptionId);
+      const hasDescription = providedDocument.getElementById(descriptionId);
       if (!hasDescription) console.warn(MESSAGE);
     }
-  }, [MESSAGE, contentRef, descriptionId]);
+  }, [MESSAGE, contentRef, descriptionId, providedDocument]);
 
   return null;
 };
diff --git a/packages/react/dismissable-layer/package.json b/packages/react/dismissable-layer/package.json
index b7d8abdc5..6bf89f847 100644
--- a/packages/react/dismissable-layer/package.json
+++ b/packages/react/dismissable-layer/package.json
@@ -36,6 +36,7 @@
   "dependencies": {
     "@radix-ui/primitive": "workspace:*",
     "@radix-ui/react-compose-refs": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*",
     "@radix-ui/react-use-escape-keydown": "workspace:*"
diff --git a/packages/react/dismissable-layer/src/dismissable-layer.tsx b/packages/react/dismissable-layer/src/dismissable-layer.tsx
index d1219af47..b87f62771 100644
--- a/packages/react/dismissable-layer/src/dismissable-layer.tsx
+++ b/packages/react/dismissable-layer/src/dismissable-layer.tsx
@@ -4,6 +4,7 @@ import { Primitive, dispatchDiscreteCustomEvent } from '@radix-ui/react-primitiv
 import { useComposedRefs } from '@radix-ui/react-compose-refs';
 import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
 import { useEscapeKeydown } from '@radix-ui/react-use-escape-keydown';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * DismissableLayer
@@ -71,7 +72,7 @@ const DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLa
     } = props;
     const context = React.useContext(DismissableLayerContext);
     const [node, setNode] = React.useState<DismissableLayerElement | null>(null);
-    const ownerDocument = node?.ownerDocument ?? globalThis?.document;
+    const providedDocument = useDocument();
     const [, force] = React.useState({});
     const composedRefs = useComposedRefs(forwardedRef, (node) => setNode(node));
     const layers = Array.from(context.layers);
@@ -88,7 +89,7 @@ const DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLa
       onPointerDownOutside?.(event);
       onInteractOutside?.(event);
       if (!event.defaultPrevented) onDismiss?.();
-    }, ownerDocument);
+    });
 
     const focusOutside = useFocusOutside((event) => {
       const target = event.target as HTMLElement;
@@ -97,7 +98,7 @@ const DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLa
       onFocusOutside?.(event);
       onInteractOutside?.(event);
       if (!event.defaultPrevented) onDismiss?.();
-    }, ownerDocument);
+    });
 
     useEscapeKeydown((event) => {
       const isHighestLayer = index === context.layers.size - 1;
@@ -107,28 +108,28 @@ const DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLa
         event.preventDefault();
         onDismiss();
       }
-    }, ownerDocument);
+    });
 
     React.useEffect(() => {
-      if (!node) return;
+      if (!node || !providedDocument) return;
       if (disableOutsidePointerEvents) {
         if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
-          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
-          ownerDocument.body.style.pointerEvents = 'none';
+          originalBodyPointerEvents = providedDocument.body.style.pointerEvents;
+          providedDocument.body.style.pointerEvents = 'none';
         }
         context.layersWithOutsidePointerEventsDisabled.add(node);
       }
       context.layers.add(node);
-      dispatchUpdate();
+      dispatchUpdate(providedDocument);
       return () => {
         if (
           disableOutsidePointerEvents &&
           context.layersWithOutsidePointerEventsDisabled.size === 1
         ) {
-          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+          providedDocument.body.style.pointerEvents = originalBodyPointerEvents;
         }
       };
-    }, [node, ownerDocument, disableOutsidePointerEvents, context]);
+    }, [node, providedDocument, disableOutsidePointerEvents, context]);
 
     /**
      * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect
@@ -138,18 +139,19 @@ const DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLa
      */
     React.useEffect(() => {
       return () => {
-        if (!node) return;
+        if (!node || !providedDocument) return;
         context.layers.delete(node);
         context.layersWithOutsidePointerEventsDisabled.delete(node);
-        dispatchUpdate();
+        dispatchUpdate(providedDocument);
       };
-    }, [node, context]);
+    }, [node, context, providedDocument]);
 
     React.useEffect(() => {
+      if (!providedDocument) return;
       const handleUpdate = () => force({});
-      document.addEventListener(CONTEXT_UPDATE, handleUpdate);
-      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
-    }, []);
+      providedDocument.addEventListener(CONTEXT_UPDATE, handleUpdate);
+      return () => providedDocument.removeEventListener(CONTEXT_UPDATE, handleUpdate);
+    }, [providedDocument]);
 
     return (
       <Primitive.div
@@ -218,15 +220,17 @@ type FocusOutsideEvent = CustomEvent<{ originalEvent: FocusEvent }>;
  * to mimic layer dismissing behaviour present in OS.
  * Returns props to pass to the node we want to check for outside events.
  */
-function usePointerDownOutside(
-  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void,
-  ownerDocument: Document = globalThis?.document
-) {
-  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside) as EventListener;
+function usePointerDownOutside(onPointerDownOutside?: (event: PointerDownOutsideEvent) => void) {
+  const providedDocument = useDocument();
+  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
   const isPointerInsideReactTreeRef = React.useRef(false);
   const handleClickRef = React.useRef(() => {});
 
   React.useEffect(() => {
+    // Only add listeners if document exists
+    const documentWindow = providedDocument?.defaultView;
+    if (!documentWindow) return;
+
     const handlePointerDown = (event: PointerEvent) => {
       if (event.target && !isPointerInsideReactTreeRef.current) {
         const eventDetail = { originalEvent: event };
@@ -253,41 +257,42 @@ function usePointerDownOutside(
          * certain that it was raised, and therefore cleaned-up.
          */
         if (event.pointerType === 'touch') {
-          ownerDocument.removeEventListener('click', handleClickRef.current);
+          providedDocument.removeEventListener('click', handleClickRef.current);
           handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;
-          ownerDocument.addEventListener('click', handleClickRef.current, { once: true });
+          providedDocument.addEventListener('click', handleClickRef.current, { once: true });
         } else {
           handleAndDispatchPointerDownOutsideEvent();
         }
       } else {
         // We need to remove the event listener in case the outside click has been canceled.
         // See: https://github.com/radix-ui/primitives/issues/2171
-        ownerDocument.removeEventListener('click', handleClickRef.current);
+        providedDocument.removeEventListener('click', handleClickRef.current);
       }
       isPointerInsideReactTreeRef.current = false;
     };
     /**
      * if this hook executes in a component that mounts via a `pointerdown` event, the event
-     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid
-     * this by delaying the event listener registration on the document.
+     * would bubble up to the providedDocument and trigger a `pointerDownOutside` event. We avoid
+     * this by delaying the event listener registration on the providedDocument.
      * This is not React specific, but rather how the DOM works, ie:
      * ```
      * button.addEventListener('pointerdown', () => {
      *   console.log('I will log');
-     *   document.addEventListener('pointerdown', () => {
+     *   providedDocument.addEventListener('pointerdown', () => {
      *     console.log('I will also log');
      *   })
      * });
      */
-    const timerId = window.setTimeout(() => {
-      ownerDocument.addEventListener('pointerdown', handlePointerDown);
+    const timerId = globalThis.window.setTimeout(() => {
+      providedDocument.addEventListener('pointerdown', handlePointerDown);
     }, 0);
+
     return () => {
-      window.clearTimeout(timerId);
-      ownerDocument.removeEventListener('pointerdown', handlePointerDown);
-      ownerDocument.removeEventListener('click', handleClickRef.current);
+      globalThis.window.clearTimeout(timerId);
+      providedDocument?.removeEventListener('pointerdown', handlePointerDown);
+      providedDocument?.removeEventListener('click', handleClickRef.current);
     };
-  }, [ownerDocument, handlePointerDownOutside]);
+  }, [providedDocument, handlePointerDownOutside]);
 
   return {
     // ensures we check React component tree (not just DOM tree)
@@ -299,14 +304,13 @@ function usePointerDownOutside(
  * Listens for when focus happens outside a react subtree.
  * Returns props to pass to the root (node) of the subtree we want to check.
  */
-function useFocusOutside(
-  onFocusOutside?: (event: FocusOutsideEvent) => void,
-  ownerDocument: Document = globalThis?.document
-) {
+function useFocusOutside(onFocusOutside?: (event: FocusOutsideEvent) => void) {
+  const providedDocument = useDocument();
   const handleFocusOutside = useCallbackRef(onFocusOutside) as EventListener;
   const isFocusInsideReactTreeRef = React.useRef(false);
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     const handleFocus = (event: FocusEvent) => {
       if (event.target && !isFocusInsideReactTreeRef.current) {
         const eventDetail = { originalEvent: event };
@@ -315,9 +319,9 @@ function useFocusOutside(
         });
       }
     };
-    ownerDocument.addEventListener('focusin', handleFocus);
-    return () => ownerDocument.removeEventListener('focusin', handleFocus);
-  }, [ownerDocument, handleFocusOutside]);
+    providedDocument.addEventListener('focusin', handleFocus);
+    return () => providedDocument.removeEventListener('focusin', handleFocus);
+  }, [providedDocument, handleFocusOutside]);
 
   return {
     onFocusCapture: () => (isFocusInsideReactTreeRef.current = true),
@@ -325,9 +329,9 @@ function useFocusOutside(
   };
 }
 
-function dispatchUpdate() {
+function dispatchUpdate(providedDocument: Document) {
   const event = new CustomEvent(CONTEXT_UPDATE);
-  document.dispatchEvent(event);
+  providedDocument.dispatchEvent(event);
 }
 
 function handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(
diff --git a/packages/react/document-context/README.md b/packages/react/document-context/README.md
new file mode 100644
index 000000000..90d869774
--- /dev/null
+++ b/packages/react/document-context/README.md
@@ -0,0 +1,5 @@
+# `react-document-context`
+
+## Usage
+
+This is an internal utility, not intended for public usage.
diff --git a/packages/react/document-context/eslint.config.mjs b/packages/react/document-context/eslint.config.mjs
new file mode 100644
index 000000000..26d682564
--- /dev/null
+++ b/packages/react/document-context/eslint.config.mjs
@@ -0,0 +1,4 @@
+// @ts-check
+import { configs } from '@repo/eslint-config/react-package';
+
+export default configs;
diff --git a/packages/react/document-context/package.json b/packages/react/document-context/package.json
new file mode 100644
index 000000000..2585d58f4
--- /dev/null
+++ b/packages/react/document-context/package.json
@@ -0,0 +1,73 @@
+{
+  "name": "@radix-ui/react-document-context",
+  "version": "0.0.0",
+  "license": "MIT",
+  "source": "./src/index.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "publishConfig": {
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "import": {
+          "types": "./dist/index.d.mts",
+          "default": "./dist/index.mjs"
+        },
+        "require": {
+          "types": "./dist/index.d.ts",
+          "default": "./dist/index.js"
+        }
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "lint": "eslint --max-warnings 0 src",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "build": "radix-build"
+  },
+  "dependencies": {
+    "@radix-ui/react-use-is-hydrated": "workspace:*"
+  },
+  "devDependencies": {
+    "@repo/builder": "workspace:*",
+    "@repo/eslint-config": "workspace:*",
+    "@repo/test-data": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/react": "^19.0.7",
+    "@types/react-dom": "^19.0.3",
+    "eslint": "^9.18.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "@types/react-dom": "*",
+    "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+    "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "@types/react-dom": {
+      "optional": true
+    }
+  },
+  "homepage": "https://radix-ui.com/primitives",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/radix-ui/primitives.git"
+  },
+  "bugs": {
+    "url": "https://github.com/radix-ui/primitives/issues"
+  }
+}
diff --git a/packages/react/document-context/src/document-context.test.tsx b/packages/react/document-context/src/document-context.test.tsx
new file mode 100644
index 000000000..3dcf805f3
--- /dev/null
+++ b/packages/react/document-context/src/document-context.test.tsx
@@ -0,0 +1,69 @@
+import { render, screen } from '@testing-library/react';
+import { DocumentProvider, useDocument } from './document-context';
+import { describe, it, expect } from 'vitest';
+
+// Test component that uses the document context
+function TestComponent() {
+  const doc = useDocument();
+  return <div>Has document: {doc ? 'true' : 'false'}</div>;
+}
+
+describe('DocumentContext', () => {
+  it('provides custom document when specified', () => {
+    const mockDocument = {} as Document;
+
+    function TestDocumentConsumer() {
+      const doc = useDocument();
+      return <div>{doc === mockDocument ? 'custom document' : 'default document'}</div>;
+    }
+
+    render(
+      <DocumentProvider document={mockDocument}>
+        <TestDocumentConsumer />
+      </DocumentProvider>
+    );
+
+    expect(screen.getByText('custom document')).toBeInTheDocument();
+  });
+
+  it('can be nested with different documents', () => {
+    const mockDocument1 = { id: 1 } as unknown as Document;
+    const mockDocument2 = { id: 2 } as unknown as Document;
+
+    function TestDocumentConsumer() {
+      const doc = useDocument();
+      return <div>Document ID: {(doc as any).id}</div>;
+    }
+
+    render(
+      <DocumentProvider document={mockDocument1}>
+        <div>
+          <TestDocumentConsumer />
+          <DocumentProvider document={mockDocument2}>
+            <TestDocumentConsumer />
+          </DocumentProvider>
+        </div>
+      </DocumentProvider>
+    );
+
+    expect(screen.getByText('Document ID: 1')).toBeInTheDocument();
+    expect(screen.getByText('Document ID: 2')).toBeInTheDocument();
+  });
+
+  it('useDocument returns global document when no value is passed to provider', () => {
+    function TestDocumentConsumer() {
+      const doc = useDocument();
+      return <div>{doc === globalThis.document ? 'global document' : 'other document'}</div>;
+    }
+
+    render(<TestDocumentConsumer />);
+
+    expect(screen.getByText('global document')).toBeInTheDocument();
+  });
+
+  it('useDocument returns default document when custom document is not provided', () => {
+    render(<TestComponent />);
+
+    expect(screen.getByText('Has document: true')).toBeInTheDocument();
+  });
+});
diff --git a/packages/react/document-context/src/document-context.tsx b/packages/react/document-context/src/document-context.tsx
new file mode 100644
index 000000000..5040d031d
--- /dev/null
+++ b/packages/react/document-context/src/document-context.tsx
@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { useIsHydrated } from '@radix-ui/react-use-is-hydrated';
+
+// Use null as initial value to handle SSR safely
+const DocumentContext = React.createContext<Document | null>(null);
+DocumentContext.displayName = 'DocumentContext';
+
+interface DocumentProviderProps {
+  document: Document | null;
+  children: React.ReactNode;
+}
+
+export function DocumentProvider({ document, children }: DocumentProviderProps) {
+  return <DocumentContext.Provider value={document}>{children}</DocumentContext.Provider>;
+}
+
+export function useDocument() {
+  const document = React.useContext(DocumentContext);
+  const isHydrated = useIsHydrated();
+  return document ?? (isHydrated ? globalThis.document : null);
+}
diff --git a/packages/react/document-context/src/index.ts b/packages/react/document-context/src/index.ts
new file mode 100644
index 000000000..e43b4eb68
--- /dev/null
+++ b/packages/react/document-context/src/index.ts
@@ -0,0 +1,2 @@
+'use client';
+export { DocumentProvider, useDocument } from './document-context';
diff --git a/packages/react/document-context/tsconfig.json b/packages/react/document-context/tsconfig.json
new file mode 100644
index 000000000..ecf7f7008
--- /dev/null
+++ b/packages/react/document-context/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "extends": "@repo/typescript-config/react-library.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "types": ["@repo/typescript-config/react-library"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/react/focus-guards/package.json b/packages/react/focus-guards/package.json
index 863d474f8..6ac68a370 100644
--- a/packages/react/focus-guards/package.json
+++ b/packages/react/focus-guards/package.json
@@ -33,6 +33,9 @@
     "typecheck": "tsc --noEmit",
     "build": "radix-build"
   },
+  "dependencies": {
+    "@radix-ui/react-document-context": "workspace:*"
+  },
   "devDependencies": {
     "@repo/builder": "workspace:*",
     "@repo/eslint-config": "workspace:*",
diff --git a/packages/react/focus-guards/src/focus-guards.tsx b/packages/react/focus-guards/src/focus-guards.tsx
index b277138b6..cf87a486e 100644
--- a/packages/react/focus-guards/src/focus-guards.tsx
+++ b/packages/react/focus-guards/src/focus-guards.tsx
@@ -1,3 +1,4 @@
+import { useDocument } from '@radix-ui/react-document-context';
 import * as React from 'react';
 
 /** Number of components which have requested interest to have focus guards */
@@ -13,23 +14,33 @@ function FocusGuards(props: any) {
  * to ensure `focusin` & `focusout` events can be caught consistently.
  */
 function useFocusGuards() {
+  const providedDocument = useDocument();
   React.useEffect(() => {
-    const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');
-    document.body.insertAdjacentElement('afterbegin', edgeGuards[0] ?? createFocusGuard());
-    document.body.insertAdjacentElement('beforeend', edgeGuards[1] ?? createFocusGuard());
+    if (!providedDocument) return;
+    const edgeGuards = providedDocument.querySelectorAll('[data-radix-focus-guard]');
+    providedDocument.body.insertAdjacentElement(
+      'afterbegin',
+      edgeGuards[0] ?? createFocusGuard(providedDocument)
+    );
+    providedDocument.body.insertAdjacentElement(
+      'beforeend',
+      edgeGuards[1] ?? createFocusGuard(providedDocument)
+    );
     count++;
 
     return () => {
       if (count === 1) {
-        document.querySelectorAll('[data-radix-focus-guard]').forEach((node) => node.remove());
+        providedDocument
+          .querySelectorAll('[data-radix-focus-guard]')
+          .forEach((node) => node.remove());
       }
       count--;
     };
-  }, []);
+  }, [providedDocument]);
 }
 
-function createFocusGuard() {
-  const element = document.createElement('span');
+function createFocusGuard(providedDocument: Document) {
+  const element = providedDocument.createElement('span');
   element.setAttribute('data-radix-focus-guard', '');
   element.tabIndex = 0;
   element.style.outline = 'none';
diff --git a/packages/react/focus-scope/package.json b/packages/react/focus-scope/package.json
index a19ba1053..649a26b75 100644
--- a/packages/react/focus-scope/package.json
+++ b/packages/react/focus-scope/package.json
@@ -35,6 +35,7 @@
   },
   "dependencies": {
     "@radix-ui/react-compose-refs": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*"
   },
diff --git a/packages/react/focus-scope/src/focus-scope.tsx b/packages/react/focus-scope/src/focus-scope.tsx
index bda929941..54e10b5d8 100644
--- a/packages/react/focus-scope/src/focus-scope.tsx
+++ b/packages/react/focus-scope/src/focus-scope.tsx
@@ -2,6 +2,7 @@ import * as React from 'react';
 import { useComposedRefs } from '@radix-ui/react-compose-refs';
 import { Primitive } from '@radix-ui/react-primitive';
 import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
+import { useDocument } from '@radix-ui/react-document-context';
 
 const AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount';
 const AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount';
@@ -58,6 +59,7 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
   const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
   const lastFocusedElementRef = React.useRef<HTMLElement | null>(null);
   const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));
+  const providedDocument = useDocument();
 
   const focusScope = React.useRef({
     paused: false,
@@ -71,14 +73,15 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
 
   // Takes care of trapping focus if focus is moved outside programmatically for example
   React.useEffect(() => {
+    if (!providedDocument) return;
     if (trapped) {
       function handleFocusIn(event: FocusEvent) {
         if (focusScope.paused || !container) return;
         const target = event.target as HTMLElement | null;
         if (container.contains(target)) {
           lastFocusedElementRef.current = target;
-        } else {
-          focus(lastFocusedElementRef.current, { select: true });
+        } else if (lastFocusedElementRef.current && providedDocument) {
+          focus(lastFocusedElementRef.current, providedDocument, { select: true });
         }
       }
 
@@ -100,8 +103,12 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
 
         // If the focus has moved to an actual legitimate element (`relatedTarget !== null`)
         // that is outside the container, we move focus to the last valid focused element inside.
-        if (!container.contains(relatedTarget)) {
-          focus(lastFocusedElementRef.current, { select: true });
+        if (
+          !container.contains(relatedTarget) &&
+          lastFocusedElementRef.current &&
+          providedDocument
+        ) {
+          focus(lastFocusedElementRef.current, providedDocument, { select: true });
         }
       }
 
@@ -109,30 +116,32 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
       // back to the document.body. In this case, we move focus to the container
       // to keep focus trapped correctly.
       function handleMutations(mutations: MutationRecord[]) {
-        const focusedElement = document.activeElement as HTMLElement | null;
-        if (focusedElement !== document.body) return;
+        if (!providedDocument) return;
+        const focusedElement = providedDocument.activeElement as HTMLElement | null;
+        if (focusedElement !== providedDocument.body) return;
         for (const mutation of mutations) {
-          if (mutation.removedNodes.length > 0) focus(container);
+          if (container && providedDocument && mutation.removedNodes.length > 0)
+            focus(container, providedDocument);
         }
       }
 
-      document.addEventListener('focusin', handleFocusIn);
-      document.addEventListener('focusout', handleFocusOut);
+      providedDocument.addEventListener('focusin', handleFocusIn);
+      providedDocument.addEventListener('focusout', handleFocusOut);
       const mutationObserver = new MutationObserver(handleMutations);
       if (container) mutationObserver.observe(container, { childList: true, subtree: true });
 
       return () => {
-        document.removeEventListener('focusin', handleFocusIn);
-        document.removeEventListener('focusout', handleFocusOut);
+        providedDocument.removeEventListener('focusin', handleFocusIn);
+        providedDocument.removeEventListener('focusout', handleFocusOut);
         mutationObserver.disconnect();
       };
     }
-  }, [trapped, container, focusScope.paused]);
+  }, [trapped, container, focusScope.paused, providedDocument]);
 
   React.useEffect(() => {
-    if (container) {
+    if (container && providedDocument) {
       focusScopesStack.add(focusScope);
-      const previouslyFocusedElement = document.activeElement as HTMLElement | null;
+      const previouslyFocusedElement = providedDocument?.activeElement as HTMLElement | null;
       const hasFocusedCandidate = container.contains(previouslyFocusedElement);
 
       if (!hasFocusedCandidate) {
@@ -140,9 +149,13 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
         container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
         container.dispatchEvent(mountEvent);
         if (!mountEvent.defaultPrevented) {
-          focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
-          if (document.activeElement === previouslyFocusedElement) {
-            focus(container);
+          focusFirst(
+            removeLinks(getTabbableCandidates(container, providedDocument)),
+            { select: true },
+            providedDocument
+          );
+          if (providedDocument?.activeElement === previouslyFocusedElement) {
+            focus(container, providedDocument);
           }
         }
       }
@@ -153,12 +166,14 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
         // We hit a react bug (fixed in v17) with focusing in unmount.
         // We need to delay the focus a little to get around it for now.
         // See: https://github.com/facebook/react/issues/17894
-        setTimeout(() => {
+        globalThis.window.setTimeout(() => {
           const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
           container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
           container.dispatchEvent(unmountEvent);
           if (!unmountEvent.defaultPrevented) {
-            focus(previouslyFocusedElement ?? document.body, { select: true });
+            focus(previouslyFocusedElement ?? providedDocument?.body, providedDocument, {
+              select: true,
+            });
           }
           // we need to remove the listener after we `dispatchEvent`
           container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
@@ -167,7 +182,7 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
         }, 0);
       };
     }
-  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
+  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope, providedDocument]);
 
   // Takes care of looping focus (when tabbing whilst at the edges)
   const handleKeyDown = React.useCallback(
@@ -176,11 +191,11 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
       if (focusScope.paused) return;
 
       const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;
-      const focusedElement = document.activeElement as HTMLElement | null;
+      const focusedElement = providedDocument?.activeElement as HTMLElement | null;
 
-      if (isTabKey && focusedElement) {
+      if (isTabKey && focusedElement && providedDocument) {
         const container = event.currentTarget as HTMLElement;
-        const [first, last] = getTabbableEdges(container);
+        const [first, last] = getTabbableEdges(container, providedDocument);
         const hasTabbableElementsInside = first && last;
 
         // we can only wrap focus if we have tabbable edges
@@ -189,15 +204,15 @@ const FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props,
         } else {
           if (!event.shiftKey && focusedElement === last) {
             event.preventDefault();
-            if (loop) focus(first, { select: true });
+            if (loop) focus(first, providedDocument, { select: true });
           } else if (event.shiftKey && focusedElement === first) {
             event.preventDefault();
-            if (loop) focus(last, { select: true });
+            if (loop) focus(last, providedDocument, { select: true });
           }
         }
       }
     },
-    [loop, trapped, focusScope.paused]
+    [loop, trapped, focusScope.paused, providedDocument]
   );
 
   return (
@@ -215,19 +230,24 @@ FocusScope.displayName = FOCUS_SCOPE_NAME;
  * Attempts focusing the first element in a list of candidates.
  * Stops when focus has actually moved.
  */
-function focusFirst(candidates: HTMLElement[], { select = false } = {}) {
-  const previouslyFocusedElement = document.activeElement;
+function focusFirst(
+  candidates: HTMLElement[],
+  { select = false } = {},
+  providedDocument: Document | null
+) {
+  if (!providedDocument) return;
+  const previouslyFocusedElement = providedDocument?.activeElement;
   for (const candidate of candidates) {
-    focus(candidate, { select });
-    if (document.activeElement !== previouslyFocusedElement) return;
+    focus(candidate, providedDocument, { select });
+    if (providedDocument?.activeElement !== previouslyFocusedElement) return;
   }
 }
 
 /**
  * Returns the first and last tabbable elements inside a container.
  */
-function getTabbableEdges(container: HTMLElement) {
-  const candidates = getTabbableCandidates(container);
+function getTabbableEdges(container: HTMLElement, providedDocument: Document) {
+  const candidates = getTabbableCandidates(container, providedDocument);
   const first = findVisible(candidates, container);
   const last = findVisible(candidates.reverse(), container);
   return [first, last] as const;
@@ -243,9 +263,9 @@ function getTabbableEdges(container: HTMLElement) {
  * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
  * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
  */
-function getTabbableCandidates(container: HTMLElement) {
+function getTabbableCandidates(container: HTMLElement, providedDocument: Document) {
   const nodes: HTMLElement[] = [];
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+  const walker = providedDocument.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
     acceptNode: (node: any) => {
       const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
       if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
@@ -287,10 +307,10 @@ function isSelectableInput(element: any): element is FocusableTarget & { select:
   return element instanceof HTMLInputElement && 'select' in element;
 }
 
-function focus(element?: FocusableTarget | null, { select = false } = {}) {
+function focus(element: FocusableTarget, providedDocument: Document, { select = false } = {}) {
   // only focus if that element is focusable
-  if (element && element.focus) {
-    const previouslyFocusedElement = document.activeElement;
+  if (element && element.focus && providedDocument) {
+    const previouslyFocusedElement = providedDocument.activeElement;
     // NOTE: we prevent scrolling on focus, to minimize jarring transitions for users
     element.focus({ preventScroll: true });
     // only select if its not the same element, it supports selection and we need to select
diff --git a/packages/react/hover-card/package.json b/packages/react/hover-card/package.json
index 88f3de90a..5d5645ef5 100644
--- a/packages/react/hover-card/package.json
+++ b/packages/react/hover-card/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-popper": "workspace:*",
     "@radix-ui/react-portal": "workspace:*",
     "@radix-ui/react-presence": "workspace:*",
diff --git a/packages/react/hover-card/src/hover-card.tsx b/packages/react/hover-card/src/hover-card.tsx
index ff59e28c0..a1ad3399a 100644
--- a/packages/react/hover-card/src/hover-card.tsx
+++ b/packages/react/hover-card/src/hover-card.tsx
@@ -11,6 +11,7 @@ import { Primitive } from '@radix-ui/react-primitive';
 import { DismissableLayer } from '@radix-ui/react-dismissable-layer';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * HoverCard
@@ -72,14 +73,14 @@ const HoverCard: React.FC<HoverCardProps> = (props: ScopedProps<HoverCardProps>)
   });
 
   const handleOpen = React.useCallback(() => {
-    clearTimeout(closeTimerRef.current);
-    openTimerRef.current = window.setTimeout(() => setOpen(true), openDelay);
+    globalThis.window.clearTimeout(closeTimerRef.current);
+    openTimerRef.current = globalThis.window.setTimeout(() => setOpen(true), openDelay);
   }, [openDelay, setOpen]);
 
   const handleClose = React.useCallback(() => {
-    clearTimeout(openTimerRef.current);
+    globalThis.window.clearTimeout(openTimerRef.current);
     if (!hasSelectionRef.current && !isPointerDownOnContentRef.current) {
-      closeTimerRef.current = window.setTimeout(() => setOpen(false), closeDelay);
+      closeTimerRef.current = globalThis.window.setTimeout(() => setOpen(false), closeDelay);
     }
   }, [closeDelay, setOpen]);
 
@@ -88,8 +89,8 @@ const HoverCard: React.FC<HoverCardProps> = (props: ScopedProps<HoverCardProps>)
   // cleanup any queued state updates on unmount
   React.useEffect(() => {
     return () => {
-      clearTimeout(openTimerRef.current);
-      clearTimeout(closeTimerRef.current);
+      globalThis.window.clearTimeout(openTimerRef.current);
+      globalThis.window.clearTimeout(closeTimerRef.current);
     };
   }, []);
 
@@ -271,10 +272,12 @@ const HoverCardContentImpl = React.forwardRef<
   const ref = React.useRef<HoverCardContentImplElement>(null);
   const composedRefs = useComposedRefs(forwardedRef, ref);
   const [containSelection, setContainSelection] = React.useState(false);
+  const providedDocument = useDocument();
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     if (containSelection) {
-      const body = document.body;
+      const body = providedDocument.body;
 
       // Safari requires prefix
       originalBodyUserSelect = body.style.userSelect || body.style.webkitUserSelect;
@@ -286,36 +289,38 @@ const HoverCardContentImpl = React.forwardRef<
         body.style.webkitUserSelect = originalBodyUserSelect;
       };
     }
-  }, [containSelection]);
+  }, [containSelection, providedDocument]);
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     if (ref.current) {
       const handlePointerUp = () => {
         setContainSelection(false);
         context.isPointerDownOnContentRef.current = false;
 
         // Delay a frame to ensure we always access the latest selection
-        setTimeout(() => {
-          const hasSelection = document.getSelection()?.toString() !== '';
+        globalThis.window.setTimeout(() => {
+          const hasSelection = providedDocument.getSelection()?.toString() !== '';
           if (hasSelection) context.hasSelectionRef.current = true;
         });
       };
 
-      document.addEventListener('pointerup', handlePointerUp);
+      providedDocument.addEventListener('pointerup', handlePointerUp);
       return () => {
-        document.removeEventListener('pointerup', handlePointerUp);
+        providedDocument.removeEventListener('pointerup', handlePointerUp);
         context.hasSelectionRef.current = false;
         context.isPointerDownOnContentRef.current = false;
       };
     }
-  }, [context.isPointerDownOnContentRef, context.hasSelectionRef]);
+  }, [context.isPointerDownOnContentRef, context.hasSelectionRef, providedDocument]);
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     if (ref.current) {
-      const tabbables = getTabbableNodes(ref.current);
+      const tabbables = getTabbableNodes(ref.current, providedDocument);
       tabbables.forEach((tabbable) => tabbable.setAttribute('tabindex', '-1'));
     }
-  });
+  }, [providedDocument]);
 
   return (
     <DismissableLayer
@@ -391,9 +396,9 @@ function excludeTouch<E>(eventHandler: () => void) {
  * Returns a list of nodes that can be in the tab sequence.
  * @see: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
  */
-function getTabbableNodes(container: HTMLElement) {
+function getTabbableNodes(container: HTMLElement, providedDocument: Document) {
   const nodes: HTMLElement[] = [];
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+  const walker = providedDocument.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
     acceptNode: (node: any) => {
       // `.tabIndex` is not the same as the `tabindex` attribute. It works on the
       // runtime's understanding of tabbability, so this automatically accounts
diff --git a/packages/react/menu/package.json b/packages/react/menu/package.json
index e37f83771..a3c5c00da 100644
--- a/packages/react/menu/package.json
+++ b/packages/react/menu/package.json
@@ -40,6 +40,7 @@
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-focus-guards": "workspace:*",
     "@radix-ui/react-focus-scope": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
diff --git a/packages/react/menu/src/menu.tsx b/packages/react/menu/src/menu.tsx
index 72c233ec0..d2bb983fa 100644
--- a/packages/react/menu/src/menu.tsx
+++ b/packages/react/menu/src/menu.tsx
@@ -21,6 +21,7 @@ import { hideOthers } from 'aria-hidden';
 import { RemoveScroll } from 'react-remove-scroll';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type Direction = 'ltr' | 'rtl';
 
@@ -91,23 +92,31 @@ const Menu: React.FC<MenuProps> = (props: ScopedProps<MenuProps>) => {
   const isUsingKeyboardRef = React.useRef(false);
   const handleOpenChange = useCallbackRef(onOpenChange);
   const direction = useDirection(dir);
+  const providedDocument = useDocument();
 
   React.useEffect(() => {
+    if (!providedDocument) return;
     // Capture phase ensures we set the boolean before any side effects execute
     // in response to the key or pointer event as they might depend on this value.
     const handleKeyDown = () => {
       isUsingKeyboardRef.current = true;
-      document.addEventListener('pointerdown', handlePointer, { capture: true, once: true });
-      document.addEventListener('pointermove', handlePointer, { capture: true, once: true });
+      providedDocument.addEventListener('pointerdown', handlePointer, {
+        capture: true,
+        once: true,
+      });
+      providedDocument.addEventListener('pointermove', handlePointer, {
+        capture: true,
+        once: true,
+      });
     };
     const handlePointer = () => (isUsingKeyboardRef.current = false);
-    document.addEventListener('keydown', handleKeyDown, { capture: true });
+    providedDocument.addEventListener('keydown', handleKeyDown, { capture: true });
     return () => {
-      document.removeEventListener('keydown', handleKeyDown, { capture: true });
-      document.removeEventListener('pointerdown', handlePointer, { capture: true });
-      document.removeEventListener('pointermove', handlePointer, { capture: true });
+      providedDocument.removeEventListener('keydown', handleKeyDown, { capture: true });
+      providedDocument.removeEventListener('pointerdown', handlePointer, { capture: true });
+      providedDocument.removeEventListener('pointermove', handlePointer, { capture: true });
     };
-  }, []);
+  }, [providedDocument]);
 
   return (
     <PopperPrimitive.Root {...popperScope}>
@@ -388,7 +397,7 @@ const MenuContentImpl = React.forwardRef<MenuContentImplElement, MenuContentImpl
     const pointerGraceIntentRef = React.useRef<GraceIntent | null>(null);
     const pointerDirRef = React.useRef<Side>('right');
     const lastPointerXRef = React.useRef(0);
-
+    const providedDocument = useDocument();
     const ScrollLockWrapper = disableOutsideScroll ? RemoveScroll : React.Fragment;
     const scrollLockWrapperProps = disableOutsideScroll
       ? { as: Slot, allowPinchZoom: true }
@@ -397,7 +406,7 @@ const MenuContentImpl = React.forwardRef<MenuContentImplElement, MenuContentImpl
     const handleTypeaheadSearch = (key: string) => {
       const search = searchRef.current + key;
       const items = getItems().filter((item) => !item.disabled);
-      const currentItem = document.activeElement;
+      const currentItem = providedDocument?.activeElement;
       const currentMatch = items.find((item) => item.ref.current === currentItem)?.textValue;
       const values = items.map((item) => item.textValue);
       const nextMatch = getNextMatch(values, search, currentMatch);
@@ -406,8 +415,9 @@ const MenuContentImpl = React.forwardRef<MenuContentImplElement, MenuContentImpl
       // Reset `searchRef` 1 second after it was last updated
       (function updateSearch(value: string) {
         searchRef.current = value;
-        window.clearTimeout(timerRef.current);
-        if (value !== '') timerRef.current = window.setTimeout(() => updateSearch(''), 1000);
+        globalThis.window.clearTimeout(timerRef.current);
+        if (value !== '')
+          timerRef.current = globalThis.window.setTimeout(() => updateSearch(''), 1000);
       })(search);
 
       if (newItem) {
@@ -415,12 +425,12 @@ const MenuContentImpl = React.forwardRef<MenuContentImplElement, MenuContentImpl
          * Imperative focus during keydown is risky so we prevent React's batching updates
          * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
          */
-        setTimeout(() => (newItem as HTMLElement).focus());
+        globalThis.window.setTimeout(() => (newItem as HTMLElement).focus());
       }
     };
 
     React.useEffect(() => {
-      return () => window.clearTimeout(timerRef.current);
+      return () => globalThis.window.clearTimeout(timerRef.current);
     }, []);
 
     // Make sure the whole tree has focus guards as our `MenuContent` may be
@@ -526,12 +536,14 @@ const MenuContentImpl = React.forwardRef<MenuContentImplElement, MenuContentImpl
                     const items = getItems().filter((item) => !item.disabled);
                     const candidateNodes = items.map((item) => item.ref.current!);
                     if (LAST_KEYS.includes(event.key)) candidateNodes.reverse();
-                    focusFirst(candidateNodes);
+                    if (providedDocument) {
+                      focusFirst(candidateNodes, providedDocument);
+                    }
                   })}
                   onBlur={composeEventHandlers(props.onBlur, (event) => {
                     // clear search buffer when leaving the menu
                     if (!event.currentTarget.contains(event.target)) {
-                      window.clearTimeout(timerRef.current);
+                      globalThis.window.clearTimeout(timerRef.current);
                       searchRef.current = '';
                     }
                   })}
@@ -1027,9 +1039,8 @@ const MenuSubTrigger = React.forwardRef<MenuSubTriggerElement, MenuSubTriggerPro
     const openTimerRef = React.useRef<number | null>(null);
     const { pointerGraceTimerRef, onPointerGraceIntentChange } = contentContext;
     const scope = { __scopeMenu: props.__scopeMenu };
-
     const clearOpenTimer = React.useCallback(() => {
-      if (openTimerRef.current) window.clearTimeout(openTimerRef.current);
+      if (openTimerRef.current) globalThis.window.clearTimeout(openTimerRef.current);
       openTimerRef.current = null;
     }, []);
 
@@ -1038,7 +1049,7 @@ const MenuSubTrigger = React.forwardRef<MenuSubTriggerElement, MenuSubTriggerPro
     React.useEffect(() => {
       const pointerGraceTimer = pointerGraceTimerRef.current;
       return () => {
-        window.clearTimeout(pointerGraceTimer);
+        globalThis.window.clearTimeout(pointerGraceTimer);
         onPointerGraceIntentChange(null);
       };
     }, [pointerGraceTimerRef, onPointerGraceIntentChange]);
@@ -1073,7 +1084,7 @@ const MenuSubTrigger = React.forwardRef<MenuSubTriggerElement, MenuSubTriggerPro
               if (event.defaultPrevented) return;
               if (!props.disabled && !context.open && !openTimerRef.current) {
                 contentContext.onPointerGraceIntentChange(null);
-                openTimerRef.current = window.setTimeout(() => {
+                openTimerRef.current = globalThis.window.setTimeout(() => {
                   context.onOpenChange(true);
                   clearOpenTimer();
                 }, 100);
@@ -1107,8 +1118,8 @@ const MenuSubTrigger = React.forwardRef<MenuSubTriggerElement, MenuSubTriggerPro
                   side,
                 });
 
-                window.clearTimeout(pointerGraceTimerRef.current);
-                pointerGraceTimerRef.current = window.setTimeout(
+                globalThis.window.clearTimeout(pointerGraceTimerRef.current);
+                pointerGraceTimerRef.current = globalThis.window.setTimeout(
                   () => contentContext.onPointerGraceIntentChange(null),
                   300
                 );
@@ -1237,13 +1248,13 @@ function getCheckedState(checked: CheckedState) {
   return isIndeterminate(checked) ? 'indeterminate' : checked ? 'checked' : 'unchecked';
 }
 
-function focusFirst(candidates: HTMLElement[]) {
-  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+function focusFirst(candidates: HTMLElement[], providedDocument: Document) {
+  const PREVIOUSLY_FOCUSED_ELEMENT = providedDocument.activeElement;
   for (const candidate of candidates) {
     // if focus is already where we want to go, we don't want to keep going through the candidates
     if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
     candidate.focus();
-    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+    if (providedDocument.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
   }
 }
 
diff --git a/packages/react/navigation-menu/package.json b/packages/react/navigation-menu/package.json
index 99d4bb62b..658c44ba4 100644
--- a/packages/react/navigation-menu/package.json
+++ b/packages/react/navigation-menu/package.json
@@ -40,6 +40,7 @@
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
     "@radix-ui/react-presence": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
diff --git a/packages/react/navigation-menu/src/navigation-menu.tsx b/packages/react/navigation-menu/src/navigation-menu.tsx
index 0161512b1..bb5873b4f 100644
--- a/packages/react/navigation-menu/src/navigation-menu.tsx
+++ b/packages/react/navigation-menu/src/navigation-menu.tsx
@@ -16,6 +16,7 @@ import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
 import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type Orientation = 'vertical' | 'horizontal';
 type Direction = 'ltr' | 'rtl';
@@ -122,11 +123,11 @@ const NavigationMenu = React.forwardRef<NavigationMenuElement, NavigationMenuPro
         const hasSkipDelayDuration = skipDelayDuration > 0;
 
         if (isOpen) {
-          window.clearTimeout(skipDelayTimerRef.current);
+          globalThis.window.clearTimeout(skipDelayTimerRef.current);
           if (hasSkipDelayDuration) setIsOpenDelayed(false);
         } else {
-          window.clearTimeout(skipDelayTimerRef.current);
-          skipDelayTimerRef.current = window.setTimeout(
+          globalThis.window.clearTimeout(skipDelayTimerRef.current);
+          skipDelayTimerRef.current = globalThis.window.setTimeout(
             () => setIsOpenDelayed(true),
             skipDelayDuration
           );
@@ -139,13 +140,13 @@ const NavigationMenu = React.forwardRef<NavigationMenuElement, NavigationMenuPro
     });
 
     const startCloseTimer = React.useCallback(() => {
-      window.clearTimeout(closeTimerRef.current);
-      closeTimerRef.current = window.setTimeout(() => setValue(''), 150);
+      globalThis.window.clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = globalThis.window.setTimeout(() => setValue(''), 150);
     }, [setValue]);
 
     const handleOpen = React.useCallback(
       (itemValue: string) => {
-        window.clearTimeout(closeTimerRef.current);
+        globalThis.window.clearTimeout(closeTimerRef.current);
         setValue(itemValue);
       },
       [setValue]
@@ -157,10 +158,10 @@ const NavigationMenu = React.forwardRef<NavigationMenuElement, NavigationMenuPro
         if (isOpenItem) {
           // If the item is already open (e.g. we're transitioning from the content to the trigger)
           // then we want to clear the close timer immediately.
-          window.clearTimeout(closeTimerRef.current);
+          globalThis.window.clearTimeout(closeTimerRef.current);
         } else {
-          openTimerRef.current = window.setTimeout(() => {
-            window.clearTimeout(closeTimerRef.current);
+          openTimerRef.current = globalThis.window.setTimeout(() => {
+            globalThis.window.clearTimeout(closeTimerRef.current);
             setValue(itemValue);
           }, delayDuration);
         }
@@ -170,9 +171,9 @@ const NavigationMenu = React.forwardRef<NavigationMenuElement, NavigationMenuPro
 
     React.useEffect(() => {
       return () => {
-        window.clearTimeout(openTimerRef.current);
-        window.clearTimeout(closeTimerRef.current);
-        window.clearTimeout(skipDelayTimerRef.current);
+        globalThis.window.clearTimeout(openTimerRef.current);
+        globalThis.window.clearTimeout(closeTimerRef.current);
+        globalThis.window.clearTimeout(skipDelayTimerRef.current);
       };
     }, []);
 
@@ -185,15 +186,15 @@ const NavigationMenu = React.forwardRef<NavigationMenuElement, NavigationMenuPro
         orientation={orientation}
         rootNavigationMenu={navigationMenu}
         onTriggerEnter={(itemValue) => {
-          window.clearTimeout(openTimerRef.current);
+          globalThis.window.clearTimeout(openTimerRef.current);
           if (isOpenDelayed) handleDelayedOpen(itemValue);
           else handleOpen(itemValue);
         }}
         onTriggerLeave={() => {
-          window.clearTimeout(openTimerRef.current);
+          globalThis.window.clearTimeout(openTimerRef.current);
           startCloseTimer();
         }}
-        onContentEnter={() => window.clearTimeout(closeTimerRef.current)}
+        onContentEnter={() => globalThis.window.clearTimeout(closeTimerRef.current)}
         onContentLeave={startCloseTimer}
         onItemSelect={(itemValue) => {
           setValue((prevValue) => (prevValue === itemValue ? '' : itemValue));
@@ -426,21 +427,26 @@ const NavigationMenuItem = React.forwardRef<NavigationMenuItemElement, Navigatio
     const focusProxyRef = React.useRef<FocusProxyElement>(null);
     const restoreContentTabOrderRef = React.useRef(() => {});
     const wasEscapeCloseRef = React.useRef(false);
-
-    const handleContentEntry = React.useCallback((side = 'start') => {
-      if (contentRef.current) {
-        restoreContentTabOrderRef.current();
-        const candidates = getTabbableCandidates(contentRef.current);
-        if (candidates.length) focusFirst(side === 'start' ? candidates : candidates.reverse());
-      }
-    }, []);
+    const providedDocument = useDocument();
+
+    const handleContentEntry = React.useCallback(
+      (side = 'start') => {
+        if (contentRef.current && providedDocument) {
+          restoreContentTabOrderRef.current();
+          const candidates = getTabbableCandidates(contentRef.current, providedDocument);
+          if (candidates.length)
+            focusFirst(side === 'start' ? candidates : candidates.reverse(), providedDocument);
+        }
+      },
+      [providedDocument]
+    );
 
     const handleContentExit = React.useCallback(() => {
-      if (contentRef.current) {
-        const candidates = getTabbableCandidates(contentRef.current);
+      if (contentRef.current && providedDocument) {
+        const candidates = getTabbableCandidates(contentRef.current, providedDocument);
         if (candidates.length) restoreContentTabOrderRef.current = removeFromTabOrder(candidates);
       }
-    }, []);
+    }, [providedDocument]);
 
     return (
       <NavigationMenuItemContextProvider
@@ -864,6 +870,7 @@ const NavigationMenuContentImpl = React.forwardRef<
   const contentId = makeContentId(context.baseId, value);
   const getItems = useCollection(__scopeNavigationMenu);
   const prevMotionAttributeRef = React.useRef<MotionAttribute | null>(null);
+  const providedDocument = useDocument();
 
   const { onItemDismiss } = context;
 
@@ -875,12 +882,21 @@ const NavigationMenuContentImpl = React.forwardRef<
       const handleClose = () => {
         onItemDismiss();
         onRootContentClose();
-        if (content.contains(document.activeElement)) triggerRef.current?.focus();
+
+        if (providedDocument && content.contains(providedDocument.activeElement))
+          triggerRef.current?.focus();
       };
       content.addEventListener(ROOT_CONTENT_DISMISS, handleClose);
       return () => content.removeEventListener(ROOT_CONTENT_DISMISS, handleClose);
     }
-  }, [context.isRootMenu, props.value, triggerRef, onItemDismiss, onRootContentClose]);
+  }, [
+    context.isRootMenu,
+    props.value,
+    triggerRef,
+    onItemDismiss,
+    onRootContentClose,
+    providedDocument,
+  ]);
 
   const motionAttribute = React.useMemo(() => {
     const items = getItems();
@@ -942,18 +958,19 @@ const NavigationMenuContentImpl = React.forwardRef<
           if (isTrigger || isRootViewport || !context.isRootMenu) event.preventDefault();
         })}
         onKeyDown={composeEventHandlers(props.onKeyDown, (event) => {
+          if (!providedDocument) return;
           const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
           const isTabKey = event.key === 'Tab' && !isMetaKey;
           if (isTabKey) {
-            const candidates = getTabbableCandidates(event.currentTarget);
-            const focusedElement = document.activeElement;
+            const candidates = getTabbableCandidates(event.currentTarget, providedDocument);
+            const focusedElement = providedDocument?.activeElement;
             const index = candidates.findIndex((candidate) => candidate === focusedElement);
             const isMovingBackwards = event.shiftKey;
             const nextCandidates = isMovingBackwards
               ? candidates.slice(0, index).reverse()
               : candidates.slice(index + 1, candidates.length);
 
-            if (focusFirst(nextCandidates)) {
+            if (focusFirst(nextCandidates, providedDocument)) {
               // prevent browser tab keydown because we've handled focus
               event.preventDefault();
             } else {
@@ -1113,6 +1130,7 @@ const FocusGroupItem = React.forwardRef<FocusGroupItemElement, FocusGroupItemPro
     const { __scopeNavigationMenu, ...groupProps } = props;
     const getItems = useFocusGroupCollection(__scopeNavigationMenu);
     const context = useNavigationMenuContext(FOCUS_GROUP_ITEM_NAME, __scopeNavigationMenu);
+    const providedDocument = useDocument();
 
     return (
       <FocusGroupCollection.ItemSlot scope={__scopeNavigationMenu}>
@@ -1134,7 +1152,11 @@ const FocusGroupItem = React.forwardRef<FocusGroupItemElement, FocusGroupItemPro
                * Imperative focus during keydown is risky so we prevent React's batching updates
                * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
                */
-              setTimeout(() => focusFirst(candidateNodes));
+              globalThis.window.setTimeout(() => {
+                if (providedDocument) {
+                  focusFirst(candidateNodes, providedDocument);
+                }
+              });
 
               // Prevent page scroll while navigating
               event.preventDefault();
@@ -1156,9 +1178,9 @@ const FocusGroupItem = React.forwardRef<FocusGroupItemElement, FocusGroupItemPro
  * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
  * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
  */
-function getTabbableCandidates(container: HTMLElement) {
+function getTabbableCandidates(container: HTMLElement, providedDocument: Document) {
   const nodes: HTMLElement[] = [];
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+  const walker = providedDocument.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
     acceptNode: (node: any) => {
       const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
       if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
@@ -1174,13 +1196,13 @@ function getTabbableCandidates(container: HTMLElement) {
   return nodes;
 }
 
-function focusFirst(candidates: HTMLElement[]) {
-  const previouslyFocusedElement = document.activeElement;
+function focusFirst(candidates: HTMLElement[], providedDocument: Document) {
+  const previouslyFocusedElement = providedDocument.activeElement;
   return candidates.some((candidate) => {
     // if focus is already where we want to go, we don't want to keep going through the candidates
     if (candidate === previouslyFocusedElement) return true;
     candidate.focus();
-    return document.activeElement !== previouslyFocusedElement;
+    return providedDocument.activeElement !== previouslyFocusedElement;
   });
 }
 
@@ -1211,11 +1233,11 @@ function useResizeObserver(element: HTMLElement | null, onResize: () => void) {
        */
       const resizeObserver = new ResizeObserver(() => {
         cancelAnimationFrame(rAF);
-        rAF = window.requestAnimationFrame(handleResize);
+        rAF = globalThis.window.requestAnimationFrame(handleResize);
       });
       resizeObserver.observe(element);
       return () => {
-        window.cancelAnimationFrame(rAF);
+        globalThis.window.cancelAnimationFrame(rAF);
         resizeObserver.unobserve(element);
       };
     }
diff --git a/packages/react/one-time-password-field/package.json b/packages/react/one-time-password-field/package.json
index b36debad9..7cf4204b7 100644
--- a/packages/react/one-time-password-field/package.json
+++ b/packages/react/one-time-password-field/package.json
@@ -40,6 +40,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/number": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-roving-focus": "workspace:*",
diff --git a/packages/react/one-time-password-field/src/one-time-password-field.tsx b/packages/react/one-time-password-field/src/one-time-password-field.tsx
index 382af41cc..b2ca7bcba 100644
--- a/packages/react/one-time-password-field/src/one-time-password-field.tsx
+++ b/packages/react/one-time-password-field/src/one-time-password-field.tsx
@@ -13,6 +13,7 @@ import { createContextScope } from '@radix-ui/react-context';
 import { useDirection } from '@radix-ui/react-direction';
 import { clamp } from '@radix-ui/number';
 import { useEffectEvent } from '@radix-ui/react-use-effect-event';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type InputValidationType = 'alpha' | 'numeric' | 'alphanumeric' | 'none';
 
@@ -381,12 +382,17 @@ const OneTimePasswordField = React.forwardRef<HTMLDivElement, OneTimePasswordFie
     const userActionRef = React.useRef<KeyboardActionDetails | null>(null);
     const rootRef = React.useRef<HTMLDivElement | null>(null);
     const composedRefs = useComposedRefs(forwardedRef, rootRef);
+    const providedDocument = useDocument();
 
     const firstInput = collection.at(0)?.element;
     const locateForm = React.useCallback(() => {
       let formElement: HTMLFormElement | null | undefined;
       if (form) {
-        const associatedElement = (rootRef.current?.ownerDocument ?? document).getElementById(form);
+        const associatedElement = (
+          rootRef.current?.ownerDocument ??
+          providedDocument ??
+          globalThis.document
+        ).getElementById(form);
         if (isFormElement(associatedElement)) {
           formElement = associatedElement;
         }
@@ -397,7 +403,7 @@ const OneTimePasswordField = React.forwardRef<HTMLDivElement, OneTimePasswordFie
       }
 
       return formElement ?? null;
-    }, [form, firstInput]);
+    }, [form, firstInput, providedDocument]);
 
     const attemptSubmit = React.useCallback(() => {
       const formElement = locateForm();
@@ -612,7 +618,7 @@ const OneTimePasswordFieldInput = React.forwardRef<
   const keyboardActionTimeoutRef = React.useRef<number | null>(null);
   React.useEffect(() => {
     return () => {
-      window.clearTimeout(keyboardActionTimeoutRef.current!);
+      globalThis.window.clearTimeout(keyboardActionTimeoutRef.current!);
     };
   }, []);
 
@@ -670,7 +676,7 @@ const OneTimePasswordFieldInput = React.forwardRef<
                   };
                   // Set a short timeout to clear the action tracker after the change
                   // handler has had time to complete.
-                  keyboardActionTimeoutRef.current = window.setTimeout(() => {
+                  keyboardActionTimeoutRef.current = globalThis.window.setTimeout(() => {
                     userActionRef.current = null;
                   }, 10);
                 }
@@ -782,7 +788,7 @@ const OneTimePasswordFieldInput = React.forwardRef<
                       };
                       // Set a short timeout to clear the action tracker after the change
                       // handler has had time to complete.
-                      keyboardActionTimeoutRef.current = window.setTimeout(() => {
+                      keyboardActionTimeoutRef.current = globalThis.window.setTimeout(() => {
                         userActionRef.current = null;
                       }, 10);
                     }
@@ -853,7 +859,7 @@ const OneTimePasswordFieldInput = React.forwardRef<
                             metaKey: event.metaKey,
                             ctrlKey: event.ctrlKey,
                           };
-                          keyboardActionTimeoutRef.current = window.setTimeout(() => {
+                          keyboardActionTimeoutRef.current = globalThis.window.setTimeout(() => {
                             userActionRef.current = null;
                           }, 10);
                         }
@@ -907,7 +913,7 @@ function focusInput(element: HTMLInputElement | null | undefined) {
   if (element.ownerDocument.activeElement === element) {
     // if the element is already focused, select the value in the next
     // animation frame
-    window.requestAnimationFrame(() => {
+    globalThis.window.requestAnimationFrame(() => {
       element.select?.();
     });
   } else {
diff --git a/packages/react/password-toggle-field/package.json b/packages/react/password-toggle-field/package.json
index 11929df61..c3436d1e5 100644
--- a/packages/react/password-toggle-field/package.json
+++ b/packages/react/password-toggle-field/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/primitive": "workspace:*",
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-controllable-state": "workspace:*",
diff --git a/packages/react/password-toggle-field/src/password-toggle-field.tsx b/packages/react/password-toggle-field/src/password-toggle-field.tsx
index a132469a9..fbf7f58c1 100644
--- a/packages/react/password-toggle-field/src/password-toggle-field.tsx
+++ b/packages/react/password-toggle-field/src/password-toggle-field.tsx
@@ -9,6 +9,7 @@ import { useIsHydrated } from '@radix-ui/react-use-is-hydrated';
 import { useEffectEvent } from '@radix-ui/react-use-effect-event';
 import type { Scope } from '@radix-ui/react-context';
 import { createContextScope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 const PASSWORD_TOGGLE_FIELD_NAME = 'PasswordToggleField';
 
@@ -233,6 +234,7 @@ const PasswordToggleFieldToggle = React.forwardRef<
     const elementRef = React.useRef<HTMLButtonElement>(null);
     const ref = useComposedRefs(forwardedRef, elementRef);
     const isHydrated = useIsHydrated();
+    const providedDocument = useDocument();
 
     React.useEffect(() => {
       const element = elementRef.current;
@@ -283,15 +285,16 @@ const PasswordToggleFieldToggle = React.forwardRef<
 
     React.useEffect(() => {
       let cleanup = () => {};
-      const ownerWindow = elementRef.current?.ownerDocument?.defaultView || window;
+      const ownerWindow =
+        elementRef.current?.ownerDocument?.defaultView || providedDocument?.defaultView;
       const reset = () => (focusState.current.clickTriggered = false);
-      const handlePointerUp = () => (cleanup = requestIdleCallback(ownerWindow, reset));
-      ownerWindow.addEventListener('pointerup', handlePointerUp);
+      const handlePointerUp = () => (cleanup = requestIdleCallback(reset));
+      ownerWindow?.addEventListener('pointerup', handlePointerUp);
       return () => {
         cleanup();
-        ownerWindow.removeEventListener('pointerup', handlePointerUp);
+        ownerWindow?.removeEventListener('pointerup', handlePointerUp);
       };
-    }, [focusState]);
+    }, [focusState, providedDocument]);
 
     return (
       <Primitive.button
@@ -349,7 +352,7 @@ const PasswordToggleFieldToggle = React.forwardRef<
           // if click handler hasn't been called at this point, it may have been
           // intercepted, in which case we still want to reset our internal
           // state
-          setTimeout(() => {
+          globalThis.window.setTimeout(() => {
             focusState.current = INITIAL_FOCUS_STATE;
           }, 50);
         }}
@@ -458,10 +461,10 @@ export type {
 };
 
 function requestIdleCallback(
-  window: Window,
   callback: IdleRequestCallback,
   options?: IdleRequestOptions
 ): () => void {
+  const window = globalThis.window;
   if ((window as any).requestIdleCallback) {
     const id = window.requestIdleCallback(callback, options);
     return () => {
diff --git a/packages/react/popper/package.json b/packages/react/popper/package.json
index 278dacd10..12c947b7f 100644
--- a/packages/react/popper/package.json
+++ b/packages/react/popper/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-arrow": "workspace:*",
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*",
     "@radix-ui/react-use-layout-effect": "workspace:*",
diff --git a/packages/react/popper/src/popper.tsx b/packages/react/popper/src/popper.tsx
index 16ab3da7f..7109b63f3 100644
--- a/packages/react/popper/src/popper.tsx
+++ b/packages/react/popper/src/popper.tsx
@@ -21,6 +21,7 @@ import { useSize } from '@radix-ui/react-use-size';
 import type { Placement, Middleware } from '@floating-ui/react-dom';
 import type { Scope } from '@radix-ui/react-context';
 import type { Measurable } from '@radix-ui/rect';
+import { useDocument } from '@radix-ui/react-document-context';
 
 const SIDE_OPTIONS = ['top', 'right', 'bottom', 'left'] as const;
 const ALIGN_OPTIONS = ['start', 'center', 'end'] as const;
@@ -224,10 +225,12 @@ const PopperContent = React.forwardRef<PopperContentElement, PopperContentProps>
     const arrowY = middlewareData.arrow?.y;
     const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
 
+    const documentWindow = useDocument()?.defaultView;
     const [contentZIndex, setContentZIndex] = React.useState<string>();
     useLayoutEffect(() => {
-      if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
-    }, [content]);
+      if (content && documentWindow)
+        setContentZIndex(documentWindow.getComputedStyle(content).zIndex);
+    }, [content, documentWindow]);
 
     return (
       <div
diff --git a/packages/react/portal/package.json b/packages/react/portal/package.json
index 7f4bb26b4..5ecd1b316 100644
--- a/packages/react/portal/package.json
+++ b/packages/react/portal/package.json
@@ -34,6 +34,7 @@
     "build": "radix-build"
   },
   "dependencies": {
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-layout-effect": "workspace:*"
   },
diff --git a/packages/react/portal/src/portal.tsx b/packages/react/portal/src/portal.tsx
index f9683e8ad..4334b0f4e 100644
--- a/packages/react/portal/src/portal.tsx
+++ b/packages/react/portal/src/portal.tsx
@@ -2,6 +2,7 @@ import * as React from 'react';
 import ReactDOM from 'react-dom';
 import { Primitive } from '@radix-ui/react-primitive';
 import { useLayoutEffect } from '@radix-ui/react-use-layout-effect';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * Portal
@@ -21,8 +22,12 @@ interface PortalProps extends PrimitiveDivProps {
 const Portal = React.forwardRef<PortalElement, PortalProps>((props, forwardedRef) => {
   const { container: containerProp, ...portalProps } = props;
   const [mounted, setMounted] = React.useState(false);
+  const providedDocument = useDocument();
+
   useLayoutEffect(() => setMounted(true), []);
-  const container = containerProp || (mounted && globalThis?.document?.body);
+
+  const container =
+    containerProp || (mounted && (providedDocument?.body || globalThis?.document?.body));
   return container
     ? ReactDOM.createPortal(<Primitive.div {...portalProps} ref={forwardedRef} />, container)
     : null;
diff --git a/packages/react/presence/src/presence.tsx b/packages/react/presence/src/presence.tsx
index 6a3edc212..06c3bd0f5 100644
--- a/packages/react/presence/src/presence.tsx
+++ b/packages/react/presence/src/presence.tsx
@@ -92,7 +92,6 @@ function usePresence(present: boolean) {
   useLayoutEffect(() => {
     if (node) {
       let timeoutId: number;
-      const ownerWindow = node.ownerDocument.defaultView ?? window;
       /**
        * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
        * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
@@ -120,7 +119,7 @@ function usePresence(present: boolean) {
             // where the component chooses not to unmount). Doing this any
             // sooner than `setTimeout` (e.g. with `requestAnimationFrame`)
             // still causes a flash.
-            timeoutId = ownerWindow.setTimeout(() => {
+            timeoutId = globalThis.window.setTimeout(() => {
               if (node.style.animationFillMode === 'forwards') {
                 node.style.animationFillMode = currentFillMode;
               }
@@ -138,7 +137,7 @@ function usePresence(present: boolean) {
       node.addEventListener('animationcancel', handleAnimationEnd);
       node.addEventListener('animationend', handleAnimationEnd);
       return () => {
-        ownerWindow.clearTimeout(timeoutId);
+        globalThis.window.clearTimeout(timeoutId);
         node.removeEventListener('animationstart', handleAnimationStart);
         node.removeEventListener('animationcancel', handleAnimationEnd);
         node.removeEventListener('animationend', handleAnimationEnd);
diff --git a/packages/react/radio-group/package.json b/packages/react/radio-group/package.json
index 4c7e48e63..151087114 100644
--- a/packages/react/radio-group/package.json
+++ b/packages/react/radio-group/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-presence": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-roving-focus": "workspace:*",
diff --git a/packages/react/radio-group/src/radio-group.tsx b/packages/react/radio-group/src/radio-group.tsx
index 82ade8bf4..b511eb0ff 100644
--- a/packages/react/radio-group/src/radio-group.tsx
+++ b/packages/react/radio-group/src/radio-group.tsx
@@ -10,6 +10,7 @@ import { useDirection } from '@radix-ui/react-direction';
 import { Radio, RadioIndicator, createRadioScope } from './radio';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
 
@@ -132,21 +133,23 @@ const RadioGroupItem = React.forwardRef<RadioGroupItemElement, RadioGroupItemPro
     const composedRefs = useComposedRefs(forwardedRef, ref);
     const checked = context.value === itemProps.value;
     const isArrowKeyPressedRef = React.useRef(false);
+    const providedDocument = useDocument();
 
     React.useEffect(() => {
+      if (!providedDocument) return;
       const handleKeyDown = (event: KeyboardEvent) => {
         if (ARROW_KEYS.includes(event.key)) {
           isArrowKeyPressedRef.current = true;
         }
       };
       const handleKeyUp = () => (isArrowKeyPressedRef.current = false);
-      document.addEventListener('keydown', handleKeyDown);
-      document.addEventListener('keyup', handleKeyUp);
+      providedDocument.addEventListener('keydown', handleKeyDown);
+      providedDocument.addEventListener('keyup', handleKeyUp);
       return () => {
-        document.removeEventListener('keydown', handleKeyDown);
-        document.removeEventListener('keyup', handleKeyUp);
+        providedDocument.removeEventListener('keydown', handleKeyDown);
+        providedDocument.removeEventListener('keyup', handleKeyUp);
       };
-    }, []);
+    }, [providedDocument]);
 
     return (
       <RovingFocusGroup.Item
diff --git a/packages/react/radix-ui/package.json b/packages/react/radix-ui/package.json
index 43167a2a6..5be3eb592 100644
--- a/packages/react/radix-ui/package.json
+++ b/packages/react/radix-ui/package.json
@@ -68,6 +68,7 @@
     "@radix-ui/react-dialog": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-dropdown-menu": "workspace:*",
     "@radix-ui/react-focus-guards": "workspace:*",
     "@radix-ui/react-focus-scope": "workspace:*",
diff --git a/packages/react/radix-ui/src/internal.ts b/packages/react/radix-ui/src/internal.ts
index 50f47b992..a8b61e738 100644
--- a/packages/react/radix-ui/src/internal.ts
+++ b/packages/react/radix-ui/src/internal.ts
@@ -4,6 +4,7 @@ export * as Collection from '@radix-ui/react-collection';
 export { composeRefs, useComposedRefs } from '@radix-ui/react-compose-refs';
 export * as Context from '@radix-ui/react-context';
 export * as DismissableLayer from '@radix-ui/react-dismissable-layer';
+export * as DocumentContext from '@radix-ui/react-document-context';
 export * as FocusGuards from '@radix-ui/react-focus-guards';
 export * as FocusScope from '@radix-ui/react-focus-scope';
 export * as Menu from '@radix-ui/react-menu';
diff --git a/packages/react/roving-focus/package.json b/packages/react/roving-focus/package.json
index e656c6c07..cf01a72fa 100644
--- a/packages/react/roving-focus/package.json
+++ b/packages/react/roving-focus/package.json
@@ -39,6 +39,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*",
diff --git a/packages/react/roving-focus/src/roving-focus-group.tsx b/packages/react/roving-focus/src/roving-focus-group.tsx
index a429acf50..359fa3e4a 100644
--- a/packages/react/roving-focus/src/roving-focus-group.tsx
+++ b/packages/react/roving-focus/src/roving-focus-group.tsx
@@ -10,6 +10,7 @@ import { useControllableState } from '@radix-ui/react-use-controllable-state';
 import { useDirection } from '@radix-ui/react-direction';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 const ENTRY_FOCUS = 'rovingFocusGroup.onEntryFocus';
 const EVENT_OPTIONS = { bubbles: false, cancelable: true };
@@ -124,6 +125,7 @@ const RovingFocusGroupImpl = React.forwardRef<
   const getItems = useCollection(__scopeRovingFocusGroup);
   const isClickFocusRef = React.useRef(false);
   const [focusableItemsCount, setFocusableItemsCount] = React.useState(0);
+  const providedDocument = useDocument();
 
   React.useEffect(() => {
     const node = ref.current;
@@ -182,7 +184,9 @@ const RovingFocusGroupImpl = React.forwardRef<
                 Boolean
               ) as typeof items;
               const candidateNodes = candidateItems.map((item) => item.ref.current!);
-              focusFirst(candidateNodes, preventScrollOnEntryFocus);
+              if (providedDocument) {
+                focusFirst(candidateNodes, providedDocument, preventScrollOnEntryFocus);
+              }
             }
           }
 
@@ -226,7 +230,7 @@ const RovingFocusGroupItem = React.forwardRef<RovingFocusItemElement, RovingFocu
     const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);
     const isCurrentTabStop = context.currentTabStopId === id;
     const getItems = useCollection(__scopeRovingFocusGroup);
-
+    const providedDocument = useDocument();
     const { onFocusableItemAdd, onFocusableItemRemove, currentTabStopId } = context;
 
     React.useEffect(() => {
@@ -285,7 +289,11 @@ const RovingFocusGroupItem = React.forwardRef<RovingFocusItemElement, RovingFocu
                * Imperative focus during keydown is risky so we prevent React's batching updates
                * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
                */
-              setTimeout(() => focusFirst(candidateNodes));
+              globalThis.window.setTimeout(() => {
+                if (providedDocument) {
+                  focusFirst(candidateNodes, providedDocument);
+                }
+              });
             }
           })}
         >
@@ -324,13 +332,13 @@ function getFocusIntent(event: React.KeyboardEvent, orientation?: Orientation, d
   return MAP_KEY_TO_FOCUS_INTENT[key];
 }
 
-function focusFirst(candidates: HTMLElement[], preventScroll = false) {
-  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+function focusFirst(candidates: HTMLElement[], providedDocument: Document, preventScroll = false) {
+  const PREVIOUSLY_FOCUSED_ELEMENT = providedDocument.activeElement;
   for (const candidate of candidates) {
     // if focus is already where we want to go, we don't want to keep going through the candidates
     if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
     candidate.focus({ preventScroll });
-    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+    if (providedDocument.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
   }
 }
 
diff --git a/packages/react/scroll-area/package.json b/packages/react/scroll-area/package.json
index fed057ed2..15bb73d1b 100644
--- a/packages/react/scroll-area/package.json
+++ b/packages/react/scroll-area/package.json
@@ -39,6 +39,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-presence": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*",
diff --git a/packages/react/scroll-area/src/scroll-area.tsx b/packages/react/scroll-area/src/scroll-area.tsx
index 378e9bd35..0725ccecc 100644
--- a/packages/react/scroll-area/src/scroll-area.tsx
+++ b/packages/react/scroll-area/src/scroll-area.tsx
@@ -11,6 +11,7 @@ import { composeEventHandlers } from '@radix-ui/primitive';
 import { useStateMachine } from './use-state-machine';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type Direction = 'ltr' | 'rtl';
 type Sizes = {
@@ -250,16 +251,16 @@ const ScrollAreaScrollbarHover = React.forwardRef<
     let hideTimer = 0;
     if (scrollArea) {
       const handlePointerEnter = () => {
-        window.clearTimeout(hideTimer);
+        globalThis.window.clearTimeout(hideTimer);
         setVisible(true);
       };
       const handlePointerLeave = () => {
-        hideTimer = window.setTimeout(() => setVisible(false), context.scrollHideDelay);
+        hideTimer = globalThis.window.setTimeout(() => setVisible(false), context.scrollHideDelay);
       };
       scrollArea.addEventListener('pointerenter', handlePointerEnter);
       scrollArea.addEventListener('pointerleave', handlePointerLeave);
       return () => {
-        window.clearTimeout(hideTimer);
+        globalThis.window.clearTimeout(hideTimer);
         scrollArea.removeEventListener('pointerenter', handlePointerEnter);
         scrollArea.removeEventListener('pointerleave', handlePointerLeave);
       };
@@ -311,8 +312,8 @@ const ScrollAreaScrollbarScroll = React.forwardRef<
 
   React.useEffect(() => {
     if (state === 'idle') {
-      const hideTimer = window.setTimeout(() => send('HIDE'), context.scrollHideDelay);
-      return () => window.clearTimeout(hideTimer);
+      const hideTimer = globalThis.window.setTimeout(() => send('HIDE'), context.scrollHideDelay);
+      return () => globalThis.window.clearTimeout(hideTimer);
     }
   }, [state, context.scrollHideDelay, send]);
 
@@ -660,6 +661,7 @@ const ScrollAreaScrollbarImpl = React.forwardRef<
   const handleWheelScroll = useCallbackRef(onWheelScroll);
   const handleThumbPositionChange = useCallbackRef(onThumbPositionChange);
   const handleResize = useDebounceCallback(onResize, 10);
+  const providedDocument = useDocument();
 
   function handleDragScroll(event: React.PointerEvent<HTMLElement>) {
     if (rectRef.current) {
@@ -674,14 +676,16 @@ const ScrollAreaScrollbarImpl = React.forwardRef<
    * mode for document wheel event to allow it to be prevented
    */
   React.useEffect(() => {
+    if (!providedDocument) return;
     const handleWheel = (event: WheelEvent) => {
       const element = event.target as HTMLElement;
       const isScrollbarWheel = scrollbar?.contains(element);
       if (isScrollbarWheel) handleWheelScroll(event, maxScrollPos);
     };
-    document.addEventListener('wheel', handleWheel, { passive: false });
-    return () => document.removeEventListener('wheel', handleWheel, { passive: false } as any);
-  }, [viewport, scrollbar, maxScrollPos, handleWheelScroll]);
+    providedDocument.addEventListener('wheel', handleWheel, { passive: false });
+    return () =>
+      providedDocument.removeEventListener('wheel', handleWheel, { passive: false } as any);
+  }, [viewport, scrollbar, maxScrollPos, handleWheelScroll, providedDocument]);
 
   /**
    * Update thumb position on sizes change
@@ -713,8 +717,10 @@ const ScrollAreaScrollbarImpl = React.forwardRef<
             rectRef.current = scrollbar!.getBoundingClientRect();
             // pointer capture doesn't prevent text selection in Safari
             // so we remove text selection manually when scrolling
-            prevWebkitUserSelectRef.current = document.body.style.webkitUserSelect;
-            document.body.style.webkitUserSelect = 'none';
+            if (providedDocument) {
+              prevWebkitUserSelectRef.current = providedDocument.body.style.webkitUserSelect;
+              providedDocument.body.style.webkitUserSelect = 'none';
+            }
             if (context.viewport) context.viewport.style.scrollBehavior = 'auto';
             handleDragScroll(event);
           }
@@ -725,7 +731,9 @@ const ScrollAreaScrollbarImpl = React.forwardRef<
           if (element.hasPointerCapture(event.pointerId)) {
             element.releasePointerCapture(event.pointerId);
           }
-          document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;
+          if (providedDocument) {
+            providedDocument.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;
+          }
           if (context.viewport) context.viewport.style.scrollBehavior = '';
           rectRef.current = null;
         })}
@@ -959,6 +967,7 @@ function isScrollingWithinScrollbarBounds(scrollPos: number, maxScrollPos: numbe
 // Custom scroll handler to avoid scroll-linked effects
 // https://developer.mozilla.org/en-US/docs/Mozilla/Performance/Scroll-linked_effects
 const addUnlinkedScrollListener = (node: HTMLElement, handler = () => {}) => {
+  const documentWindow = node.ownerDocument?.defaultView;
   let prevPosition = { left: node.scrollLeft, top: node.scrollTop };
   let rAF = 0;
   (function loop() {
@@ -967,24 +976,26 @@ const addUnlinkedScrollListener = (node: HTMLElement, handler = () => {}) => {
     const isVerticalScroll = prevPosition.top !== position.top;
     if (isHorizontalScroll || isVerticalScroll) handler();
     prevPosition = position;
-    rAF = window.requestAnimationFrame(loop);
+    rAF = documentWindow?.requestAnimationFrame(loop) ?? 0;
   })();
-  return () => window.cancelAnimationFrame(rAF);
+  return () => documentWindow?.cancelAnimationFrame(rAF);
 };
 
 function useDebounceCallback(callback: () => void, delay: number) {
   const handleCallback = useCallbackRef(callback);
   const debounceTimerRef = React.useRef(0);
-  React.useEffect(() => () => window.clearTimeout(debounceTimerRef.current), []);
+  React.useEffect(() => () => globalThis.window.clearTimeout(debounceTimerRef.current), []);
   return React.useCallback(() => {
-    window.clearTimeout(debounceTimerRef.current);
-    debounceTimerRef.current = window.setTimeout(handleCallback, delay);
+    globalThis.window.clearTimeout(debounceTimerRef.current);
+    debounceTimerRef.current = globalThis.window.setTimeout(handleCallback, delay);
   }, [handleCallback, delay]);
 }
 
 function useResizeObserver(element: HTMLElement | null, onResize: () => void) {
+  const documentWindow = useDocument()?.defaultView;
   const handleResize = useCallbackRef(onResize);
   useLayoutEffect(() => {
+    if (!documentWindow) return;
     let rAF = 0;
     if (element) {
       /**
@@ -996,15 +1007,15 @@ function useResizeObserver(element: HTMLElement | null, onResize: () => void) {
        */
       const resizeObserver = new ResizeObserver(() => {
         cancelAnimationFrame(rAF);
-        rAF = window.requestAnimationFrame(handleResize);
+        rAF = documentWindow.requestAnimationFrame(handleResize);
       });
       resizeObserver.observe(element);
       return () => {
-        window.cancelAnimationFrame(rAF);
+        documentWindow.cancelAnimationFrame(rAF);
         resizeObserver.unobserve(element);
       };
     }
-  }, [element, handleResize]);
+  }, [element, handleResize, documentWindow]);
 }
 
 /* -----------------------------------------------------------------------------------------------*/
diff --git a/packages/react/select/package.json b/packages/react/select/package.json
index a64940e8c..114130c3b 100644
--- a/packages/react/select/package.json
+++ b/packages/react/select/package.json
@@ -41,6 +41,7 @@
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-direction": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-focus-guards": "workspace:*",
     "@radix-ui/react-focus-scope": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
diff --git a/packages/react/select/src/select.tsx b/packages/react/select/src/select.tsx
index 8505c0b63..1e3b0fac0 100644
--- a/packages/react/select/src/select.tsx
+++ b/packages/react/select/src/select.tsx
@@ -24,6 +24,7 @@ import { hideOthers } from 'aria-hidden';
 import { RemoveScroll } from 'react-remove-scroll';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type Direction = 'ltr' | 'rtl';
 
@@ -568,6 +569,7 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
     const getItems = useCollection(__scopeSelect);
     const [isPositioned, setIsPositioned] = React.useState(false);
     const firstValidItemFoundRef = React.useRef(false);
+    const providedDocument = useDocument();
 
     // aria-hide everything except the content (better supported equivalent to setting aria-modal)
     React.useEffect(() => {
@@ -580,10 +582,11 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
 
     const focusFirst = React.useCallback(
       (candidates: Array<HTMLElement | null>) => {
+        if (!providedDocument) return;
         const [firstItem, ...restItems] = getItems().map((item) => item.ref.current);
         const [lastItem] = restItems.slice(-1);
 
-        const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+        const PREVIOUSLY_FOCUSED_ELEMENT = providedDocument.activeElement;
         for (const candidate of candidates) {
           // if focus is already where we want to go, we don't want to keep going through the candidates
           if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
@@ -592,10 +595,10 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
           if (candidate === firstItem && viewport) viewport.scrollTop = 0;
           if (candidate === lastItem && viewport) viewport.scrollTop = viewport.scrollHeight;
           candidate?.focus();
-          if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+          if (providedDocument.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
         }
       },
-      [getItems, viewport]
+      [getItems, viewport, providedDocument]
     );
 
     const focusSelectedItem = React.useCallback(
@@ -615,7 +618,7 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
     // and close on `pointerup` outside.
     const { onOpenChange, triggerPointerDownPosRef } = context;
     React.useEffect(() => {
-      if (content) {
+      if (content && providedDocument) {
         let pointerMoveDelta = { x: 0, y: 0 };
 
         const handlePointerMove = (event: PointerEvent) => {
@@ -634,42 +637,49 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
               onOpenChange(false);
             }
           }
-          document.removeEventListener('pointermove', handlePointerMove);
+          providedDocument.removeEventListener('pointermove', handlePointerMove);
           triggerPointerDownPosRef.current = null;
         };
 
         if (triggerPointerDownPosRef.current !== null) {
-          document.addEventListener('pointermove', handlePointerMove);
-          document.addEventListener('pointerup', handlePointerUp, { capture: true, once: true });
+          providedDocument.addEventListener('pointermove', handlePointerMove);
+          providedDocument.addEventListener('pointerup', handlePointerUp, {
+            capture: true,
+            once: true,
+          });
         }
 
         return () => {
-          document.removeEventListener('pointermove', handlePointerMove);
-          document.removeEventListener('pointerup', handlePointerUp, { capture: true });
+          providedDocument.removeEventListener('pointermove', handlePointerMove);
+          providedDocument.removeEventListener('pointerup', handlePointerUp, { capture: true });
         };
       }
-    }, [content, onOpenChange, triggerPointerDownPosRef]);
+    }, [content, onOpenChange, triggerPointerDownPosRef, providedDocument]);
 
     React.useEffect(() => {
+      const documentWindow = providedDocument?.defaultView;
+      if (!documentWindow) return;
       const close = () => onOpenChange(false);
-      window.addEventListener('blur', close);
-      window.addEventListener('resize', close);
+      documentWindow.addEventListener('blur', close);
+      documentWindow.addEventListener('resize', close);
       return () => {
-        window.removeEventListener('blur', close);
-        window.removeEventListener('resize', close);
+        documentWindow.removeEventListener('blur', close);
+        documentWindow.removeEventListener('resize', close);
       };
-    }, [onOpenChange]);
+    }, [onOpenChange, providedDocument]);
 
     const [searchRef, handleTypeaheadSearch] = useTypeaheadSearch((search) => {
       const enabledItems = getItems().filter((item) => !item.disabled);
-      const currentItem = enabledItems.find((item) => item.ref.current === document.activeElement);
+      const currentItem = enabledItems.find(
+        (item) => item.ref.current === providedDocument?.activeElement
+      );
       const nextItem = findNextItem(enabledItems, search, currentItem);
       if (nextItem) {
         /**
          * Imperative focus during keydown is risky so we prevent React's batching updates
          * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
          */
-        setTimeout(() => (nextItem.ref.current as HTMLElement).focus());
+        globalThis.window.setTimeout(() => (nextItem.ref.current as HTMLElement).focus());
       }
     });
 
@@ -799,7 +809,7 @@ const SelectContentImpl = React.forwardRef<SelectContentImplElement, SelectConte
                      * Imperative focus during keydown is risky so we prevent React's batching updates
                      * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
                      */
-                    setTimeout(() => focusFirst(candidateNodes));
+                    globalThis.window.setTimeout(() => focusFirst(candidateNodes));
 
                     event.preventDefault();
                   }
@@ -837,7 +847,7 @@ const SelectItemAlignedPosition = React.forwardRef<
   const getItems = useCollection(__scopeSelect);
   const shouldExpandOnScrollRef = React.useRef(false);
   const shouldRepositionRef = React.useRef(true);
-
+  const documentWindow = useDocument()?.defaultView;
   const { viewport, selectedItem, selectedItemText, focusSelectedItem } = contentContext;
   const position = React.useCallback(() => {
     if (
@@ -847,7 +857,8 @@ const SelectItemAlignedPosition = React.forwardRef<
       content &&
       viewport &&
       selectedItem &&
-      selectedItemText
+      selectedItemText &&
+      documentWindow
     ) {
       const triggerRect = context.trigger.getBoundingClientRect();
 
@@ -864,7 +875,7 @@ const SelectItemAlignedPosition = React.forwardRef<
         const leftDelta = triggerRect.left - left;
         const minContentWidth = triggerRect.width + leftDelta;
         const contentWidth = Math.max(minContentWidth, contentRect.width);
-        const rightEdge = window.innerWidth - CONTENT_MARGIN;
+        const rightEdge = documentWindow.innerWidth - CONTENT_MARGIN;
         const clampedLeft = clamp(left, [
           CONTENT_MARGIN,
           // Prevents the content from going off the starting edge of the
@@ -879,11 +890,11 @@ const SelectItemAlignedPosition = React.forwardRef<
         contentWrapper.style.left = clampedLeft + 'px';
       } else {
         const itemTextOffset = contentRect.right - itemTextRect.right;
-        const right = window.innerWidth - valueNodeRect.right - itemTextOffset;
-        const rightDelta = window.innerWidth - triggerRect.right - right;
+        const right = documentWindow.innerWidth - valueNodeRect.right - itemTextOffset;
+        const rightDelta = documentWindow.innerWidth - triggerRect.right - right;
         const minContentWidth = triggerRect.width + rightDelta;
         const contentWidth = Math.max(minContentWidth, contentRect.width);
-        const leftEdge = window.innerWidth - CONTENT_MARGIN;
+        const leftEdge = documentWindow.innerWidth - CONTENT_MARGIN;
         const clampedRight = clamp(right, [
           CONTENT_MARGIN,
           Math.max(CONTENT_MARGIN, leftEdge - contentWidth),
@@ -897,10 +908,10 @@ const SelectItemAlignedPosition = React.forwardRef<
       // Vertical positioning
       // -----------------------------------------------------------------------------------------
       const items = getItems();
-      const availableHeight = window.innerHeight - CONTENT_MARGIN * 2;
+      const availableHeight = documentWindow.innerHeight - CONTENT_MARGIN * 2;
       const itemsHeight = viewport.scrollHeight;
 
-      const contentStyles = window.getComputedStyle(content);
+      const contentStyles = documentWindow.getComputedStyle(content);
       const contentBorderTopWidth = parseInt(contentStyles.borderTopWidth, 10);
       const contentPaddingTop = parseInt(contentStyles.paddingTop, 10);
       const contentBorderBottomWidth = parseInt(contentStyles.borderBottomWidth, 10);
@@ -908,7 +919,7 @@ const SelectItemAlignedPosition = React.forwardRef<
       const fullContentHeight = contentBorderTopWidth + contentPaddingTop + itemsHeight + contentPaddingBottom + contentBorderBottomWidth; // prettier-ignore
       const minContentHeight = Math.min(selectedItem.offsetHeight * 5, fullContentHeight);
 
-      const viewportStyles = window.getComputedStyle(viewport);
+      const viewportStyles = documentWindow.getComputedStyle(viewport);
       const viewportPaddingTop = parseInt(viewportStyles.paddingTop, 10);
       const viewportPaddingBottom = parseInt(viewportStyles.paddingBottom, 10);
 
@@ -976,6 +987,7 @@ const SelectItemAlignedPosition = React.forwardRef<
     selectedItemText,
     context.dir,
     onPlaced,
+    documentWindow,
   ]);
 
   useLayoutEffect(() => position(), [position]);
@@ -983,8 +995,9 @@ const SelectItemAlignedPosition = React.forwardRef<
   // copy z-index from content to wrapper
   const [contentZIndex, setContentZIndex] = React.useState<string>();
   useLayoutEffect(() => {
-    if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
-  }, [content]);
+    if (content && documentWindow)
+      setContentZIndex(documentWindow.getComputedStyle(content).zIndex);
+  }, [content, documentWindow]);
 
   // When the viewport becomes scrollable at the top, the scroll up button will mount.
   // Because it is part of the normal flow, it will push down the viewport, thus throwing our
@@ -1112,6 +1125,7 @@ const SelectViewport = React.forwardRef<SelectViewportElement, SelectViewportPro
     const viewportContext = useSelectViewportContext(VIEWPORT_NAME, __scopeSelect);
     const composedRefs = useComposedRefs(forwardedRef, contentContext.onViewportChange);
     const prevScrollTopRef = React.useRef(0);
+    const documentWindow = useDocument()?.defaultView;
     return (
       <>
         {/* Hide scrollbars cross-browser and enable momentum scroll for touch devices */}
@@ -1141,12 +1155,13 @@ const SelectViewport = React.forwardRef<SelectViewportElement, SelectViewportPro
               ...viewportProps.style,
             }}
             onScroll={composeEventHandlers(viewportProps.onScroll, (event) => {
+              if (!documentWindow) return;
               const viewport = event.currentTarget;
               const { contentWrapper, shouldExpandOnScrollRef } = viewportContext;
               if (shouldExpandOnScrollRef?.current && contentWrapper) {
                 const scrolledBy = Math.abs(prevScrollTopRef.current - viewport.scrollTop);
                 if (scrolledBy > 0) {
-                  const availableHeight = window.innerHeight - CONTENT_MARGIN * 2;
+                  const availableHeight = documentWindow.innerHeight - CONTENT_MARGIN * 2;
                   const cssMinHeight = parseFloat(contentWrapper.style.minHeight);
                   const cssHeight = parseFloat(contentWrapper.style.height);
                   const prevHeight = Math.max(cssMinHeight, cssHeight);
@@ -1266,6 +1281,7 @@ const SelectItem = React.forwardRef<SelectItemElement, SelectItemProps>(
     );
     const textId = useId();
     const pointerTypeRef = React.useRef<React.PointerEvent['pointerType']>('touch');
+    const providedDocument = useDocument();
 
     const handleSelect = () => {
       if (!disabled) {
@@ -1335,7 +1351,7 @@ const SelectItem = React.forwardRef<SelectItemElement, SelectItemProps>(
               }
             })}
             onPointerLeave={composeEventHandlers(itemProps.onPointerLeave, (event) => {
-              if (event.currentTarget === document.activeElement) {
+              if (providedDocument && event.currentTarget === providedDocument.activeElement) {
                 contentContext.onItemLeave?.();
               }
             })}
@@ -1542,13 +1558,16 @@ const SelectScrollButtonImpl = React.forwardRef<
   const contentContext = useSelectContentContext('SelectScrollButton', __scopeSelect);
   const autoScrollTimerRef = React.useRef<number | null>(null);
   const getItems = useCollection(__scopeSelect);
+  const providedDocument = useDocument();
+  const documentWindow = providedDocument?.defaultView;
 
   const clearAutoScrollTimer = React.useCallback(() => {
     if (autoScrollTimerRef.current !== null) {
-      window.clearInterval(autoScrollTimerRef.current);
+      if (!documentWindow) return;
+      documentWindow.clearInterval(autoScrollTimerRef.current);
       autoScrollTimerRef.current = null;
     }
-  }, []);
+  }, [documentWindow]);
 
   React.useEffect(() => {
     return () => clearAutoScrollTimer();
@@ -1559,9 +1578,11 @@ const SelectScrollButtonImpl = React.forwardRef<
   // the viewport, potentially causing the active item to now be partially out of view.
   // We re-run the `scrollIntoView` logic to make sure it stays within the viewport.
   useLayoutEffect(() => {
-    const activeItem = getItems().find((item) => item.ref.current === document.activeElement);
+    const activeItem = getItems().find(
+      (item) => item.ref.current === providedDocument?.activeElement
+    );
     activeItem?.ref.current?.scrollIntoView({ block: 'nearest' });
-  }, [getItems]);
+  }, [getItems, providedDocument]);
 
   return (
     <Primitive.div
@@ -1570,14 +1591,14 @@ const SelectScrollButtonImpl = React.forwardRef<
       ref={forwardedRef}
       style={{ flexShrink: 0, ...scrollIndicatorProps.style }}
       onPointerDown={composeEventHandlers(scrollIndicatorProps.onPointerDown, () => {
-        if (autoScrollTimerRef.current === null) {
-          autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+        if (autoScrollTimerRef.current === null && documentWindow) {
+          autoScrollTimerRef.current = documentWindow.setInterval(onAutoScroll, 50);
         }
       })}
       onPointerMove={composeEventHandlers(scrollIndicatorProps.onPointerMove, () => {
         contentContext.onItemLeave?.();
-        if (autoScrollTimerRef.current === null) {
-          autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+        if (autoScrollTimerRef.current === null && documentWindow) {
+          autoScrollTimerRef.current = documentWindow.setInterval(onAutoScroll, 50);
         }
       })}
       onPointerLeave={composeEventHandlers(scrollIndicatorProps.onPointerLeave, () => {
@@ -1705,9 +1726,10 @@ function useTypeaheadSearch(onSearchChange: (search: string) => void) {
 
       (function updateSearch(value: string) {
         searchRef.current = value;
-        window.clearTimeout(timerRef.current);
+        globalThis.window.clearTimeout(timerRef.current);
         // Reset `searchRef` 1 second after it was last updated
-        if (value !== '') timerRef.current = window.setTimeout(() => updateSearch(''), 1000);
+        if (value !== '')
+          timerRef.current = globalThis.window.setTimeout(() => updateSearch(''), 1000);
       })(search);
     },
     [handleSearchChange]
@@ -1715,11 +1737,11 @@ function useTypeaheadSearch(onSearchChange: (search: string) => void) {
 
   const resetTypeahead = React.useCallback(() => {
     searchRef.current = '';
-    window.clearTimeout(timerRef.current);
+    globalThis.window.clearTimeout(timerRef.current);
   }, []);
 
   React.useEffect(() => {
-    return () => window.clearTimeout(timerRef.current);
+    return () => globalThis.window.clearTimeout(timerRef.current);
   }, []);
 
   return [searchRef, handleTypeaheadSearch, resetTypeahead] as const;
diff --git a/packages/react/toast/package.json b/packages/react/toast/package.json
index 94b537c96..ec545b813 100644
--- a/packages/react/toast/package.json
+++ b/packages/react/toast/package.json
@@ -39,6 +39,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-portal": "workspace:*",
     "@radix-ui/react-presence": "workspace:*",
     "@radix-ui/react-primitive": "workspace:*",
diff --git a/packages/react/toast/src/toast.tsx b/packages/react/toast/src/toast.tsx
index afdd8310b..2dc51422a 100644
--- a/packages/react/toast/src/toast.tsx
+++ b/packages/react/toast/src/toast.tsx
@@ -14,6 +14,7 @@ import { useLayoutEffect } from '@radix-ui/react-use-layout-effect';
 import { VisuallyHidden } from '@radix-ui/react-visually-hidden';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /* -------------------------------------------------------------------------------------------------
  * ToastProvider
@@ -145,6 +146,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
       label = 'Notifications ({hotkey})',
       ...viewportProps
     } = props;
+    const providedDocument = useDocument();
     const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
     const getItems = useCollection(__scopeToast);
     const wrapperRef = React.useRef<HTMLDivElement>(null);
@@ -156,6 +158,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
     const hasToasts = context.toastCount > 0;
 
     React.useEffect(() => {
+      if (!providedDocument) return;
       const handleKeyDown = (event: KeyboardEvent) => {
         // we use `event.code` as it is consistent regardless of meta keys that were pressed.
         // for example, `event.key` for `Control+Alt+t` is `†` and `t !== †`
@@ -163,11 +166,14 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
           hotkey.length !== 0 && hotkey.every((key) => (event as any)[key] || event.code === key);
         if (isHotkeyPressed) ref.current?.focus();
       };
-      document.addEventListener('keydown', handleKeyDown);
-      return () => document.removeEventListener('keydown', handleKeyDown);
-    }, [hotkey]);
+      providedDocument.addEventListener('keydown', handleKeyDown);
+      return () => providedDocument.removeEventListener('keydown', handleKeyDown);
+    }, [hotkey, providedDocument]);
 
     React.useEffect(() => {
+      const documentWindow = providedDocument?.defaultView;
+      if (!documentWindow) return;
+
       const wrapper = wrapperRef.current;
       const viewport = ref.current;
       if (hasToasts && wrapper && viewport) {
@@ -193,7 +199,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
         };
 
         const handlePointerLeaveResume = () => {
-          const isFocusInside = wrapper.contains(document.activeElement);
+          const isFocusInside = wrapper.contains(providedDocument.activeElement);
           if (!isFocusInside) handleResume();
         };
 
@@ -202,25 +208,28 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
         wrapper.addEventListener('focusout', handleFocusOutResume);
         wrapper.addEventListener('pointermove', handlePause);
         wrapper.addEventListener('pointerleave', handlePointerLeaveResume);
-        window.addEventListener('blur', handlePause);
-        window.addEventListener('focus', handleResume);
+        documentWindow.addEventListener('blur', handlePause);
+        documentWindow.addEventListener('focus', handleResume);
         return () => {
           wrapper.removeEventListener('focusin', handlePause);
           wrapper.removeEventListener('focusout', handleFocusOutResume);
           wrapper.removeEventListener('pointermove', handlePause);
           wrapper.removeEventListener('pointerleave', handlePointerLeaveResume);
-          window.removeEventListener('blur', handlePause);
-          window.removeEventListener('focus', handleResume);
+          documentWindow.removeEventListener('blur', handlePause);
+          documentWindow.removeEventListener('focus', handleResume);
         };
       }
-    }, [hasToasts, context.isClosePausedRef]);
+    }, [hasToasts, context.isClosePausedRef, providedDocument]);
 
     const getSortedTabbableCandidates = React.useCallback(
       ({ tabbingDirection }: { tabbingDirection: 'forwards' | 'backwards' }) => {
         const toastItems = getItems();
         const tabbableCandidates = toastItems.map((toastItem) => {
           const toastNode = toastItem.ref.current!;
-          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)];
+          const toastTabbableCandidates = [
+            toastNode,
+            ...getTabbableCandidates(toastNode, providedDocument ?? globalThis.document),
+          ];
           return tabbingDirection === 'forwards'
             ? toastTabbableCandidates
             : toastTabbableCandidates.reverse();
@@ -229,7 +238,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
           tabbingDirection === 'forwards' ? tabbableCandidates.reverse() : tabbableCandidates
         ).flat();
       },
-      [getItems]
+      [getItems, providedDocument]
     );
 
     React.useEffect(() => {
@@ -243,7 +252,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
           const isTabKey = event.key === 'Tab' && !isMetaKey;
 
           if (isTabKey) {
-            const focusedElement = document.activeElement;
+            const focusedElement = providedDocument?.activeElement;
             const isTabbingBackwards = event.shiftKey;
             const targetIsViewport = event.target === viewport;
 
@@ -257,7 +266,9 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
             const tabbingDirection = isTabbingBackwards ? 'backwards' : 'forwards';
             const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });
             const index = sortedCandidates.findIndex((candidate) => candidate === focusedElement);
-            if (focusFirst(sortedCandidates.slice(index + 1))) {
+            if (
+              focusFirst(sortedCandidates.slice(index + 1), providedDocument ?? globalThis.document)
+            ) {
               event.preventDefault();
             } else {
               // If we can't focus that means we're at the edges so we
@@ -274,7 +285,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
         viewport.addEventListener('keydown', handleKeyDown);
         return () => viewport.removeEventListener('keydown', handleKeyDown);
       }
-    }, [getItems, getSortedTabbableCandidates]);
+    }, [getItems, getSortedTabbableCandidates, providedDocument]);
 
     return (
       <DismissableLayer.Branch
@@ -294,7 +305,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
               const tabbableCandidates = getSortedTabbableCandidates({
                 tabbingDirection: 'forwards',
               });
-              focusFirst(tabbableCandidates);
+              focusFirst(tabbableCandidates, providedDocument ?? globalThis.document);
             }}
           />
         )}
@@ -312,7 +323,7 @@ const ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>
               const tabbableCandidates = getSortedTabbableCandidates({
                 tabbingDirection: 'backwards',
               });
-              focusFirst(tabbableCandidates);
+              focusFirst(tabbableCandidates, providedDocument ?? globalThis.document);
             }}
           />
         )}
@@ -489,10 +500,12 @@ const ToastImpl = React.forwardRef<ToastImplElement, ToastImplProps>(
     const closeTimerRemainingTimeRef = React.useRef(duration);
     const closeTimerRef = React.useRef(0);
     const { onToastAdd, onToastRemove } = context;
+    const providedDocument = useDocument();
     const handleClose = useCallbackRef(() => {
       // focus viewport if focus is within toast to read the remaining toast
       // count to SR users and ensure focus isn't lost
-      const isFocusInToast = node?.contains(document.activeElement);
+      if (!providedDocument) return;
+      const isFocusInToast = node?.contains(providedDocument.activeElement);
       if (isFocusInToast) context.viewport?.focus();
       onClose();
     });
@@ -500,9 +513,9 @@ const ToastImpl = React.forwardRef<ToastImplElement, ToastImplProps>(
     const startTimer = React.useCallback(
       (duration: number) => {
         if (!duration || duration === Infinity) return;
-        window.clearTimeout(closeTimerRef.current);
+        globalThis.window.clearTimeout(closeTimerRef.current);
         closeTimerStartTimeRef.current = new Date().getTime();
-        closeTimerRef.current = window.setTimeout(handleClose, duration);
+        closeTimerRef.current = globalThis.window.setTimeout(handleClose, duration);
       },
       [handleClose]
     );
@@ -517,7 +530,7 @@ const ToastImpl = React.forwardRef<ToastImplElement, ToastImplProps>(
         const handlePause = () => {
           const elapsedTime = new Date().getTime() - closeTimerStartTimeRef.current;
           closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
-          window.clearTimeout(closeTimerRef.current);
+          globalThis.window.clearTimeout(closeTimerRef.current);
           onPause?.();
         };
         viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
@@ -687,8 +700,8 @@ const ToastAnnounce: React.FC<ToastAnnounceProps> = (props: ScopedProps<ToastAnn
 
   // cleanup after announcing
   React.useEffect(() => {
-    const timer = window.setTimeout(() => setIsAnnounced(true), 1000);
-    return () => window.clearTimeout(timer);
+    const timer = globalThis.window.setTimeout(() => setIsAnnounced(true), 1000);
+    return () => globalThis.window.clearTimeout(timer);
   }, []);
 
   return isAnnounced ? null : (
@@ -900,10 +913,12 @@ function useNextFrame(callback = () => {}) {
   useLayoutEffect(() => {
     let raf1 = 0;
     let raf2 = 0;
-    raf1 = window.requestAnimationFrame(() => (raf2 = window.requestAnimationFrame(fn)));
+    raf1 = globalThis.window.requestAnimationFrame(
+      () => (raf2 = globalThis.window.requestAnimationFrame(fn))
+    );
     return () => {
-      window.cancelAnimationFrame(raf1);
-      window.cancelAnimationFrame(raf2);
+      globalThis.window.cancelAnimationFrame(raf1);
+      globalThis.window.cancelAnimationFrame(raf2);
     };
   }, [fn]);
 }
@@ -922,9 +937,9 @@ function isHTMLElement(node: any): node is HTMLElement {
  * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
  * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
  */
-function getTabbableCandidates(container: HTMLElement) {
+function getTabbableCandidates(container: HTMLElement, providedDocument: Document) {
   const nodes: HTMLElement[] = [];
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+  const walker = providedDocument.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
     acceptNode: (node: any) => {
       const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
       if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
@@ -940,13 +955,13 @@ function getTabbableCandidates(container: HTMLElement) {
   return nodes;
 }
 
-function focusFirst(candidates: HTMLElement[]) {
-  const previouslyFocusedElement = document.activeElement;
+function focusFirst(candidates: HTMLElement[], providedDocument: Document) {
+  const previouslyFocusedElement = providedDocument.activeElement;
   return candidates.some((candidate) => {
     // if focus is already where we want to go, we don't want to keep going through the candidates
     if (candidate === previouslyFocusedElement) return true;
     candidate.focus();
-    return document.activeElement !== previouslyFocusedElement;
+    return providedDocument.activeElement !== previouslyFocusedElement;
   });
 }
 
diff --git a/packages/react/tooltip/package.json b/packages/react/tooltip/package.json
index d8749d36b..be21b5728 100644
--- a/packages/react/tooltip/package.json
+++ b/packages/react/tooltip/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-compose-refs": "workspace:*",
     "@radix-ui/react-context": "workspace:*",
     "@radix-ui/react-dismissable-layer": "workspace:*",
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-id": "workspace:*",
     "@radix-ui/react-popper": "workspace:*",
     "@radix-ui/react-portal": "workspace:*",
diff --git a/packages/react/tooltip/src/tooltip.tsx b/packages/react/tooltip/src/tooltip.tsx
index 924644673..880b3d9a2 100644
--- a/packages/react/tooltip/src/tooltip.tsx
+++ b/packages/react/tooltip/src/tooltip.tsx
@@ -14,6 +14,7 @@ import { useControllableState } from '@radix-ui/react-use-controllable-state';
 import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
 
 import type { Scope } from '@radix-ui/react-context';
+import { useDocument } from '@radix-ui/react-document-context';
 
 type ScopedProps<P = {}> = P & { __scopeTooltip?: Scope };
 const [createTooltipContext, createTooltipScope] = createContextScope('Tooltip', [
@@ -77,7 +78,7 @@ const TooltipProvider: React.FC<TooltipProviderProps> = (
 
   React.useEffect(() => {
     const skipDelayTimer = skipDelayTimerRef.current;
-    return () => window.clearTimeout(skipDelayTimer);
+    return () => globalThis.window.clearTimeout(skipDelayTimer);
   }, []);
 
   return (
@@ -86,12 +87,12 @@ const TooltipProvider: React.FC<TooltipProviderProps> = (
       isOpenDelayedRef={isOpenDelayedRef}
       delayDuration={delayDuration}
       onOpen={React.useCallback(() => {
-        window.clearTimeout(skipDelayTimerRef.current);
+        globalThis.window.clearTimeout(skipDelayTimerRef.current);
         isOpenDelayedRef.current = false;
       }, [])}
       onClose={React.useCallback(() => {
-        window.clearTimeout(skipDelayTimerRef.current);
-        skipDelayTimerRef.current = window.setTimeout(
+        globalThis.window.clearTimeout(skipDelayTimerRef.current);
+        skipDelayTimerRef.current = globalThis.window.setTimeout(
           () => (isOpenDelayedRef.current = true),
           skipDelayDuration
         );
@@ -168,6 +169,7 @@ const Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {
     disableHoverableContentProp ?? providerContext.disableHoverableContent;
   const delayDuration = delayDurationProp ?? providerContext.delayDuration;
   const wasOpenDelayedRef = React.useRef(false);
+  const providedDocument = useDocument();
   const [open, setOpen] = useControllableState({
     prop: openProp,
     defaultProp: defaultOpen ?? false,
@@ -177,7 +179,7 @@ const Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {
 
         // as `onChange` is called within a lifecycle method we
         // avoid dispatching via `dispatchDiscreteCustomEvent`.
-        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+        providedDocument?.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
       } else {
         providerContext.onClose();
       }
@@ -190,21 +192,21 @@ const Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {
   }, [open]);
 
   const handleOpen = React.useCallback(() => {
-    window.clearTimeout(openTimerRef.current);
+    globalThis.window.clearTimeout(openTimerRef.current);
     openTimerRef.current = 0;
     wasOpenDelayedRef.current = false;
     setOpen(true);
   }, [setOpen]);
 
   const handleClose = React.useCallback(() => {
-    window.clearTimeout(openTimerRef.current);
+    globalThis.window.clearTimeout(openTimerRef.current);
     openTimerRef.current = 0;
     setOpen(false);
   }, [setOpen]);
 
   const handleDelayedOpen = React.useCallback(() => {
-    window.clearTimeout(openTimerRef.current);
-    openTimerRef.current = window.setTimeout(() => {
+    globalThis.window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = globalThis.window.setTimeout(() => {
       wasOpenDelayedRef.current = true;
       setOpen(true);
       openTimerRef.current = 0;
@@ -214,7 +216,7 @@ const Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {
   React.useEffect(() => {
     return () => {
       if (openTimerRef.current) {
-        window.clearTimeout(openTimerRef.current);
+        globalThis.window.clearTimeout(openTimerRef.current);
         openTimerRef.current = 0;
       }
     };
@@ -238,7 +240,7 @@ const Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {
             handleClose();
           } else {
             // Clear the timer in case the pointer leaves the trigger before the tooltip is opened.
-            window.clearTimeout(openTimerRef.current);
+            globalThis.window.clearTimeout(openTimerRef.current);
             openTimerRef.current = 0;
           }
         }, [handleClose, disableHoverableContent])}
@@ -275,10 +277,11 @@ const TooltipTrigger = React.forwardRef<TooltipTriggerElement, TooltipTriggerPro
     const isPointerDownRef = React.useRef(false);
     const hasPointerMoveOpenedRef = React.useRef(false);
     const handlePointerUp = React.useCallback(() => (isPointerDownRef.current = false), []);
+    const providedDocument = useDocument();
 
     React.useEffect(() => {
-      return () => document.removeEventListener('pointerup', handlePointerUp);
-    }, [handlePointerUp]);
+      return () => providedDocument?.removeEventListener('pointerup', handlePointerUp);
+    }, [handlePointerUp, providedDocument]);
 
     return (
       <PopperPrimitive.Anchor asChild {...popperScope}>
@@ -308,7 +311,7 @@ const TooltipTrigger = React.forwardRef<TooltipTriggerElement, TooltipTriggerPro
               context.onClose();
             }
             isPointerDownRef.current = true;
-            document.addEventListener('pointerup', handlePointerUp, { once: true });
+            providedDocument?.addEventListener('pointerup', handlePointerUp, { once: true });
           })}
           onFocus={composeEventHandlers(props.onFocus, () => {
             if (!isPointerDownRef.current) context.onOpen();
@@ -411,6 +414,7 @@ const TooltipContentHoverable = React.forwardRef<
   const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);
   const ref = React.useRef<TooltipContentHoverableElement>(null);
   const composedRefs = useComposedRefs(forwardedRef, ref);
+  const providedDocument = useDocument();
   const [pointerGraceArea, setPointerGraceArea] = React.useState<Polygon | null>(null);
 
   const { trigger, onClose } = context;
@@ -470,10 +474,10 @@ const TooltipContentHoverable = React.forwardRef<
           onClose();
         }
       };
-      document.addEventListener('pointermove', handleTrackPointerGrace);
-      return () => document.removeEventListener('pointermove', handleTrackPointerGrace);
+      providedDocument?.addEventListener('pointermove', handleTrackPointerGrace);
+      return () => providedDocument?.removeEventListener('pointermove', handleTrackPointerGrace);
     }
-  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);
+  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea, providedDocument]);
 
   return <TooltipContentImpl {...props} ref={composedRefs} />;
 });
@@ -517,24 +521,33 @@ const TooltipContentImpl = React.forwardRef<TooltipContentImplElement, TooltipCo
     const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
     const popperScope = usePopperScope(__scopeTooltip);
     const { onClose } = context;
+    const providedDocument = useDocument();
 
     // Close this tooltip if another one opens
     React.useEffect(() => {
-      document.addEventListener(TOOLTIP_OPEN, onClose);
-      return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
-    }, [onClose]);
+      if (providedDocument) {
+        providedDocument.addEventListener(TOOLTIP_OPEN, onClose);
+        return () => providedDocument.removeEventListener(TOOLTIP_OPEN, onClose);
+      }
+    }, [onClose, providedDocument]);
 
     // Close the tooltip if the trigger is scrolled
+    const documentWindow = providedDocument?.defaultView;
     React.useEffect(() => {
+      if (!documentWindow) return;
+
       if (context.trigger) {
         const handleScroll = (event: Event) => {
           const target = event.target as HTMLElement;
           if (target?.contains(context.trigger)) onClose();
         };
-        window.addEventListener('scroll', handleScroll, { capture: true });
-        return () => window.removeEventListener('scroll', handleScroll, { capture: true });
+        documentWindow.addEventListener('scroll', handleScroll, { capture: true });
+        return () =>
+          documentWindow.removeEventListener('scroll', handleScroll, {
+            capture: true,
+          });
       }
-    }, [context.trigger, onClose]);
+    }, [context.trigger, onClose, documentWindow]);
 
     return (
       <DismissableLayer
diff --git a/packages/react/use-escape-keydown/package.json b/packages/react/use-escape-keydown/package.json
index 2f2f638ae..866ce4acd 100644
--- a/packages/react/use-escape-keydown/package.json
+++ b/packages/react/use-escape-keydown/package.json
@@ -34,6 +34,7 @@
     "build": "radix-build"
   },
   "dependencies": {
+    "@radix-ui/react-document-context": "workspace:*",
     "@radix-ui/react-use-callback-ref": "workspace:*"
   },
   "devDependencies": {
diff --git a/packages/react/use-escape-keydown/src/use-escape-keydown.tsx b/packages/react/use-escape-keydown/src/use-escape-keydown.tsx
index 58485d5ec..a5eaf814e 100644
--- a/packages/react/use-escape-keydown/src/use-escape-keydown.tsx
+++ b/packages/react/use-escape-keydown/src/use-escape-keydown.tsx
@@ -1,24 +1,28 @@
 import * as React from 'react';
 import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
+import { useDocument } from '@radix-ui/react-document-context';
 
 /**
  * Listens for when the escape key is down
  */
 function useEscapeKeydown(
   onEscapeKeyDownProp?: (event: KeyboardEvent) => void,
-  ownerDocument: Document = globalThis?.document
+  ownerDocument?: Document
 ) {
+  const providedDocument = useDocument();
+  const document = ownerDocument || providedDocument;
   const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
 
   React.useEffect(() => {
+    const _document = document || globalThis.document;
     const handleKeyDown = (event: KeyboardEvent) => {
       if (event.key === 'Escape') {
         onEscapeKeyDown(event);
       }
     };
-    ownerDocument.addEventListener('keydown', handleKeyDown, { capture: true });
-    return () => ownerDocument.removeEventListener('keydown', handleKeyDown, { capture: true });
-  }, [onEscapeKeyDown, ownerDocument]);
+    _document.addEventListener('keydown', handleKeyDown, { capture: true });
+    return () => _document.removeEventListener('keydown', handleKeyDown, { capture: true });
+  }, [onEscapeKeyDown, document]);
 }
 
 export { useEscapeKeydown };
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fe33b15c6..5af133e11 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -457,6 +457,9 @@ importers:
       '@radix-ui/react-dialog':
         specifier: workspace:*
         version: link:../dialog
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -605,6 +608,9 @@ importers:
       '@radix-ui/react-context':
         specifier: workspace:*
         version: link:../context
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -925,6 +931,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-focus-guards':
         specifier: workspace:*
         version: link:../focus-guards
@@ -1022,6 +1031,9 @@ importers:
       '@radix-ui/react-compose-refs':
         specifier: workspace:*
         version: link:../compose-refs
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -1063,6 +1075,43 @@ importers:
         specifier: ^5.7.3
         version: 5.8.3
 
+  packages/react/document-context:
+    dependencies:
+      '@radix-ui/react-use-is-hydrated':
+        specifier: workspace:*
+        version: link:../use-is-hydrated
+    devDependencies:
+      '@repo/builder':
+        specifier: workspace:*
+        version: link:../../../internal/builder
+      '@repo/eslint-config':
+        specifier: workspace:*
+        version: link:../../../internal/eslint-config
+      '@repo/test-data':
+        specifier: workspace:*
+        version: link:../../../internal/test-data
+      '@repo/typescript-config':
+        specifier: workspace:*
+        version: link:../../../internal/typescript-config
+      '@types/react':
+        specifier: ^19.0.7
+        version: 19.1.0
+      '@types/react-dom':
+        specifier: ^19.0.3
+        version: 19.1.1(@types/react@19.1.0)
+      eslint:
+        specifier: ^9.18.0
+        version: 9.24.0
+      react:
+        specifier: ^19.1.0
+        version: 19.1.0
+      react-dom:
+        specifier: ^19.1.0
+        version: 19.1.0(react@19.1.0)
+      typescript:
+        specifier: ^5.7.3
+        version: 5.8.3
+
   packages/react/dropdown-menu:
     dependencies:
       '@radix-ui/primitive':
@@ -1119,6 +1168,10 @@ importers:
         version: 5.8.3
 
   packages/react/focus-guards:
+    dependencies:
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
     devDependencies:
       '@repo/builder':
         specifier: workspace:*
@@ -1153,6 +1206,9 @@ importers:
       '@radix-ui/react-compose-refs':
         specifier: workspace:*
         version: link:../compose-refs
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -1251,6 +1307,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-popper':
         specifier: workspace:*
         version: link:../popper
@@ -1383,6 +1442,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-focus-guards':
         specifier: workspace:*
         version: link:../focus-guards
@@ -1535,6 +1597,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-id':
         specifier: workspace:*
         version: link:../id
@@ -1608,6 +1673,9 @@ importers:
       '@radix-ui/react-direction':
         specifier: workspace:*
         version: link:../direction
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -1666,6 +1734,9 @@ importers:
       '@radix-ui/react-context':
         specifier: workspace:*
         version: link:../context
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-id':
         specifier: workspace:*
         version: link:../id
@@ -1800,6 +1871,9 @@ importers:
       '@radix-ui/react-context':
         specifier: workspace:*
         version: link:../context
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -1849,6 +1923,9 @@ importers:
 
   packages/react/portal:
     dependencies:
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-primitive':
         specifier: workspace:*
         version: link:../primitive
@@ -2006,6 +2083,9 @@ importers:
       '@radix-ui/react-direction':
         specifier: workspace:*
         version: link:../direction
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-presence':
         specifier: workspace:*
         version: link:../presence
@@ -2103,6 +2183,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-dropdown-menu':
         specifier: workspace:*
         version: link:../dropdown-menu
@@ -2266,6 +2349,9 @@ importers:
       '@radix-ui/react-direction':
         specifier: workspace:*
         version: link:../direction
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-id':
         specifier: workspace:*
         version: link:../id
@@ -2324,6 +2410,9 @@ importers:
       '@radix-ui/react-direction':
         specifier: workspace:*
         version: link:../direction
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-presence':
         specifier: workspace:*
         version: link:../presence
@@ -2388,6 +2477,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-focus-guards':
         specifier: workspace:*
         version: link:../focus-guards
@@ -2718,6 +2810,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-portal':
         specifier: workspace:*
         version: link:../portal
@@ -2926,6 +3021,9 @@ importers:
       '@radix-ui/react-dismissable-layer':
         specifier: workspace:*
         version: link:../dismissable-layer
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-id':
         specifier: workspace:*
         version: link:../id
@@ -3085,6 +3183,9 @@ importers:
 
   packages/react/use-escape-keydown:
     dependencies:
+      '@radix-ui/react-document-context':
+        specifier: workspace:*
+        version: link:../document-context
       '@radix-ui/react-use-callback-ref':
         specifier: workspace:*
         version: link:../use-callback-ref