@uniflowed/ui 0.0.0-alpha.40 → 0.0.0-alpha.42

package/internal/menu-tree.js

@@ -100,7 +100,7 @@ export type MenuState = {|
    * lands on the last item, and re-rendering the trigger to say so would be a
    * render whose only purpose is to carry a message to an effect.
    */
-  readonly pendingFocus: { current: "first" | "last" | null },
+  readonly pendingFocusRef: { current: "first" | "last" | null },
   /** The menu this one hangs off, or null for the outermost. */
   readonly parent: MenuState | null,
   /**
@@ -207,7 +207,7 @@ export component MenuLevel(
   const base = useId();
   const [isOpen, setOpen] = useControlled(open, defaultOpen, onOpenChange);
   const triggerRef = useRef<HTMLElement | null>(null);
-  const pendingFocus = useRef<"first" | "last" | null>(null);
+  const pendingFocusRef = useRef<"first" | "last" | null>(null);
   const [triggered, setTriggered] = useState(false);
 
   const state = useMemo(
@@ -216,7 +216,7 @@ export component MenuLevel(
       open: isOpen,
       setOpen,
       triggerRef,
-      pendingFocus,
+      pendingFocusRef,
       parent,
       triggered,
       registerTrigger: setTriggered,

package/internal/roving-focus.js

@@ -346,6 +346,8 @@ export hook useFirstItem(
       false,
       set.skipDisabled,
     );
+    // The first item is only knowable after the caller's items are in the DOM.
+    // uf-lint-disable-next-line react-compiler/set-state-in-effect
     setFirst(landing?.id ?? null);
   });
 

package/menu.js

@@ -243,10 +243,14 @@ export component MenuTrigger(children: React.Node, render?: RenderProp, ...rest:
         return;
       }
       event.preventDefault();
-      menu.pendingFocus.current = end;
+      // This is an instruction for the menu body after the opening commit.
+      // uf-lint-disable-next-line react-compiler/immutability
+      menu.pendingFocusRef.current = end;
       menu.setOpen(true);
     }),
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
+      // React calls callback refs during commit; the menu body reads the trigger later.
+      // uf-lint-disable-next-line react-compiler/immutability
       menu.triggerRef.current = element;
     }),
   });
@@ -296,7 +300,9 @@ export component MenuBody(
   // it re-ran on every parent render and re-took focus each time, dragging the
   // reader back to the first item while they were arrowing.
   const triggerRef = menu.triggerRef;
-  const pendingFocus = menu.pendingFocus;
+  const pendingFocusRef = menu.pendingFocusRef;
+  // `parent` is menu-tree metadata; no ref value is read during render.
+  // uf-lint-disable-next-line react-compiler/refs
   const isRoot = menu.parent == null;
   const closeAll = useStableCallback(() => closeTree(menu));
   // A root menu drops from its button; a submenu comes out of the side of the
@@ -304,14 +310,20 @@ export component MenuBody(
   // be a parameter default because it is not a constant: it is the answer to
   // "is this the outermost menu", which only this component knows.
   const placement = side ?? (isRoot ? "bottom" : "inline-end");
+  // useAnchor accepts ref objects and reads them from layout/effects.
+  // uf-lint-disable-next-line react-compiler/refs
   const anchored = useAnchor({
     align,
     alignOffset,
     anchorRect: point,
+    // uf-lint-disable-next-line react-compiler/refs
     anchorRef: triggerRef,
     avoidCollisions,
     collisionPadding,
+    // `open` is menu-tree metadata; no ref value is read during render.
+    // uf-lint-disable-next-line react-compiler/refs
     open: menu.open,
+    // uf-lint-disable-next-line react-compiler/refs
     overlayRef: bodyRef,
     side: placement,
     sideOffset,
@@ -328,8 +340,8 @@ export component MenuBody(
     const document = body.ownerDocument;
     const trigger = triggerRef.current;
 
-    const wanted = pendingFocus.current;
-    pendingFocus.current = null;
+    const wanted = pendingFocusRef.current;
+    pendingFocusRef.current = null;
     const items = itemsOf(body, ITEM_SELECTOR, MENU_SELECTOR);
     const landing = moveTo(items, -1, wanted === "last" ? "last" : "first", false);
     // The menu itself when it holds nothing focusable, so focus is inside it
@@ -352,32 +364,47 @@ export component MenuBody(
         trigger?.focus?.();
       }
     };
-  }, [menu.open, triggerRef, pendingFocus]);
+    // The ref objects are stable; this effect reads them after the opening commit.
+    // uf-lint-disable-next-line react-compiler/refs
+  }, [menu.open, triggerRef, pendingFocusRef]);
 
   // Only the outermost menu listens. A submenu closes with the tree, and two
   // of these would each answer the same press.
+  // The outside-interaction hook accepts refs; it reads them from event handlers.
+  // uf-lint-disable-next-line react-compiler/refs
   useInteractOutside({
+    // `open` is menu-tree metadata; the hook reads refs from event handlers.
+    // uf-lint-disable-next-line react-compiler/refs
     isDisabled: !menu.open || !isRoot,
     onInteractOutside: () => {
       dismissed.current = true;
       closeAll();
     },
+    // uf-lint-disable-next-line react-compiler/refs
     refs: [bodyRef, triggerRef],
   });
 
   const list = useMemo(() => ({ activeId, setActiveId }), [activeId]);
 
+  // `open` is menu-tree metadata; no ref value is read during render.
+  // uf-lint-disable-next-line react-compiler/refs
   if (!menu.open) {
     return null;
   }
 
   const props = withProps(withoutComposed(rest, ["onKeyDown", "ref"]), {
+    // `triggered` and `base` are menu-tree metadata, not ref values.
+    // uf-lint-disable-next-line react-compiler/refs
     "aria-labelledby": menu.triggered ? `${menu.base}-trigger` : undefined,
     "aria-orientation": "vertical",
     children,
     "data-align": anchored.align,
     "data-side": anchored.side,
+    // `base` is menu-tree metadata, not a ref value.
+    // uf-lint-disable-next-line react-compiler/refs
     id: `${menu.base}-body`,
+    // Key handling moves real DOM focus and records the active item after events.
+    // uf-lint-disable-next-line react-compiler/refs
     onKeyDown: composeHandlers(rest.onKeyDown, (event: PartEvent) => {
       const body: $FlowFixMe = event.currentTarget;
       const items = itemsOf(body, ITEM_SELECTOR, MENU_SELECTOR);
@@ -438,6 +465,8 @@ export component MenuBody(
         }
       }
     }),
+    // React calls callback refs during commit; placement and keyboard effects read it later.
+    // uf-lint-disable-next-line react-compiler/refs
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
       bodyRef.current = element;
     }),
@@ -709,7 +738,9 @@ export component MenuSubTrigger(children: React.Node, render?: RenderProp, ...re
   const id = `${menu.base}-trigger`;
 
   const open = () => {
-    menu.pendingFocus.current = "first";
+    // This is an instruction for the submenu body after the opening commit.
+    // uf-lint-disable-next-line react-compiler/immutability
+    menu.pendingFocusRef.current = "first";
     menu.setOpen(true);
   };
 
@@ -733,6 +764,8 @@ export component MenuSubTrigger(children: React.Node, render?: RenderProp, ...re
       open();
     }),
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
+      // React calls callback refs during commit; the submenu body reads the trigger later.
+      // uf-lint-disable-next-line react-compiler/immutability
       menu.triggerRef.current = element;
     }),
     role: "menuitem",

package/menubar.js

@@ -187,6 +187,8 @@ export component MenubarRoot(children: renders* MenubarMenu, render?: RenderProp
         setActive(value);
       }
     }),
+    // React calls callback refs during commit; keyboard handlers read it later.
+    // uf-lint-disable-next-line react-compiler/refs
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
       barRef.current = element;
     }),
@@ -271,10 +273,15 @@ export component MenubarTrigger(children: React.Node, render?: RenderProp, ...re
         return;
       }
       event.preventDefault();
-      menu.pendingFocus.current = end;
+      // This is an instruction for the menu body after the opening commit.
+      // uf-lint-disable-next-line react-compiler/immutability
+      menu.pendingFocusRef.current = end;
       bar.setOpen(value);
     }),
+    // React calls callback refs during commit; menu focus restoration reads it later.
+    // uf-lint-disable-next-line react-compiler/refs
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
+      // uf-lint-disable-next-line react-compiler/immutability
       menu.triggerRef.current = element;
     }),
     role: "menuitem",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/ui",
-  "version": "0.0.0-alpha.40",
+  "version": "0.0.0-alpha.42",
   "description": "Headless, accessible React components whose composition Flow checks, part of the Unified Toolchain for Flow.",
   "type": "module",
   "license": "MIT",
@@ -19,10 +19,10 @@
     "!*.test.js"
   ],
   "dependencies": {
-    "@uniflowed/core": "0.0.0-alpha.40",
-    "@uniflowed/hooks": "0.0.0-alpha.40",
-    "@uniflowed/react": "0.0.0-alpha.40",
-    "@uniflowed/state": "0.0.0-alpha.40"
+    "@uniflowed/core": "0.0.0-alpha.42",
+    "@uniflowed/hooks": "0.0.0-alpha.42",
+    "@uniflowed/react": "0.0.0-alpha.42",
+    "@uniflowed/state": "0.0.0-alpha.42"
   },
   "peerDependencies": {
     "react": ">=19"

package/popover.js

@@ -167,6 +167,8 @@ export component PopoverTrigger(children: React.Node, render?: RenderProp, ...re
     id: `${popover.base}-trigger`,
     onClick: composeHandlers(rest.onClick, () => popover.setOpen(!popover.open)),
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
+      // React calls callback refs during commit; focus restoration reads it later.
+      // uf-lint-disable-next-line react-compiler/immutability
       popover.triggerRef.current = element;
     }),
   });
@@ -220,13 +222,19 @@ export component PopoverBody(
   const left = useRef(false);
   const triggerRef = popover.triggerRef;
 
+  // useAnchor accepts ref objects and reads them from layout/effects.
+  // uf-lint-disable-next-line react-compiler/refs
   const anchored = useAnchor({
     align,
     alignOffset,
+    // uf-lint-disable-next-line react-compiler/refs
     anchorRef: triggerRef,
     avoidCollisions,
     collisionPadding,
+    // `open` is popover metadata; no ref value is read during render.
+    // uf-lint-disable-next-line react-compiler/refs
     open: popover.open,
+    // uf-lint-disable-next-line react-compiler/refs
     overlayRef: bodyRef,
     side,
     sideOffset,
@@ -286,19 +294,28 @@ export component PopoverBody(
         opener?.focus?.();
       }
     };
+    // The ref objects are stable; this effect reads them after the opening commit.
+    // uf-lint-disable-next-line react-compiler/refs
   }, [popover.open, triggerRef, close, initialFocus]);
 
   // A press outside is the other way a reader leaves, and the trigger is not
   // "outside" for the reason the module header gives.
+  // The outside-interaction hook accepts refs; it reads them from event handlers.
+  // uf-lint-disable-next-line react-compiler/refs
   useInteractOutside({
+    // `open` is popover metadata; the hook reads refs from event handlers.
+    // uf-lint-disable-next-line react-compiler/refs
     isDisabled: !popover.open,
     onInteractOutside: () => {
       left.current = true;
       close();
     },
+    // uf-lint-disable-next-line react-compiler/refs
     refs: [bodyRef, triggerRef],
   });
 
+  // `open` is popover metadata; no ref value is read during render.
+  // uf-lint-disable-next-line react-compiler/refs
   if (!popover.open) {
     return null;
   }
@@ -310,11 +327,15 @@ export component PopoverBody(
   const named = rest["aria-label"] != null || rest["aria-labelledby"] != null;
 
   const props = withProps(passed, {
+    // `triggered` and `base` are popover metadata, not ref values.
+    // uf-lint-disable-next-line react-compiler/refs
     "aria-labelledby": named || !popover.triggered ? undefined : `${popover.base}-trigger`,
     children,
     "data-align": anchored.align,
     "data-side": anchored.side,
     "data-state": "open",
+    // `base` is popover metadata, not a ref value.
+    // uf-lint-disable-next-line react-compiler/refs
     id: `${popover.base}-body`,
     onKeyDown: composeHandlers(rest.onKeyDown, (event: PartEvent) => {
       if (event.key !== "Escape") {
@@ -326,6 +347,8 @@ export component PopoverBody(
       event.stopPropagation();
       close();
     }),
+    // React calls callback refs during commit; placement effects and traps read it later.
+    // uf-lint-disable-next-line react-compiler/refs
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
       bodyRef.current = element;
     }),

package/radio-group.js

@@ -208,6 +208,8 @@ export component RadioGroupRoot(
         select(next.getAttribute("data-value") ?? "");
       }
     }),
+    // React calls callback refs during commit; keyboard handlers read it later.
+    // uf-lint-disable-next-line react-compiler/refs
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
       rootRef.current = element;
     }),

package/resizable.js

@@ -332,6 +332,8 @@ export component ResizableHandle(label?: string = "Resize", ...rest: Rest) {
       aria-valuemax={group.max}
       aria-valuemin={group.min}
       aria-valuenow={group.value}
+      // Key and pointer handlers keep gesture state in refs between events.
+      // uf-lint-disable-next-line react-compiler/refs
       onKeyDown={composeHandlers(rest.onKeyDown, (event: $FlowFixMe) => {
         if (group.disabled) {
           return;
@@ -373,7 +375,9 @@ export component ResizableHandle(label?: string = "Resize", ...rest: Rest) {
           moveBy(amount);
         }
       })}
+      // uf-lint-disable-next-line react-compiler/refs
       onPointerCancel={composeHandlers(rest.onPointerCancel, endDrag)}
+      // uf-lint-disable-next-line react-compiler/refs
       onPointerDown={composeHandlers(rest.onPointerDown, (event: $FlowFixMe) => {
         if (group.disabled) {
           return;
@@ -395,6 +399,7 @@ export component ResizableHandle(label?: string = "Resize", ...rest: Rest) {
         // it to move. The module header says what a press does on a track
         // instead, and why the two are not the same gesture.
       })}
+      // uf-lint-disable-next-line react-compiler/refs
       onPointerMove={composeHandlers(rest.onPointerMove, (event: $FlowFixMe) => {
         if (!dragging.current) {
           return;
@@ -404,6 +409,7 @@ export component ResizableHandle(label?: string = "Resize", ...rest: Rest) {
           group.setValue(share);
         }
       })}
+      // uf-lint-disable-next-line react-compiler/refs
       onPointerUp={composeHandlers(rest.onPointerUp, endDrag)}
       role="separator"
       // A separator that is not in the tab sequence is the WCAG 2.1.1 failure

package/scroll-area.js

@@ -72,10 +72,10 @@ type ScrollAreaState = {|
   readonly base: string,
   readonly label: string,
   readonly viewportRef: { current: HTMLElement | null },
-  readonly remembered: { current: Offset },
+  readonly rememberedRef: { current: Offset },
   /** Written by the viewport, read by every scrollbar. */
   readonly report: () => void,
-  readonly scrollbars: { current: Array<HTMLElement> },
+  readonly scrollbarsRef: { current: Array<HTMLElement> },
 |};
 
 const ScrollAreaContext: React.Context<ScrollAreaState | null> = createContext(null);
