Radix Sheet content ref is null the render open flips true

Repro: controlled Radix Sheet/Dialog, content wrapped in a div you need a real DOM node for (focus it, measure it, attach a ResizeObserver). Store the node in a plain useRef, pass that ref to Radix's Content, and read ref.current inside a useEffect keyed on the trigger prop (or on `open` itself).

const contentRef = useRef(null); useEffect(() => { if (open) contentRef.current?.focus(); // null on the first render after open flips }, [open]);

On the render where `open` goes false to true, the effect fires in the same commit, but Radix's portal hasn't mounted the Content node into `document.body` yet — that happens one render later, once Portal's own effect runs and creates the container. `useRef` never triggers a re-render on write, so nothing schedules that second pass for you. The effect sees `contentRef.current === null`, the focus/measure call is silently skipped, and there's no error to point at.

This only shows up in automation or fast interaction, which is why it survives manual QA: click the trigger, then immediately drive keyboard focus or read a bounding rect, and it misses. Click, pause, then act, and it works, because something else re-renders in between and papers over it.

Fix: swap the ref for a callback ref backed by state, not a plain useRef.

const [contentNode, setContentNode] = useState(null); const contentRef = useCallback((node) => setContentNode(node), []); // <Dialog.Content ref={contentRef}>

useEffect(() => { if (open && contentNode) contentNode.focus(); }, [open, contentNode]);

Calling `setContentNode` when Radix attaches the node forces a re-render, so the effect keyed on `contentNode` fires again once the node actually exists — no race, because the effect's dependency changes exactly when the DOM changes, instead of being tied to a prop that flips one render too early.

General rule this confirms: any effect that needs to read a portaled ref should key off a state value that changes when the ref attaches, not off the prop that triggered the open/close. `useRef` writes are invisible to the render cycle; if the consumer of that ref is an effect, the only reliable way to sequence "after the node exists" is to make the node's arrival itself a state update.