@jobber/components 9.5.3 → 9.6.0

package/dist/SelectGroupLabel-cjs.js

@@ -6,8 +6,6 @@ var useRenderElement = require('./useRenderElement-cjs.js');
 var useCompositeListItem = require('./useCompositeListItem-cjs.js');
 var scrollEdges = require('./scrollEdges-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
-var floatingUi_utils = require('./floating-ui.utils-cjs.js');
-var floatingUi_reactDom = require('./floating-ui.react-dom-cjs.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -48,7 +46,7 @@ function usePreviousValue(value) {
     current: value,
     previous: null
   });
-  if (value !== state.current) {
+  if (!Object.is(value, state.current)) {
     setState({
       current: value,
       previous: state.current
@@ -63,8 +61,6 @@ function isElementDisabled(element) {
 
 const SelectRootContext = /*#__PURE__*/React__namespace.createContext(null);
 if (process.env.NODE_ENV !== "production") SelectRootContext.displayName = "SelectRootContext";
-const SelectFloatingContext = /*#__PURE__*/React__namespace.createContext(null);
-if (process.env.NODE_ENV !== "production") SelectFloatingContext.displayName = "SelectFloatingContext";
 function useSelectRootContext() {
   const context = React__namespace.useContext(SelectRootContext);
   if (context === null) {
@@ -72,25 +68,16 @@ function useSelectRootContext() {
   }
   return context;
 }
-function useSelectFloatingContext() {
-  const context = React__namespace.useContext(SelectFloatingContext);
-  if (context === null) {
-    throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: SelectFloatingContext is missing. Select parts must be placed within <Select.Root>.' : useRenderElement.formatErrorMessage(61));
-  }
-  return context;
-}
 
 const selectors = {
-  id: useScrollLock.createSelector(state => state.id),
-  labelId: useScrollLock.createSelector(state => state.labelId),
-  modal: useScrollLock.createSelector(state => state.modal),
-  multiple: useScrollLock.createSelector(state => state.multiple),
-  items: useScrollLock.createSelector(state => state.items),
-  itemToStringLabel: useScrollLock.createSelector(state => state.itemToStringLabel),
-  itemToStringValue: useScrollLock.createSelector(state => state.itemToStringValue),
-  isItemEqualToValue: useScrollLock.createSelector(state => state.isItemEqualToValue),
-  value: useScrollLock.createSelector(state => state.value),
-  hasSelectedValue: useScrollLock.createSelector(state => {
+  id: state => state.id,
+  labelId: state => state.labelId,
+  modal: state => state.modal,
+  items: state => state.items,
+  itemToStringLabel: state => state.itemToStringLabel,
+  isItemEqualToValue: state => state.isItemEqualToValue,
+  value: state => state.value,
+  hasSelectedValue: state => {
     const {
       value,
       multiple,
@@ -103,19 +90,19 @@ const selectors = {
       return value.length > 0;
     }
     return useCompositeListItem.stringifyAsValue(value, itemToStringValue) !== '';
-  }),
-  hasNullItemLabel: useScrollLock.createSelector((state, enabled) => {
+  },
+  hasNullItemLabel: (state, enabled) => {
     return enabled ? useCompositeListItem.hasNullItemLabel(state.items) : false;
-  }),
-  open: useScrollLock.createSelector(state => state.open),
-  mounted: useScrollLock.createSelector(state => state.mounted),
-  forceMount: useScrollLock.createSelector(state => state.forceMount),
-  transitionStatus: useScrollLock.createSelector(state => state.transitionStatus),
-  openMethod: useScrollLock.createSelector(state => state.openMethod),
-  activeIndex: useScrollLock.createSelector(state => state.activeIndex),
-  selectedIndex: useScrollLock.createSelector(state => state.selectedIndex),
-  isActive: useScrollLock.createSelector((state, index) => state.activeIndex === index),
-  isSelected: useScrollLock.createSelector((state, itemValue) => {
+  },
+  open: state => state.open,
+  mounted: state => state.mounted,
+  forceMount: state => state.forceMount,
+  transitionStatus: state => state.transitionStatus,
+  openMethod: state => state.openMethod,
+  activeIndex: state => state.activeIndex,
+  selectedIndex: state => state.selectedIndex,
+  isActive: (state, index) => state.activeIndex === index,
+  isSelected: (state, itemValue) => {
     const comparer = state.isItemEqualToValue;
     const storeValue = state.value;
     if (state.multiple) {
@@ -126,19 +113,19 @@ const selectors = {
     // value changes while the popup is open, where the index sync is deferred) must not
     // keep a previously selected item marked as selected.
     return useCompositeListItem.compareItemEquality(itemValue, storeValue, comparer);
-  }),
-  isSelectedByFocus: useScrollLock.createSelector((state, index) => {
+  },
+  isSelectedByFocus: (state, index) => {
     return state.selectedIndex === index;
-  }),
-  popupProps: useScrollLock.createSelector(state => state.popupProps),
-  triggerProps: useScrollLock.createSelector(state => state.triggerProps),
-  triggerElement: useScrollLock.createSelector(state => state.triggerElement),
-  positionerElement: useScrollLock.createSelector(state => state.positionerElement),
-  listElement: useScrollLock.createSelector(state => state.listElement),
-  popupSide: useScrollLock.createSelector(state => state.popupSide),
-  scrollUpArrowVisible: useScrollLock.createSelector(state => state.scrollUpArrowVisible),
-  scrollDownArrowVisible: useScrollLock.createSelector(state => state.scrollDownArrowVisible),
-  hasScrollArrows: useScrollLock.createSelector(state => state.hasScrollArrows)
+  },
+  popupProps: state => state.popupProps,
+  triggerProps: state => state.triggerProps,
+  triggerElement: state => state.triggerElement,
+  positionerElement: state => state.positionerElement,
+  listElement: state => state.listElement,
+  popupSide: state => state.popupSide,
+  scrollUpArrowVisible: state => state.scrollUpArrowVisible,
+  scrollDownArrowVisible: state => state.scrollDownArrowVisible,
+  hasScrollArrows: state => state.hasScrollArrows
 };
 
 function SelectRoot(props) {
@@ -224,7 +211,7 @@ function SelectRoot(props) {
     openMethod,
     triggerProps: interactionTypeProps
   } = useScrollLock.useOpenInteractionType(open);
-  const store = useRenderElement.useRefWithInit(() => new useScrollLock.Store({
+  const store = useRenderElement.useRefWithInit(() => new useScrollLock.ReactStore({
     id: generatedId,
     labelId: undefined,
     modal,
@@ -256,7 +243,7 @@ function SelectRoot(props) {
   const triggerElement = useScrollLock.useStore(store, selectors.triggerElement);
   const positionerElement = useScrollLock.useStore(store, selectors.positionerElement);
   const previousOpenMethod = usePreviousValue(openMethod);
-  const renderedOpenMethod = openMethod ?? previousOpenMethod ?? null;
+  const renderedOpenMethod = openMethod ?? previousOpenMethod;
   const serializedValue = React__namespace.useMemo(() => {
     // In multiple mode the shared input is nameless; per-value entries are submitted via
     // `hiddenInputs`. Its value is therefore irrelevant, and passing the whole array to
@@ -272,38 +259,26 @@ function SelectRoot(props) {
     }
     return useCompositeListItem.stringifyAsValue(value, itemToStringValue);
   }, [multiple, value, itemToStringValue]);
-  const controlRef = useScrollLock.useValueAsRef(store.state.triggerElement);
+  const controlRef = useScrollLock.useValueAsRef(triggerElement);
   const getStringifiedValueForForm = useScrollLock.useStableCallback(() => fieldStringValue);
   useCompositeListItem.useRegisterFieldControl(controlRef, generatedId, value, getStringifiedValueForForm, !disabled, nameProp);
   const initialValueRef = React__namespace.useRef(value);
   // Mirror the `hasSelectedValue` store selector so the Field's filled state agrees with the
   // trigger/value placeholder semantics (a value serializing to `''` counts as empty).
-  const hasSelectedValue = multiple ? Array.isArray(value) && value.length > 0 : value != null && useCompositeListItem.stringifyAsValue(value, itemToStringValue) !== '';
-  useScrollLock.useIsoLayoutEffect(() => {
-    // Ensure the values and labels are registered for programmatic value changes.
-    if (value !== initialValueRef.current) {
-      store.set('forceMount', true);
-    }
-  }, [store, value]);
+  const hasSelectedValue = multiple ? Array.isArray(value) && value.length > 0 : value != null && serializedValue !== '';
   useScrollLock.useIsoLayoutEffect(() => {
     setFilled(hasSelectedValue);
   }, [hasSelectedValue, setFilled]);
   useScrollLock.useIsoLayoutEffect(function syncSelectedIndex() {
-    const registry = valuesRef.current;
-    let nextIndex;
+    let target = value;
+    let empty = false;
     if (multiple) {
       const currentValue = Array.isArray(value) ? value : [];
-      if (currentValue.length === 0) {
-        nextIndex = null;
-      } else {
-        const lastValue = currentValue[currentValue.length - 1];
-        const lastIndex = useCompositeListItem.findItemIndex(registry, lastValue, isItemEqualToValue);
-        nextIndex = lastIndex === -1 ? null : lastIndex;
-      }
-    } else {
-      const index = useCompositeListItem.findItemIndex(registry, value, isItemEqualToValue);
-      nextIndex = index === -1 ? null : index;
+      empty = currentValue.length === 0;
+      target = currentValue[currentValue.length - 1];
     }
+    const index = empty ? -1 : useCompositeListItem.findItemIndex(valuesRef.current, target, isItemEqualToValue);
+    const nextIndex = index === -1 ? null : index;
     if (nextIndex === null) {
       selectedItemTextRef.current = null;
     }
@@ -311,7 +286,7 @@ function SelectRoot(props) {
       return;
     }
     store.set('selectedIndex', nextIndex);
-  }, [hasSelectedValue, multiple, open, value, valuesRef, isItemEqualToValue, store, selectedItemTextRef]);
+  }, [multiple, open, value, isItemEqualToValue, store]);
   function isSelectedValueDirty(currentValue) {
     const initialValue = validityData.initialValue;
     if (Array.isArray(currentValue) && Array.isArray(initialValue)) {
@@ -342,7 +317,9 @@ function SelectRoot(props) {
     setMounted(false);
     store.update({
       activeIndex: null,
-      openMethod: null
+      openMethod: null,
+      scrollUpArrowVisible: false,
+      scrollDownArrowVisible: false
     });
     onOpenChangeComplete?.(false);
   });
@@ -366,21 +343,13 @@ function SelectRoot(props) {
     }
     setValueUnwrapped(nextValue);
   });
-  const handleScrollArrowVisibility = useScrollLock.useStableCallback(() => {
-    const scroller = store.state.listElement || popupRef.current;
-    if (!scroller) {
-      return;
-    }
+  const handleScrollArrowVisibility = useScrollLock.useStableCallback(scroller => {
     const maxScrollTop = scrollEdges.getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
     const scrollTop = scrollEdges.normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
     const shouldShowUp = scrollTop > 0;
     const shouldShowDown = scrollTop < maxScrollTop;
-    if (store.state.scrollUpArrowVisible !== shouldShowUp) {
-      store.set('scrollUpArrowVisible', shouldShowUp);
-    }
-    if (store.state.scrollDownArrowVisible !== shouldShowDown) {
-      store.set('scrollDownArrowVisible', shouldShowDown);
-    }
+    store.set('scrollUpArrowVisible', shouldShowUp);
+    store.set('scrollDownArrowVisible', shouldShowDown);
   });
   const floatingContext = useCompositeListItem.useFloatingRootContext({
     open,
@@ -425,49 +394,43 @@ function SelectRoot(props) {
       if (open) {
         store.set('activeIndex', index);
       } else {
-        setValue(valuesRef.current[index], useScrollLock.createChangeEventDetails('none'));
+        setValue(valuesRef.current[index], useScrollLock.createChangeEventDetails(useScrollLock.none));
       }
     },
     onTyping(typing) {
       typingRef.current = typing;
     }
   });
-  const mergedTriggerProps = React__namespace.useMemo(() => {
-    const triggerInteractionProps = useRenderElement.mergeProps(typeahead.reference, listNavigation.reference, dismiss.reference, click.reference, interactionTypeProps);
-    if (generatedId) {
-      triggerInteractionProps.id = generatedId;
-    }
-    return triggerInteractionProps;
-  }, [click.reference, typeahead.reference, listNavigation.reference, dismiss.reference, interactionTypeProps, generatedId]);
+
+  // `Select.Trigger` applies the id itself from the store, so it's deliberately not merged here.
+  const mergedTriggerProps = React__namespace.useMemo(() => useRenderElement.mergeProps(typeahead.reference, listNavigation.reference, dismiss.reference, click.reference, interactionTypeProps), [click.reference, typeahead.reference, listNavigation.reference, dismiss.reference, interactionTypeProps]);
   const popupProps = React__namespace.useMemo(() => useRenderElement.mergeProps(useScrollLock.FOCUSABLE_POPUP_PROPS, typeahead.floating, listNavigation.floating, dismiss.floating), [typeahead.floating, listNavigation.floating, dismiss.floating]);
   const itemProps = listNavigation.item ?? useRenderElement.EMPTY_OBJECT;
-  useScrollLock.useOnFirstRender(() => {
+  useCompositeListItem.useOnFirstRender(() => {
     store.update({
       popupProps,
       triggerProps: mergedTriggerProps
     });
   });
-  useScrollLock.useIsoLayoutEffect(() => {
-    store.update({
-      id: generatedId,
-      modal,
-      multiple,
-      value,
-      open,
-      mounted,
-      transitionStatus,
-      popupProps,
-      triggerProps: mergedTriggerProps,
-      items,
-      itemToStringLabel,
-      itemToStringValue,
-      isItemEqualToValue,
-      openMethod: renderedOpenMethod
-    });
-  }, [store, generatedId, modal, multiple, value, open, mounted, transitionStatus, popupProps, mergedTriggerProps, items, itemToStringLabel, itemToStringValue, isItemEqualToValue, renderedOpenMethod]);
+  store.useSyncedValues({
+    id: generatedId,
+    modal,
+    multiple,
+    value,
+    open,
+    mounted,
+    transitionStatus,
+    popupProps,
+    triggerProps: mergedTriggerProps,
+    items,
+    itemToStringLabel,
+    itemToStringValue,
+    isItemEqualToValue,
+    openMethod: renderedOpenMethod
+  });
   const contextValue = React__namespace.useMemo(() => ({
     store,
-    name,
+    floatingContext,
     required,
     disabled,
     readOnly,
@@ -492,9 +455,8 @@ function SelectRoot(props) {
     onOpenChangeComplete,
     alignItemWithTriggerActiveRef,
     initialValueRef
-  }), [store, name, required, disabled, readOnly, multiple, highlightItemOnHover, setValue, setOpen, itemProps, validation, onOpenChangeComplete, handleScrollArrowVisibility]);
+  }), [store, floatingContext, required, disabled, readOnly, multiple, highlightItemOnHover, setValue, setOpen, itemProps, validation, onOpenChangeComplete, handleScrollArrowVisibility]);
   const ref = useRenderElement.useMergedRefs(inputRef, validation.inputRef);
-  const hasMultipleSelection = multiple && Array.isArray(value) && value.length > 0;
   const hiddenInputName = multiple ? undefined : name;
   const hiddenInputs = React__namespace.useMemo(() => {
     if (!multiple || !Array.isArray(value) || !name) {
@@ -511,73 +473,69 @@ function SelectRoot(props) {
       }, currentSerializedValue);
     });
   }, [multiple, value, form, name, itemToStringValue, disabled]);
-  return /*#__PURE__*/jsxRuntime.jsx(SelectRootContext.Provider, {
+  return /*#__PURE__*/jsxRuntime.jsxs(SelectRootContext.Provider, {
     value: contextValue,
-    children: /*#__PURE__*/jsxRuntime.jsxs(SelectFloatingContext.Provider, {
-      value: floatingContext,
-      children: [children, /*#__PURE__*/jsxRuntime.jsx("input", {
-        ...validation.getValidationProps(disabled, {
-          onFocus() {
-            // Move focus to the trigger element when the hidden input is focused.
-            store.state.triggerElement?.focus({
-              // Supported in Chrome from 144 (January 2026)
-              focusVisible: true
-            });
-          },
-          // Handle browser autofill.
-          onChange(event) {
-            // Workaround for https://github.com/facebook/react/issues/9023
-            if (event.nativeEvent.defaultPrevented || disabled || readOnly) {
+    children: [children, /*#__PURE__*/jsxRuntime.jsx("input", {
+      ...validation.getValidationProps(disabled, {
+        onFocus() {
+          // Move focus to the trigger element when the hidden input is focused.
+          store.state.triggerElement?.focus({
+            // Supported in Chrome from 144 (January 2026)
+            focusVisible: true
+          });
+        },
+        // Handle browser autofill.
+        onChange(event) {
+          // Workaround for https://github.com/react/react/issues/9023
+          if (event.nativeEvent.defaultPrevented || disabled || readOnly) {
+            return;
+          }
+          const nextValue = event.currentTarget.value;
+          const details = useScrollLock.createChangeEventDetails(useScrollLock.none, event.nativeEvent);
+          function handleChange() {
+            if (multiple) {
+              // Browser autofill only writes a single scalar value.
               return;
             }
-            const nextValue = event.currentTarget.value;
-            const details = useScrollLock.createChangeEventDetails(useScrollLock.none, event.nativeEvent);
-            function handleChange() {
-              if (multiple) {
-                // Browser autofill only writes a single scalar value.
-                return;
-              }
 
-              // Preserve the original serialized matching, then fall back to rendered text,
-              // which browsers can autofill for primitive values like `value="US">United States`.
-              const nextValueLower = nextValue.toLowerCase();
-              let matchingIndex = valuesRef.current.findIndex(candidate => useCompositeListItem.stringifyAsValue(candidate, itemToStringValue).toLowerCase() === nextValueLower || useCompositeListItem.stringifyAsLabel(candidate, itemToStringLabel).toLowerCase() === nextValueLower);
-              if (matchingIndex === -1) {
-                matchingIndex = valuesRef.current.findIndex((_, index) => {
-                  const renderedLabel = labelsRef.current[index];
-                  return renderedLabel != null && renderedLabel.toLowerCase() === nextValueLower;
-                });
-              }
-              const matchingValue = matchingIndex === -1 ? undefined : valuesRef.current[matchingIndex];
-              if (matchingValue != null) {
-                // `setValue` may be canceled by `onValueChange`; rely on `useValueChanged` to
-                // mark the field dirty and run validation only when the value actually changes.
-                setValue(matchingValue, details);
-              }
+            // Preserve the original serialized matching, then fall back to rendered text,
+            // which browsers can autofill for primitive values like `value="US">United States`.
+            const nextValueLower = nextValue.toLowerCase();
+            let matchingIndex = valuesRef.current.findIndex(candidate => useCompositeListItem.stringifyAsValue(candidate, itemToStringValue).toLowerCase() === nextValueLower || useCompositeListItem.stringifyAsLabel(candidate, itemToStringLabel).toLowerCase() === nextValueLower);
+            if (matchingIndex === -1) {
+              matchingIndex = valuesRef.current.findIndex((_, index) => {
+                const renderedLabel = labelsRef.current[index];
+                return renderedLabel != null && renderedLabel.toLowerCase() === nextValueLower;
+              });
+            }
+            const matchingValue = valuesRef.current[matchingIndex];
+            if (matchingValue != null) {
+              // `setValue` may be canceled by `onValueChange`; rely on `useValueChanged` to
+              // mark the field dirty and run validation only when the value actually changes.
+              setValue(matchingValue, details);
             }
-            store.set('forceMount', true);
-            queueMicrotask(handleChange);
           }
-        }),
-        id: generatedId && hiddenInputName == null ? `${generatedId}-hidden-input` : undefined,
-        form: form,
-        name: hiddenInputName,
-        autoComplete: autoComplete,
-        value: serializedValue,
-        disabled: disabled,
-        required: required && !hasMultipleSelection,
-        readOnly: readOnly,
-        ref: ref,
-        style: name ? useScrollLock.visuallyHiddenInput : useScrollLock.visuallyHidden,
-        tabIndex: -1,
-        "aria-hidden": true,
-        suppressHydrationWarning: true
-      }), hiddenInputs]
-    })
+          store.set('forceMount', true);
+          queueMicrotask(handleChange);
+        }
+      }),
+      id: generatedId && hiddenInputName == null ? `${generatedId}-hidden-input` : undefined,
+      form: form,
+      name: hiddenInputName,
+      autoComplete: autoComplete,
+      value: serializedValue,
+      disabled: disabled,
+      required: required && !(multiple && hasSelectedValue),
+      readOnly: readOnly,
+      ref: ref,
+      style: name ? useScrollLock.visuallyHiddenInput : useScrollLock.visuallyHidden,
+      tabIndex: -1,
+      "aria-hidden": true,
+      suppressHydrationWarning: true
+    }), hiddenInputs]
   });
 }
 
-const BOUNDARY_OFFSET = 2;
 const SELECTED_DELAY = 400;
 const stateAttributesMapping$2 = {
   ...useScrollLock.pressableTriggerOpenStateMapping,
@@ -650,9 +608,7 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
     disabled,
     native: nativeButton
   });
-  const setTriggerElement = useScrollLock.useStableCallback(element => {
-    store.set('triggerElement', element);
-  });
+  const setTriggerElement = store.useStateSetter('triggerElement');
   const timeoutFocus = useScrollLock.useTimeout();
   const timeoutMouseDown = useScrollLock.useTimeout();
   const selectedDelayTimeout = useScrollLock.useTimeout();
@@ -681,7 +637,7 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
   const mergedProps = useRenderElement.mergeProps(triggerProps, {
     id,
     role: 'combobox',
-    'aria-expanded': open ? 'true' : 'false',
+    'aria-expanded': open,
     'aria-haspopup': 'listbox',
     'aria-controls': open ? listElement?.id ?? useScrollLock.getFloatingFocusElement(positionerElement)?.id : undefined,
     'aria-labelledby': ariaLabelledBy,
@@ -730,8 +686,7 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
         if (useScrollLock.contains(triggerRef.current, mouseUpTarget) || useScrollLock.contains(positionerRef.current, mouseUpTarget)) {
           return;
         }
-        const bounds = useCompositeListItem.getPseudoElementBounds(triggerRef.current);
-        if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) {
+        if (useCompositeListItem.isMouseWithinBounds(mouseEvent, triggerRef.current)) {
           return;
         }
         setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.cancelOpen, mouseEvent));
@@ -806,7 +761,7 @@ const SelectValue = /*#__PURE__*/React__namespace.forwardRef(function SelectValu
     children = childrenProp(value);
   } else if (childrenProp != null) {
     children = childrenProp;
-  } else if (!hasSelectedValue && placeholder != null && !hasNullLabel) {
+  } else if (shouldCheckNullItemLabel && !hasNullLabel) {
     children = placeholder;
   } else if (Array.isArray(value)) {
     children = useCompositeListItem.resolveMultipleLabels(value, items, itemToStringLabel);
@@ -825,9 +780,6 @@ const SelectValue = /*#__PURE__*/React__namespace.forwardRef(function SelectValu
 });
 if (process.env.NODE_ENV !== "production") SelectValue.displayName = "SelectValue";
 
-const SelectPortalContext = /*#__PURE__*/React__namespace.createContext(undefined);
-if (process.env.NODE_ENV !== "production") SelectPortalContext.displayName = "SelectPortalContext";
-
 const SelectPortal = /*#__PURE__*/React__namespace.forwardRef(function SelectPortal(portalProps, forwardedRef) {
   const {
     store
@@ -838,12 +790,9 @@ const SelectPortal = /*#__PURE__*/React__namespace.forwardRef(function SelectPor
   if (!shouldRender) {
     return null;
   }
-  return /*#__PURE__*/jsxRuntime.jsx(SelectPortalContext.Provider, {
-    value: true,
-    children: /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingPortal, {
-      ref: forwardedRef,
-      ...portalProps
-    })
+  return /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingPortal, {
+    ref: forwardedRef,
+    ...portalProps
   });
 });
 if (process.env.NODE_ENV !== "production") SelectPortal.displayName = "SelectPortal";
@@ -883,17 +832,19 @@ const FIXED = {
 const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function SelectPositioner(componentProps, forwardedRef) {
   const {
     anchor,
-    positionMethod = 'absolute',
     className,
     render,
-    side = 'bottom',
-    align = 'center',
-    sideOffset = 0,
-    alignOffset = 0,
+    // `useAnchorPositioning` applies the same defaults to the undefined values; the names
+    // remain destructured to exclude the props from `elementProps`.
+    positionMethod,
+    side,
+    align,
+    sideOffset,
+    alignOffset,
     collisionBoundary = 'clipping-ancestors',
     collisionPadding,
-    arrowPadding = 5,
-    sticky = false,
+    arrowPadding,
+    sticky,
     disableAnchorTracking,
     alignItemWithTrigger = true,
     collisionAvoidance = useScrollLock.DROPDOWN_COLLISION_AVOIDANCE,
@@ -909,9 +860,9 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
     valuesRef,
     initialValueRef,
     popupRef,
-    setValue
+    setValue,
+    floatingContext: floatingRootContext
   } = useSelectRootContext();
-  const floatingRootContext = useSelectFloatingContext();
   const open = useScrollLock.useStore(store, selectors.open);
   const mounted = useScrollLock.useStore(store, selectors.mounted);
   const modal = useScrollLock.useStore(store, selectors.modal);
@@ -928,16 +879,6 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
   if (!mounted && controlledAlignItemWithTrigger !== alignItemWithTrigger) {
     setControlledAlignItemWithTrigger(alignItemWithTrigger);
   }
-  useScrollLock.useIsoLayoutEffect(() => {
-    if (!mounted) {
-      if (selectors.scrollUpArrowVisible(store.state)) {
-        store.set('scrollUpArrowVisible', false);
-      }
-      if (selectors.scrollDownArrowVisible(store.state)) {
-        store.set('scrollDownArrowVisible', false);
-      }
-    }
-  }, [store, mounted]);
   React__namespace.useImperativeHandle(alignItemWithTriggerActiveRef, () => alignItemWithTriggerActive);
   useCompositeListItem.useAnchoredPopupScrollLock((alignItemWithTriggerActive || modal) && open, openMethod === 'touch', positionerElement, triggerElement);
   const positioning = useCompositeListItem.useAnchorPositioning({
@@ -968,9 +909,7 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
   useScrollLock.useIsoLayoutEffect(() => {
     store.set('popupSide', positioning.side);
   }, [store, positioning.side]);
-  const setPositionerElement = useScrollLock.useStableCallback(element => {
-    store.set('positionerElement', element);
-  });
+  const setPositionerElement = store.useStateSetter('positionerElement');
   const element = useCompositeListItem.usePositioner(componentProps, state, {
     styles: positionerStyles,
     transitionStatus,
@@ -981,9 +920,6 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
   });
   const prevMapSizeRef = React__namespace.useRef(0);
   const onMapChange = useScrollLock.useStableCallback(map => {
-    if (map.size === 0 && prevMapSizeRef.current === 0) {
-      return;
-    }
     if (valuesRef.current.length === 0) {
       return;
     }
@@ -1007,9 +943,8 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
       }
     }
     if (prevSize !== 0 && store.state.multiple && Array.isArray(value)) {
-      const hasVisibleItem = selectedItemValue => useCompositeListItem.findItemIndex(valuesRef.current, selectedItemValue, isItemEqualToValue) !== -1;
-      const nextValue = value.filter(selectedItemValue => hasVisibleItem(selectedItemValue));
-      if (nextValue.length !== value.length || nextValue.some(selectedItemValue => !useCompositeListItem.selectedValueIncludes(value, selectedItemValue, isItemEqualToValue))) {
+      const nextValue = value.filter(selectedItemValue => useCompositeListItem.findItemIndex(valuesRef.current, selectedItemValue, isItemEqualToValue) !== -1);
+      if (nextValue.length !== value.length) {
         setValue(nextValue, eventDetails);
         if (nextValue.length === 0) {
           store.set('selectedIndex', null);
@@ -1083,7 +1018,8 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     handleScrollArrowVisibility,
     scrollHandlerRef,
     listRef,
-    highlightItemOnHover
+    highlightItemOnHover,
+    floatingContext: floatingRootContext
   } = useSelectRootContext();
   const {
     side,
@@ -1093,7 +1029,6 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     setControlledAlignItemWithTrigger
   } = useSelectPositionerContext();
   const insideToolbar = useToolbarRootContext(true) != null;
-  const floatingRootContext = useSelectFloatingContext();
   const direction = useScrollLock.useDirection();
   const {
     nonce,
@@ -1116,20 +1051,16 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     if (!positionerElement || !popupRef.current || !initialPlacedRef.current) {
       return;
     }
-    if (reachedMaxHeightRef.current || !alignItemWithTriggerActive) {
-      handleScrollArrowVisibility();
-      return;
-    }
     const isTopPositioned = positionerElement.style.top === '0px';
     const isBottomPositioned = positionerElement.style.bottom === '0px';
-    if (!isTopPositioned && !isBottomPositioned) {
-      handleScrollArrowVisibility();
+    if (reachedMaxHeightRef.current || !alignItemWithTriggerActive || !isTopPositioned && !isBottomPositioned) {
+      handleScrollArrowVisibility(scroller);
       return;
     }
     const scale = getScale(positionerElement);
     const currentHeight = normalizeSize(positionerElement.getBoundingClientRect().height, 'y', scale);
     const doc = useScrollLock.ownerDocument(positionerElement);
-    const win = floatingUi_utils.getWindow(positionerElement);
+    const win = useScrollLock.getWindow(positionerElement);
     const positionerStyles = win.getComputedStyle(positionerElement);
     const marginTop = parseFloat(positionerStyles.marginTop);
     const marginBottom = parseFloat(positionerStyles.marginBottom);
@@ -1137,63 +1068,50 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     const maxAvailableHeight = Math.min(doc.documentElement.clientHeight - marginTop - marginBottom, maxPopupHeight);
     const scrollTop = scroller.scrollTop;
     const maxScrollTop = getMaxScrollTop(scroller);
-    let nextPositionerHeight = 0;
+
+    // `Infinity` requests a scroll to the recomputed maximum offset.
     let nextScrollTop = null;
-    let setReachedMax = false;
-    let scrollToMax = false;
     const setHeight = height => {
       positionerElement.style.height = `${height}px`;
     };
-    const handleSmallDiff = (diff, targetScrollTop) => {
+    const diff = isTopPositioned ? maxScrollTop - scrollTop : scrollTop;
+    const nextHeight = Math.min(currentHeight + diff, maxAvailableHeight);
+    if (diff <= scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
       const heightDelta = scrollEdges.clamp(diff, 0, maxAvailableHeight - currentHeight);
       if (heightDelta > 0) {
         // Consume the remaining scroll in height.
         setHeight(currentHeight + heightDelta);
       }
-      scroller.scrollTop = targetScrollTop;
+      scroller.scrollTop = isTopPositioned ? maxScrollTop : 0;
       if (maxAvailableHeight - (currentHeight + heightDelta) <= scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
         reachedMaxHeightRef.current = true;
       }
-      handleScrollArrowVisibility();
-    };
-    const diff = isTopPositioned ? maxScrollTop - scrollTop : scrollTop;
-    const nextHeight = Math.min(currentHeight + diff, maxAvailableHeight);
-    nextPositionerHeight = nextHeight;
-    if (diff <= scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
-      handleSmallDiff(diff, isTopPositioned ? maxScrollTop : 0);
+      handleScrollArrowVisibility(scroller);
       return;
     }
     if (maxAvailableHeight - nextHeight > scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
-      if (isTopPositioned) {
-        scrollToMax = true;
-      } else {
-        nextScrollTop = 0;
-      }
-    } else {
-      setReachedMax = true;
-      if (isBottomPositioned && scrollTop < maxScrollTop) {
-        const overshoot = currentHeight + diff - maxAvailableHeight;
-        nextScrollTop = scrollTop - (diff - overshoot);
-      }
+      nextScrollTop = isTopPositioned ? Infinity : 0;
+    } else if (isBottomPositioned && scrollTop < maxScrollTop) {
+      const overshoot = currentHeight + diff - maxAvailableHeight;
+      nextScrollTop = scrollTop - (diff - overshoot);
     }
-    nextPositionerHeight = Math.ceil(nextPositionerHeight);
+    const nextPositionerHeight = Math.ceil(nextHeight);
     if (nextPositionerHeight !== 0) {
       setHeight(nextPositionerHeight);
     }
-    if (scrollToMax || nextScrollTop != null) {
+    if (nextScrollTop != null) {
       // Recompute bounds after resizing (clientHeight likely changed).
-      const nextMaxScrollTop = getMaxScrollTop(scroller);
-      const target = scrollToMax ? nextMaxScrollTop : scrollEdges.clamp(nextScrollTop, 0, nextMaxScrollTop);
+      const target = scrollEdges.clamp(nextScrollTop, 0, getMaxScrollTop(scroller));
 
       // Avoid adjustments that re-trigger scroll events forever.
       if (Math.abs(scroller.scrollTop - target) > scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
         scroller.scrollTop = target;
       }
     }
-    if (setReachedMax || nextPositionerHeight >= maxAvailableHeight - scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
+    if (nextPositionerHeight >= maxAvailableHeight - scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
       reachedMaxHeightRef.current = true;
     }
-    handleScrollArrowVisibility();
+    handleScrollArrowVisibility(scroller);
   });
   React__namespace.useImperativeHandle(scrollHandlerRef, () => handleScroll, [handleScroll]);
   useScrollLock.useOpenChangeComplete({
@@ -1244,17 +1162,18 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     if (!open || !triggerElement || !positionerElement || !popupElement || alignItemWithTriggerActive && !isPositioned || store.state.transitionStatus === 'ending') {
       return;
     }
+    initialPlacedRef.current = true;
+    popupElement.style.removeProperty('--transform-origin');
     if (!alignItemWithTriggerActive) {
-      initialPlacedRef.current = true;
-      scrollArrowFrame.request(handleScrollArrowVisibility);
-      popupElement.style.removeProperty('--transform-origin');
+      // The wrapper supplies the scroller: the list owns scrolling once it has mounted, and
+      // this effect re-runs (cancelling the stale frame) when that happens.
+      scrollArrowFrame.request(() => handleScrollArrowVisibility(listElement || popupElement));
       return;
     }
 
     // Ensure we remove any transforms that can affect the location of the popup
     // and therefore the calculations.
     const restoreTransformStyles = unsetTransformStyles(popupElement);
-    popupElement.style.removeProperty('--transform-origin');
     try {
       let textElement = selectedItemTextRef.current;
       if (!textElement?.isConnected) {
@@ -1262,7 +1181,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
         textElement = !hasSelectedValue && firstItemTextRef.current?.isConnected ? firstItemTextRef.current : null;
       }
       const valueElement = valueRef.current;
-      const win = floatingUi_utils.getWindow(positionerElement);
+      const win = useScrollLock.getWindow(positionerElement);
       const positionerStyles = win.getComputedStyle(positionerElement);
       const popupStyles = win.getComputedStyle(popupElement);
       const doc = useScrollLock.ownerDocument(triggerElement);
@@ -1323,7 +1242,6 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
       // Safari doesn't position the popup correctly when pinch-zoomed.
       const isPinchZoomed = (win.visualViewport?.scale ?? 1) !== 1 && useScrollLock.webkit;
       if (fallbackToAlignPopupToTrigger || isPinchZoomed) {
-        initialPlacedRef.current = true;
         clearStyles(positionerElement, originalPositionerStylesRef.current);
         setControlledAlignItemWithTrigger(false);
         return;
@@ -1342,18 +1260,16 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
         const popupTop = positionerRect.top;
         const popupHeight = positionerRect.height;
         const textCenterY = textRect.top + textRect.height / 2;
-        const transformOriginY = popupHeight > 0 ? (textCenterY - popupTop) / popupHeight * 100 : 50;
-        const clampedY = scrollEdges.clamp(transformOriginY, 0, 100);
+        const clampedY = scrollEdges.clamp(popupHeight > 0 ? (textCenterY - popupTop) / popupHeight * 100 : 50, 0, 100);
         popupElement.style.setProperty('--transform-origin', `50% ${clampedY}%`);
       }
       if (initialHeight === viewportHeight || height >= maxPopupHeight) {
         reachedMaxHeightRef.current = true;
       }
-      handleScrollArrowVisibility();
+      handleScrollArrowVisibility(scroller);
       if (highlightItemOnHover && store.state.selectedIndex === null && store.state.activeIndex === null && listRef.current[0] != null) {
         store.set('activeIndex', 0);
       }
-      initialPlacedRef.current = true;
     } finally {
       restoreTransformStyles();
     }
@@ -1362,7 +1278,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     if (!alignItemWithTriggerActive || !positionerElement || !open) {
       return undefined;
     }
-    const win = floatingUi_utils.getWindow(positionerElement);
+    const win = useScrollLock.getWindow(positionerElement);
     function handleResize(event) {
       setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.windowResize, event));
     }
@@ -1392,15 +1308,14 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
       style: listElement ? {
         height: '100%'
       } : LIST_FUNCTIONAL_STYLES
-    })
+    }),
+    className: !listElement && alignItemWithTriggerActive ? scrollEdges.styleDisableScrollbar.className : undefined
   };
   const element = useRenderElement.useRenderElement('div', componentProps, {
     ref: [forwardedRef, popupRef],
     state,
     stateAttributesMapping,
-    props: [popupProps, defaultProps, useCompositeListItem.getDisabledMountTransitionStyles(transitionStatus), {
-      className: !listElement && alignItemWithTriggerActive ? scrollEdges.styleDisableScrollbar.className : undefined
-    }, elementProps]
+    props: [popupProps, defaultProps, useCompositeListItem.getDisabledMountTransitionStyles(transitionStatus), elementProps]
   });
   return /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
     children: [!disableStyleElements && scrollEdges.styleDisableScrollbar.getElement(nonce), /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingFocusManager, {
@@ -1416,7 +1331,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
 });
 if (process.env.NODE_ENV !== "production") SelectPopup.displayName = "SelectPopup";
 function getMaxPopupHeight(popupStyles) {
-  const maxHeightStyle = popupStyles.maxHeight || '';
+  const maxHeightStyle = popupStyles.maxHeight;
   return maxHeightStyle.endsWith('px') ? parseFloat(maxHeightStyle) || Infinity : Infinity;
 }
 function getMaxScrollTop(scroller) {
@@ -1424,13 +1339,13 @@ function getMaxScrollTop(scroller) {
 }
 function getScale(element) {
   // The platform API is async-capable, but the DOM platform returns a plain scale object.
-  return floatingUi_reactDom.platform.getScale(element);
+  return useCompositeListItem.platform.getScale(element);
 }
 function normalizeSize(size, axis, scale) {
   return size / scale[axis];
 }
 function normalizeRect(rect, scale) {
-  return floatingUi_utils.rectToClientRect({
+  return useScrollLock.rectToClientRect({
     x: normalizeSize(rect.x, 'x', scale),
     y: normalizeSize(rect.y, 'y', scale),
     width: normalizeSize(rect.width, 'x', scale),
@@ -1474,14 +1389,14 @@ const SelectList = /*#__PURE__*/React__namespace.forwardRef(function SelectList(
   } = componentProps;
   const {
     store,
-    scrollHandlerRef
+    scrollHandlerRef,
+    multiple
   } = useSelectRootContext();
   const {
     alignItemWithTriggerActive
   } = useSelectPositionerContext();
   const hasScrollArrows = useScrollLock.useStore(store, selectors.hasScrollArrows);
   const openMethod = useScrollLock.useStore(store, selectors.openMethod);
-  const multiple = useScrollLock.useStore(store, selectors.multiple);
   const id = useScrollLock.useStore(store, selectors.id);
   const defaultProps = {
     id: `${id}-list`,
@@ -1495,9 +1410,7 @@ const SelectList = /*#__PURE__*/React__namespace.forwardRef(function SelectList(
     }),
     className: hasScrollArrows && openMethod !== 'touch' ? scrollEdges.styleDisableScrollbar.className : undefined
   };
-  const setListElement = useScrollLock.useStableCallback(element => {
-    store.set('listElement', element);
-  });
+  const setListElement = store.useStateSetter('listElement');
   return useRenderElement.useRenderElement('div', componentProps, {
     ref: [forwardedRef, setListElement],
     props: [defaultProps, elementProps]
@@ -1522,15 +1435,15 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     style,
     value: itemValue = null,
     label,
-    disabled = false,
+    disabled: disabledProp = false,
     nativeButton = false,
     ...elementProps
   } = componentProps;
   const textRef = React__namespace.useRef(null);
   const listItem = useCompositeListItem.useCompositeListItem({
+    guess: true,
     label,
-    textRef,
-    indexGuessBehavior: useCompositeListItem.IndexGuessBehavior.GuessFromOrder
+    textRef
   });
   const {
     store,
@@ -1545,28 +1458,22 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     disabled: selectDisabled,
     readOnly
   } = useSelectRootContext();
+  const disabled = selectDisabled || disabledProp;
   const highlighted = useScrollLock.useStore(store, selectors.isActive, listItem.index);
   const open = useScrollLock.useStore(store, selectors.open);
   const selected = useScrollLock.useStore(store, selectors.isSelected, itemValue);
   const selectedByFocus = useScrollLock.useStore(store, selectors.isSelectedByFocus, listItem.index);
   const isItemEqualToValue = useScrollLock.useStore(store, selectors.isItemEqualToValue);
   const index = listItem.index;
-  const hasRegistered = index !== -1;
   const itemRef = React__namespace.useRef(null);
   useScrollLock.useIsoLayoutEffect(() => {
-    if (!hasRegistered) {
-      return undefined;
-    }
     const values = valuesRef.current;
     values[index] = itemValue;
     return () => {
       delete values[index];
     };
-  }, [hasRegistered, index, itemValue, valuesRef]);
+  }, [index, itemValue, valuesRef]);
   useScrollLock.useIsoLayoutEffect(() => {
-    if (!hasRegistered) {
-      return;
-    }
     const selectedValue = store.state.value;
     let selectedCandidate = selectedValue;
     if (multiple && Array.isArray(selectedValue)) {
@@ -1582,8 +1489,7 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
         selectedItemTextRef.current = textRef.current;
       }
     }
-  }, [hasRegistered, index, multiple, isItemEqualToValue, store, itemValue, selectedItemTextRef]);
-  const lastKeyRef = React__namespace.useRef(null);
+  }, [index, multiple, isItemEqualToValue, store, itemValue, selectedItemTextRef]);
   const pointerTypeRef = React__namespace.useRef('mouse');
   const allowMouseSelectionRef = React__namespace.useRef(false);
   const {
@@ -1624,14 +1530,15 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     'aria-selected': selected,
     tabIndex: open && highlighted ? 0 : -1,
     onKeyDown(event) {
-      lastKeyRef.current = event.key;
       store.set('activeIndex', index);
       if (event.key === ' ' && typingRef.current) {
+        // `useButton` skips Space activation for `role="option"` items when the keydown
+        // is `defaultPrevented`, keeping typeahead spaces from committing a selection.
         event.preventDefault();
       }
     },
     onClick(event) {
-      const isMouseClick = event.type === 'click' && pointerTypeRef.current !== 'touch';
+      const isMouseClick = pointerTypeRef.current !== 'touch';
       const clickPointerType = event.nativeEvent.pointerType;
       const isVirtualMouseClick = isMouseClick && useScrollLock.isVirtualClick(event.nativeEvent) && (
       // Generic no-pointer `detail === 0` clicks stay tied to highlight state. Virtual
@@ -1643,15 +1550,9 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
       // assistive technology activation.
       const isInvalidMouseClick = isMouseClick && !isVirtualMouseClick && !allowMouseSelectionRef.current;
       allowMouseSelectionRef.current = false;
-
-      // Prevent double commit on {Enter}
-      if (event.type === 'keydown' && lastKeyRef.current === null) {
-        return;
-      }
-      if (disabled || event.type === 'keydown' && lastKeyRef.current === ' ' && typingRef.current || isInvalidMouseClick) {
+      if (disabled || isInvalidMouseClick) {
         return;
       }
-      lastKeyRef.current = null;
       commitSelection(event.nativeEvent);
     },
     onPointerEnter(event) {
@@ -1700,9 +1601,8 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     selected,
     index,
     textRef,
-    selectedByFocus,
-    hasRegistered
-  }), [selected, index, textRef, selectedByFocus, hasRegistered]);
+    selectedByFocus
+  }), [selected, index, textRef, selectedByFocus]);
   return /*#__PURE__*/jsxRuntime.jsx(SelectItemContext.Provider, {
     value: contextValue,
     children: element
@@ -1711,11 +1611,10 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
 if (process.env.NODE_ENV !== "production") SelectItem.displayName = "SelectItem";
 
 const SelectItemIndicator = /*#__PURE__*/React__namespace.forwardRef(function SelectItemIndicator(componentProps, forwardedRef) {
-  const keepMounted = componentProps.keepMounted ?? false;
   const {
     selected
   } = useSelectItemContext();
-  const shouldRender = keepMounted || selected;
+  const shouldRender = componentProps.keepMounted || selected;
   if (!shouldRender) {
     return null;
   }
@@ -1781,8 +1680,7 @@ const SelectItemText = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__na
   const {
     index,
     textRef,
-    selectedByFocus,
-    hasRegistered
+    selectedByFocus
   } = useSelectItemContext();
   const {
     firstItemTextRef,
@@ -1798,13 +1696,13 @@ const SelectItemText = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__na
     if (!node) {
       return;
     }
-    if (hasRegistered && index === 0) {
+    if (index === 0) {
       firstItemTextRef.current = node;
     }
-    if (hasRegistered && selectedByFocus) {
+    if (selectedByFocus) {
       selectedItemTextRef.current = node;
     }
-  }, [firstItemTextRef, selectedItemTextRef, index, selectedByFocus, hasRegistered]);
+  }, [firstItemTextRef, selectedItemTextRef, index, selectedByFocus]);
   const element = useRenderElement.useRenderElement('div', componentProps, {
     ref: [localRef, forwardedRef, textRef],
     props: elementProps
@@ -1869,6 +1767,9 @@ const SelectGroupLabel = /*#__PURE__*/React__namespace.forwardRef(function Selec
   const id = useScrollLock.useBaseUiId(idProp);
   useScrollLock.useIsoLayoutEffect(() => {
     setLabelId(id);
+    return () => {
+      setLabelId(currentId => currentId === id ? undefined : currentId);
+    };
   }, [id, setLabelId]);
   const element = useRenderElement.useRenderElement('div', componentProps, {
     ref: forwardedRef,