@@ -106,24 +106,24 @@ hook useScrollArea(part: string): ScrollAreaState {
 export component ScrollAreaRoot(children: React.Node, label: string, ...rest: Rest) {
   const base = useId();
   const viewportRef = useRef<HTMLElement | null>(null);
-  const remembered = useRef<Offset>({ x: 0, y: 0 });
-  const scrollbars = useRef<Array<HTMLElement>>([]);
+  const rememberedRef = useRef<Offset>({ x: 0, y: 0 });
+  const scrollbarsRef = useRef<Array<HTMLElement>>([]);
 
   const state = useMemo(
     () => ({
       base,
       label,
-      remembered,
+      rememberedRef,
       report: () => {
         const viewport = viewportRef.current;
         if (viewport == null) {
           return;
         }
-        for (const scrollbar of scrollbars.current) {
+        for (const scrollbar of scrollbarsRef.current) {
           write(scrollbar, viewport);
         }
       },
-      scrollbars,
+      scrollbarsRef,
       viewportRef,
     }),
     [base, label],
@@ -145,7 +145,7 @@ export component ScrollAreaRoot(children: React.Node, label: string, ...rest: Re
  */
 export component ScrollAreaViewport(children: React.Node, ...rest: Rest) {
   const area = useScrollArea("ScrollArea.Viewport");
-  const { remembered, report, viewportRef } = area;
+  const { rememberedRef, report, viewportRef } = area;
   const passed = withoutComposed(rest, ["ref"]);
 
   useEventListener(viewportRef, "scroll", () => {
@@ -155,7 +155,7 @@ export component ScrollAreaViewport(children: React.Node, ...rest: Rest) {
     }
     // The reader's own position, including a deliberate scroll back to the
     // top — which is why the restore below never fights them.
-    remembered.current = { x: viewport.scrollLeft, y: viewport.scrollTop };
+    rememberedRef.current = { x: viewport.scrollLeft, y: viewport.scrollTop };
     report();
   });
 
@@ -167,7 +167,7 @@ export component ScrollAreaViewport(children: React.Node, ...rest: Rest) {
     if (viewport == null) {
       return;
     }
-    const { x, y } = remembered.current;
+    const { x, y } = rememberedRef.current;
     if (y !== 0 && viewport.scrollTop === 0) {
       viewport.scrollTop = y;
     }
@@ -213,7 +213,7 @@ export component ScrollAreaScrollbar(
   ...rest: Rest
 ) {
   const area = useScrollArea("ScrollArea.Scrollbar");
-  const { report, scrollbars } = area;
+  const { report, scrollbarsRef } = area;
   const passed = withoutComposed(rest, ["ref"]);
 
   return (
@@ -225,8 +225,8 @@ export component ScrollAreaScrollbar(
       aria-hidden="true"
       data-orientation={orientation}
       ref={composeRefs(rest.ref, (element: HTMLElement | null) => {
-        const kept = scrollbars.current.filter((each) => each !== element);
-        scrollbars.current = element == null ? kept : [...kept, element];
+        const kept = scrollbarsRef.current.filter((each) => each !== element);
+        scrollbarsRef.current = element == null ? kept : [...kept, element];
         report();
       })}
     >

package/select.js

@@ -192,7 +192,7 @@ type SelectState = {|
   /** The id of the option `aria-activedescendant` names, if any. */
   readonly activeId: string | null,
   readonly setActiveId: (id: string | null) => void,
-  readonly pendingLanding: { current: Landing | null },
+  readonly pendingLandingRef: { current: Landing | null },
   readonly triggerRef: { current: HTMLElement | null },
   readonly listRef: { current: HTMLElement | null },
   /**
@@ -270,7 +270,7 @@ export component SelectRoot(
   const [activeId, setActiveId] = useState<string | null>(null);
   const [labels, setLabels] = useState<{ readonly [string]: string }>({});
   const [labelled, setLabelled] = useState(false);
-  const pendingLanding = useRef<Landing | null>(null);
+  const pendingLandingRef = useRef<Landing | null>(null);
   const triggerRef = useRef<HTMLElement | null>(null);
   const listRef = useRef<HTMLElement | null>(null);
   const typeahead = useTypeahead();
@@ -313,7 +313,7 @@ export component SelectRoot(
       choose,
       activeId,
       setActiveId,
-      pendingLanding,
+      pendingLandingRef,
       triggerRef,
       listRef,
       labels,
@@ -415,7 +415,9 @@ export component SelectTrigger(children: React.Node, ...rest: Rest) {
   /** Move the cursor within an open list, or open with an instruction. */
   const move = (end: Movement, preferSelected: boolean) => {
     if (!select.open) {
-      select.pendingLanding.current = { kind: "end", end, preferSelected };
+      // This is an instruction for the list after the opening commit.
+      // uf-lint-disable-next-line react-compiler/immutability
+      select.pendingLandingRef.current = { kind: "end", end, preferSelected };
       select.setOpen(true);
       return;
     }
@@ -458,7 +460,9 @@ export component SelectTrigger(children: React.Node, ...rest: Rest) {
           select.setActiveId(null);
           return;
         }
-        select.pendingLanding.current = { kind: "end", end: "first", preferSelected: true };
+        // This is an instruction for the list after the opening commit.
+        // uf-lint-disable-next-line react-compiler/immutability
+        select.pendingLandingRef.current = { kind: "end", end: "first", preferSelected: true };
         select.setOpen(true);
       })}
       onKeyDown={composeHandlers(rest.onKeyDown, (event: $FlowFixMe) => {
@@ -500,7 +504,9 @@ export component SelectTrigger(children: React.Node, ...rest: Rest) {
           // again as a click.
           event.preventDefault();
           if (!select.open) {
-            select.pendingLanding.current = { kind: "end", end: "first", preferSelected: true };
+            // This is an instruction for the list after the opening commit.
+            // uf-lint-disable-next-line react-compiler/immutability
+            select.pendingLandingRef.current = { kind: "end", end: "first", preferSelected: true };
             select.setOpen(true);
             return;
           }
@@ -544,7 +550,8 @@ export component SelectTrigger(children: React.Node, ...rest: Rest) {
           event.preventDefault();
           // The options are not in the document yet, so the keystroke travels
           // to the commit that renders them.
-          select.pendingLanding.current = { kind: "typed", key: event.key };
+          // uf-lint-disable-next-line react-compiler/immutability
+          select.pendingLandingRef.current = { kind: "typed", key: event.key };
           select.setOpen(true);
           return;
         }
@@ -560,6 +567,8 @@ export component SelectTrigger(children: React.Node, ...rest: Rest) {
         }
       })}
       ref={composeRefs(rest.ref, (element) => {
+        // React calls callback refs during commit; the list reads the trigger later.
+        // uf-lint-disable-next-line react-compiler/immutability
         select.triggerRef.current = element;
       })}
       role="combobox"
@@ -628,7 +637,8 @@ export component SelectList(
   ...rest: Rest
 ) {
   const select = useSelect("Select.List");
-  const { activeId, listRef, pendingLanding, setActiveId, triggerRef, typeahead, value } = select;
+  const { activeId, listRef, pendingLandingRef, setActiveId, triggerRef, typeahead, value } =
+    select;
   const close = useStableCallback(() => {
     select.setOpen(false);
     select.setActiveId(null);
@@ -656,6 +666,8 @@ export component SelectList(
   // render — a change to `children` that no dependency list can describe. Every
   // write is guarded by a comparison, so it settles after one extra pass rather
   // than looping.
+  // This effect measures caller-rendered options after commit.
+  // uf-lint-disable-next-line react-compiler/immutability
   useEffect(() => {
     const list = listRef.current;
     if (list == null) {
@@ -663,9 +675,10 @@ export component SelectList(
     }
     const items = itemsOf(list, OPTION_SELECTOR, LISTBOX_SELECTOR);
 
-    const wanted = pendingLanding.current;
+    const wanted = pendingLandingRef.current;
     if (wanted != null) {
-      pendingLanding.current = null;
+      // uf-lint-disable-next-line react-compiler/immutability
+      pendingLandingRef.current = null;
       // An `if` rather than a `match` on `wanted.kind`, because matching on a
       // property does not refine the object that property came from: inside
       // `match (wanted.kind)` both arms still see the whole union, and `uf

package/sidebar.js

@@ -275,7 +275,12 @@ export component SidebarItem(
   ...rest: Rest
 ) {
   const sidebar = useSidebar("Sidebar.Item");
+  // This removes the caller's ref from rest props; it does not read a ref value.
+  // uf-lint-disable-next-line react-compiler/refs
   const passed = withoutComposed(rest, ["ref"]);
+  // The forwarded ref is passed through to whichever entry wrapper renders.
+  // uf-lint-disable-next-line react-compiler/refs
+  const forwardedRef = rest.ref;
   const mine: Rest = {
     "aria-label": sidebar.collapsed ? label : undefined,
     children,
@@ -293,7 +298,9 @@ export component SidebarItem(
   };
 
   if (!sidebar.collapsed) {
-    return entry({ ref: rest.ref });
+    // The forwarded ref is passed through to the rendered entry.
+    // uf-lint-disable-next-line react-compiler/refs
+    return entry({ ref: forwardedRef });
   }
 
   // The icon's name, shown. A reader who can see the rail and not read minds
@@ -301,7 +308,7 @@ export component SidebarItem(
   // the mechanism that already satisfies WCAG 1.4.13 in this package.
   return (
     <TooltipRoot>
-      <TooltipTrigger ref={rest.ref} render={(props: Rest) => entry(props)} />
+      <TooltipTrigger ref={forwardedRef} render={(props: Rest) => entry(props)} />
       <TooltipBody
         {...forwarded(tooltipProps ?? {})}
         side={sidebar.side === "left" ? "right" : "left"}

package/skeleton.js

@@ -108,9 +108,13 @@ export component SkeletonRoot(
   useEffect(() => {
     if (busy) {
       waited.current = true;
+      // The live-region text changes after commit so assistive tech can announce it.
+      // uf-lint-disable-next-line react-compiler/set-state-in-effect
       setMessage(label);
       return;
     }
+    // The live-region text changes after commit so assistive tech can announce it.
+    // uf-lint-disable-next-line react-compiler/set-state-in-effect
     setMessage(waited.current ? doneLabel : "");
   }, [busy, doneLabel, label]);
 

package/slider.js

@@ -247,6 +247,8 @@ export component SliderTrack(children: React.Node, render?: RenderProp, ...rest:
 
   const props = withProps(passed, {
     children,
+    // Pointer handlers keep the active thumb in a ref between events.
+    // uf-lint-disable-next-line react-compiler/refs
     onPointerDown: composeHandlers(rest.onPointerDown, (event: $FlowFixMe) => {
       if (slider.disabled) {
         return;
@@ -257,16 +259,20 @@ export component SliderTrack(children: React.Node, render?: RenderProp, ...rest:
       event.currentTarget?.setPointerCapture?.(event.pointerId);
       moveTo(event, null);
     }),
+    // uf-lint-disable-next-line react-compiler/refs
     onPointerMove: composeHandlers(rest.onPointerMove, (event: $FlowFixMe) => {
       if (dragging.current != null) {
         moveTo(event, dragging.current);
       }
     }),
+    // uf-lint-disable-next-line react-compiler/refs
     onPointerUp: composeHandlers(rest.onPointerUp, (event: $FlowFixMe) => {
       dragging.current = null;
       event.currentTarget?.releasePointerCapture?.(event.pointerId);
     }),
     ref: composeRefs(rest.ref, (element: HTMLElement | null) => {
+      // React calls callback refs during commit; pointer handlers read the track later.
+      // uf-lint-disable-next-line react-compiler/immutability
       slider.trackRef.current = element;
     }),
   });