@jobber/components 9.6.0 → 9.6.2

package/dist/SelectGroupLabel-cjs.js

@@ -6,6 +6,8 @@ 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);
@@ -46,7 +48,7 @@ function usePreviousValue(value) {
     current: value,
     previous: null
   });
-  if (!Object.is(value, state.current)) {
+  if (value !== state.current) {
     setState({
       current: value,
       previous: state.current
@@ -61,6 +63,8 @@ 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) {
@@ -68,16 +72,25 @@ 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: 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 => {
+  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 => {
     const {
       value,
       multiple,
@@ -90,19 +103,19 @@ const selectors = {
       return value.length > 0;
     }
     return useCompositeListItem.stringifyAsValue(value, itemToStringValue) !== '';
-  },
-  hasNullItemLabel: (state, enabled) => {
+  }),
+  hasNullItemLabel: useScrollLock.createSelector((state, enabled) => {
     return enabled ? useCompositeListItem.hasNullItemLabel(state.items) : false;
-  },
-  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) => {
+  }),
+  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) => {
     const comparer = state.isItemEqualToValue;
     const storeValue = state.value;
     if (state.multiple) {
@@ -113,19 +126,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: (state, index) => {
+  }),
+  isSelectedByFocus: useScrollLock.createSelector((state, index) => {
     return state.selectedIndex === index;
-  },
-  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
+  }),
+  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)
 };
 
 function SelectRoot(props) {
@@ -211,7 +224,7 @@ function SelectRoot(props) {
     openMethod,
     triggerProps: interactionTypeProps
   } = useScrollLock.useOpenInteractionType(open);
-  const store = useRenderElement.useRefWithInit(() => new useScrollLock.ReactStore({
+  const store = useRenderElement.useRefWithInit(() => new useScrollLock.Store({
     id: generatedId,
     labelId: undefined,
     modal,
@@ -243,7 +256,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;
+  const renderedOpenMethod = openMethod ?? previousOpenMethod ?? null;
   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
@@ -259,26 +272,38 @@ function SelectRoot(props) {
     }
     return useCompositeListItem.stringifyAsValue(value, itemToStringValue);
   }, [multiple, value, itemToStringValue]);
-  const controlRef = useScrollLock.useValueAsRef(triggerElement);
+  const controlRef = useScrollLock.useValueAsRef(store.state.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 && serializedValue !== '';
+  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]);
   useScrollLock.useIsoLayoutEffect(() => {
     setFilled(hasSelectedValue);
   }, [hasSelectedValue, setFilled]);
   useScrollLock.useIsoLayoutEffect(function syncSelectedIndex() {
-    let target = value;
-    let empty = false;
+    const registry = valuesRef.current;
+    let nextIndex;
     if (multiple) {
       const currentValue = Array.isArray(value) ? value : [];
-      empty = currentValue.length === 0;
-      target = currentValue[currentValue.length - 1];
+      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;
     }
-    const index = empty ? -1 : useCompositeListItem.findItemIndex(valuesRef.current, target, isItemEqualToValue);
-    const nextIndex = index === -1 ? null : index;
     if (nextIndex === null) {
       selectedItemTextRef.current = null;
     }
@@ -286,7 +311,7 @@ function SelectRoot(props) {
       return;
     }
     store.set('selectedIndex', nextIndex);
-  }, [multiple, open, value, isItemEqualToValue, store]);
+  }, [hasSelectedValue, multiple, open, value, valuesRef, isItemEqualToValue, store, selectedItemTextRef]);
   function isSelectedValueDirty(currentValue) {
     const initialValue = validityData.initialValue;
     if (Array.isArray(currentValue) && Array.isArray(initialValue)) {
@@ -317,9 +342,7 @@ function SelectRoot(props) {
     setMounted(false);
     store.update({
       activeIndex: null,
-      openMethod: null,
-      scrollUpArrowVisible: false,
-      scrollDownArrowVisible: false
+      openMethod: null
     });
     onOpenChangeComplete?.(false);
   });
@@ -343,13 +366,21 @@ function SelectRoot(props) {
     }
     setValueUnwrapped(nextValue);
   });
-  const handleScrollArrowVisibility = useScrollLock.useStableCallback(scroller => {
+  const handleScrollArrowVisibility = useScrollLock.useStableCallback(() => {
+    const scroller = store.state.listElement || popupRef.current;
+    if (!scroller) {
+      return;
+    }
     const maxScrollTop = scrollEdges.getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
     const scrollTop = scrollEdges.normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
     const shouldShowUp = scrollTop > 0;
     const shouldShowDown = scrollTop < maxScrollTop;
-    store.set('scrollUpArrowVisible', shouldShowUp);
-    store.set('scrollDownArrowVisible', shouldShowDown);
+    if (store.state.scrollUpArrowVisible !== shouldShowUp) {
+      store.set('scrollUpArrowVisible', shouldShowUp);
+    }
+    if (store.state.scrollDownArrowVisible !== shouldShowDown) {
+      store.set('scrollDownArrowVisible', shouldShowDown);
+    }
   });
   const floatingContext = useCompositeListItem.useFloatingRootContext({
     open,
@@ -394,43 +425,49 @@ function SelectRoot(props) {
       if (open) {
         store.set('activeIndex', index);
       } else {
-        setValue(valuesRef.current[index], useScrollLock.createChangeEventDetails(useScrollLock.none));
+        setValue(valuesRef.current[index], useScrollLock.createChangeEventDetails('none'));
       }
     },
     onTyping(typing) {
       typingRef.current = typing;
     }
   });
-
-  // `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 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]);
   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;
-  useCompositeListItem.useOnFirstRender(() => {
+  useScrollLock.useOnFirstRender(() => {
     store.update({
       popupProps,
       triggerProps: mergedTriggerProps
     });
   });
-  store.useSyncedValues({
-    id: generatedId,
-    modal,
-    multiple,
-    value,
-    open,
-    mounted,
-    transitionStatus,
-    popupProps,
-    triggerProps: mergedTriggerProps,
-    items,
-    itemToStringLabel,
-    itemToStringValue,
-    isItemEqualToValue,
-    openMethod: renderedOpenMethod
-  });
+  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]);
   const contextValue = React__namespace.useMemo(() => ({
     store,
-    floatingContext,
+    name,
     required,
     disabled,
     readOnly,
@@ -455,8 +492,9 @@ function SelectRoot(props) {
     onOpenChangeComplete,
     alignItemWithTriggerActiveRef,
     initialValueRef
-  }), [store, floatingContext, required, disabled, readOnly, multiple, highlightItemOnHover, setValue, setOpen, itemProps, validation, onOpenChangeComplete, handleScrollArrowVisibility]);
+  }), [store, name, 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) {
@@ -473,69 +511,73 @@ function SelectRoot(props) {
       }, currentSerializedValue);
     });
   }, [multiple, value, form, name, itemToStringValue, disabled]);
-  return /*#__PURE__*/jsxRuntime.jsxs(SelectRootContext.Provider, {
+  return /*#__PURE__*/jsxRuntime.jsx(SelectRootContext.Provider, {
     value: contextValue,
-    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.
+    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) {
               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 = 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 = 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);
+              }
             }
+            store.set('forceMount', true);
+            queueMicrotask(handleChange);
           }
-          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]
+        }),
+        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]
+    })
   });
 }
 
+const BOUNDARY_OFFSET = 2;
 const SELECTED_DELAY = 400;
 const stateAttributesMapping$2 = {
   ...useScrollLock.pressableTriggerOpenStateMapping,
@@ -608,7 +650,9 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
     disabled,
     native: nativeButton
   });
-  const setTriggerElement = store.useStateSetter('triggerElement');
+  const setTriggerElement = useScrollLock.useStableCallback(element => {
+    store.set('triggerElement', element);
+  });
   const timeoutFocus = useScrollLock.useTimeout();
   const timeoutMouseDown = useScrollLock.useTimeout();
   const selectedDelayTimeout = useScrollLock.useTimeout();
@@ -637,7 +681,7 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
   const mergedProps = useRenderElement.mergeProps(triggerProps, {
     id,
     role: 'combobox',
-    'aria-expanded': open,
+    'aria-expanded': open ? 'true' : 'false',
     'aria-haspopup': 'listbox',
     'aria-controls': open ? listElement?.id ?? useScrollLock.getFloatingFocusElement(positionerElement)?.id : undefined,
     'aria-labelledby': ariaLabelledBy,
@@ -686,7 +730,8 @@ const SelectTrigger = /*#__PURE__*/React__namespace.forwardRef(function SelectTr
         if (useScrollLock.contains(triggerRef.current, mouseUpTarget) || useScrollLock.contains(positionerRef.current, mouseUpTarget)) {
           return;
         }
-        if (useCompositeListItem.isMouseWithinBounds(mouseEvent, triggerRef.current)) {
+        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) {
           return;
         }
         setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.cancelOpen, mouseEvent));
@@ -761,7 +806,7 @@ const SelectValue = /*#__PURE__*/React__namespace.forwardRef(function SelectValu
     children = childrenProp(value);
   } else if (childrenProp != null) {
     children = childrenProp;
-  } else if (shouldCheckNullItemLabel && !hasNullLabel) {
+  } else if (!hasSelectedValue && placeholder != null && !hasNullLabel) {
     children = placeholder;
   } else if (Array.isArray(value)) {
     children = useCompositeListItem.resolveMultipleLabels(value, items, itemToStringLabel);
@@ -780,6 +825,9 @@ 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
@@ -790,9 +838,12 @@ const SelectPortal = /*#__PURE__*/React__namespace.forwardRef(function SelectPor
   if (!shouldRender) {
     return null;
   }
-  return /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingPortal, {
-    ref: forwardedRef,
-    ...portalProps
+  return /*#__PURE__*/jsxRuntime.jsx(SelectPortalContext.Provider, {
+    value: true,
+    children: /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingPortal, {
+      ref: forwardedRef,
+      ...portalProps
+    })
   });
 });
 if (process.env.NODE_ENV !== "production") SelectPortal.displayName = "SelectPortal";
@@ -832,19 +883,17 @@ const FIXED = {
 const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function SelectPositioner(componentProps, forwardedRef) {
   const {
     anchor,
+    positionMethod = 'absolute',
     className,
     render,
-    // `useAnchorPositioning` applies the same defaults to the undefined values; the names
-    // remain destructured to exclude the props from `elementProps`.
-    positionMethod,
-    side,
-    align,
-    sideOffset,
-    alignOffset,
+    side = 'bottom',
+    align = 'center',
+    sideOffset = 0,
+    alignOffset = 0,
     collisionBoundary = 'clipping-ancestors',
     collisionPadding,
-    arrowPadding,
-    sticky,
+    arrowPadding = 5,
+    sticky = false,
     disableAnchorTracking,
     alignItemWithTrigger = true,
     collisionAvoidance = useScrollLock.DROPDOWN_COLLISION_AVOIDANCE,
@@ -860,9 +909,9 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
     valuesRef,
     initialValueRef,
     popupRef,
-    setValue,
-    floatingContext: floatingRootContext
+    setValue
   } = 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);
@@ -879,6 +928,16 @@ 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({
@@ -909,7 +968,9 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
   useScrollLock.useIsoLayoutEffect(() => {
     store.set('popupSide', positioning.side);
   }, [store, positioning.side]);
-  const setPositionerElement = store.useStateSetter('positionerElement');
+  const setPositionerElement = useScrollLock.useStableCallback(element => {
+    store.set('positionerElement', element);
+  });
   const element = useCompositeListItem.usePositioner(componentProps, state, {
     styles: positionerStyles,
     transitionStatus,
@@ -920,6 +981,9 @@ 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;
     }
@@ -943,8 +1007,9 @@ const SelectPositioner = /*#__PURE__*/React__namespace.forwardRef(function Selec
       }
     }
     if (prevSize !== 0 && store.state.multiple && Array.isArray(value)) {
-      const nextValue = value.filter(selectedItemValue => useCompositeListItem.findItemIndex(valuesRef.current, selectedItemValue, isItemEqualToValue) !== -1);
-      if (nextValue.length !== value.length) {
+      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))) {
         setValue(nextValue, eventDetails);
         if (nextValue.length === 0) {
           store.set('selectedIndex', null);
@@ -1018,8 +1083,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     handleScrollArrowVisibility,
     scrollHandlerRef,
     listRef,
-    highlightItemOnHover,
-    floatingContext: floatingRootContext
+    highlightItemOnHover
   } = useSelectRootContext();
   const {
     side,
@@ -1029,6 +1093,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     setControlledAlignItemWithTrigger
   } = useSelectPositionerContext();
   const insideToolbar = useToolbarRootContext(true) != null;
+  const floatingRootContext = useSelectFloatingContext();
   const direction = useScrollLock.useDirection();
   const {
     nonce,
@@ -1051,16 +1116,20 @@ 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 (reachedMaxHeightRef.current || !alignItemWithTriggerActive || !isTopPositioned && !isBottomPositioned) {
-      handleScrollArrowVisibility(scroller);
+    if (!isTopPositioned && !isBottomPositioned) {
+      handleScrollArrowVisibility();
       return;
     }
     const scale = getScale(positionerElement);
     const currentHeight = normalizeSize(positionerElement.getBoundingClientRect().height, 'y', scale);
     const doc = useScrollLock.ownerDocument(positionerElement);
-    const win = useScrollLock.getWindow(positionerElement);
+    const win = floatingUi_utils.getWindow(positionerElement);
     const positionerStyles = win.getComputedStyle(positionerElement);
     const marginTop = parseFloat(positionerStyles.marginTop);
     const marginBottom = parseFloat(positionerStyles.marginBottom);
@@ -1068,50 +1137,63 @@ 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);
-
-    // `Infinity` requests a scroll to the recomputed maximum offset.
+    let nextPositionerHeight = 0;
     let nextScrollTop = null;
+    let setReachedMax = false;
+    let scrollToMax = false;
     const setHeight = height => {
       positionerElement.style.height = `${height}px`;
     };
-    const diff = isTopPositioned ? maxScrollTop - scrollTop : scrollTop;
-    const nextHeight = Math.min(currentHeight + diff, maxAvailableHeight);
-    if (diff <= scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
+    const handleSmallDiff = (diff, targetScrollTop) => {
       const heightDelta = scrollEdges.clamp(diff, 0, maxAvailableHeight - currentHeight);
       if (heightDelta > 0) {
         // Consume the remaining scroll in height.
         setHeight(currentHeight + heightDelta);
       }
-      scroller.scrollTop = isTopPositioned ? maxScrollTop : 0;
+      scroller.scrollTop = targetScrollTop;
       if (maxAvailableHeight - (currentHeight + heightDelta) <= scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
         reachedMaxHeightRef.current = true;
       }
-      handleScrollArrowVisibility(scroller);
+      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);
       return;
     }
     if (maxAvailableHeight - nextHeight > scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
-      nextScrollTop = isTopPositioned ? Infinity : 0;
-    } else if (isBottomPositioned && scrollTop < maxScrollTop) {
-      const overshoot = currentHeight + diff - maxAvailableHeight;
-      nextScrollTop = scrollTop - (diff - overshoot);
+      if (isTopPositioned) {
+        scrollToMax = true;
+      } else {
+        nextScrollTop = 0;
+      }
+    } else {
+      setReachedMax = true;
+      if (isBottomPositioned && scrollTop < maxScrollTop) {
+        const overshoot = currentHeight + diff - maxAvailableHeight;
+        nextScrollTop = scrollTop - (diff - overshoot);
+      }
     }
-    const nextPositionerHeight = Math.ceil(nextHeight);
+    nextPositionerHeight = Math.ceil(nextPositionerHeight);
     if (nextPositionerHeight !== 0) {
       setHeight(nextPositionerHeight);
     }
-    if (nextScrollTop != null) {
+    if (scrollToMax || nextScrollTop != null) {
       // Recompute bounds after resizing (clientHeight likely changed).
-      const target = scrollEdges.clamp(nextScrollTop, 0, getMaxScrollTop(scroller));
+      const nextMaxScrollTop = getMaxScrollTop(scroller);
+      const target = scrollToMax ? nextMaxScrollTop : scrollEdges.clamp(nextScrollTop, 0, nextMaxScrollTop);
 
       // Avoid adjustments that re-trigger scroll events forever.
       if (Math.abs(scroller.scrollTop - target) > scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
         scroller.scrollTop = target;
       }
     }
-    if (nextPositionerHeight >= maxAvailableHeight - scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
+    if (setReachedMax || nextPositionerHeight >= maxAvailableHeight - scrollEdges.SCROLL_EDGE_TOLERANCE_PX) {
       reachedMaxHeightRef.current = true;
     }
-    handleScrollArrowVisibility(scroller);
+    handleScrollArrowVisibility();
   });
   React__namespace.useImperativeHandle(scrollHandlerRef, () => handleScroll, [handleScroll]);
   useScrollLock.useOpenChangeComplete({
@@ -1162,18 +1244,17 @@ 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) {
-      // 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));
+      initialPlacedRef.current = true;
+      scrollArrowFrame.request(handleScrollArrowVisibility);
+      popupElement.style.removeProperty('--transform-origin');
       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) {
@@ -1181,7 +1262,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
         textElement = !hasSelectedValue && firstItemTextRef.current?.isConnected ? firstItemTextRef.current : null;
       }
       const valueElement = valueRef.current;
-      const win = useScrollLock.getWindow(positionerElement);
+      const win = floatingUi_utils.getWindow(positionerElement);
       const positionerStyles = win.getComputedStyle(positionerElement);
       const popupStyles = win.getComputedStyle(popupElement);
       const doc = useScrollLock.ownerDocument(triggerElement);
@@ -1242,6 +1323,7 @@ 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;
@@ -1260,16 +1342,18 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
         const popupTop = positionerRect.top;
         const popupHeight = positionerRect.height;
         const textCenterY = textRect.top + textRect.height / 2;
-        const clampedY = scrollEdges.clamp(popupHeight > 0 ? (textCenterY - popupTop) / popupHeight * 100 : 50, 0, 100);
+        const transformOriginY = popupHeight > 0 ? (textCenterY - popupTop) / popupHeight * 100 : 50;
+        const clampedY = scrollEdges.clamp(transformOriginY, 0, 100);
         popupElement.style.setProperty('--transform-origin', `50% ${clampedY}%`);
       }
       if (initialHeight === viewportHeight || height >= maxPopupHeight) {
         reachedMaxHeightRef.current = true;
       }
-      handleScrollArrowVisibility(scroller);
+      handleScrollArrowVisibility();
       if (highlightItemOnHover && store.state.selectedIndex === null && store.state.activeIndex === null && listRef.current[0] != null) {
         store.set('activeIndex', 0);
       }
+      initialPlacedRef.current = true;
     } finally {
       restoreTransformStyles();
     }
@@ -1278,7 +1362,7 @@ const SelectPopup = /*#__PURE__*/React__namespace.forwardRef(function SelectPopu
     if (!alignItemWithTriggerActive || !positionerElement || !open) {
       return undefined;
     }
-    const win = useScrollLock.getWindow(positionerElement);
+    const win = floatingUi_utils.getWindow(positionerElement);
     function handleResize(event) {
       setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.windowResize, event));
     }
@@ -1308,14 +1392,15 @@ 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), elementProps]
+    props: [popupProps, defaultProps, useCompositeListItem.getDisabledMountTransitionStyles(transitionStatus), {
+      className: !listElement && alignItemWithTriggerActive ? scrollEdges.styleDisableScrollbar.className : undefined
+    }, elementProps]
   });
   return /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
     children: [!disableStyleElements && scrollEdges.styleDisableScrollbar.getElement(nonce), /*#__PURE__*/jsxRuntime.jsx(useScrollLock.FloatingFocusManager, {
@@ -1331,7 +1416,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) {
@@ -1339,13 +1424,13 @@ function getMaxScrollTop(scroller) {
 }
 function getScale(element) {
   // The platform API is async-capable, but the DOM platform returns a plain scale object.
-  return useCompositeListItem.platform.getScale(element);
+  return floatingUi_reactDom.platform.getScale(element);
 }
 function normalizeSize(size, axis, scale) {
   return size / scale[axis];
 }
 function normalizeRect(rect, scale) {
-  return useScrollLock.rectToClientRect({
+  return floatingUi_utils.rectToClientRect({
     x: normalizeSize(rect.x, 'x', scale),
     y: normalizeSize(rect.y, 'y', scale),
     width: normalizeSize(rect.width, 'x', scale),
@@ -1389,14 +1474,14 @@ const SelectList = /*#__PURE__*/React__namespace.forwardRef(function SelectList(
   } = componentProps;
   const {
     store,
-    scrollHandlerRef,
-    multiple
+    scrollHandlerRef
   } = 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`,
@@ -1410,7 +1495,9 @@ const SelectList = /*#__PURE__*/React__namespace.forwardRef(function SelectList(
     }),
     className: hasScrollArrows && openMethod !== 'touch' ? scrollEdges.styleDisableScrollbar.className : undefined
   };
-  const setListElement = store.useStateSetter('listElement');
+  const setListElement = useScrollLock.useStableCallback(element => {
+    store.set('listElement', element);
+  });
   return useRenderElement.useRenderElement('div', componentProps, {
     ref: [forwardedRef, setListElement],
     props: [defaultProps, elementProps]
@@ -1435,15 +1522,15 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     style,
     value: itemValue = null,
     label,
-    disabled: disabledProp = false,
+    disabled = false,
     nativeButton = false,
     ...elementProps
   } = componentProps;
   const textRef = React__namespace.useRef(null);
   const listItem = useCompositeListItem.useCompositeListItem({
-    guess: true,
     label,
-    textRef
+    textRef,
+    indexGuessBehavior: useCompositeListItem.IndexGuessBehavior.GuessFromOrder
   });
   const {
     store,
@@ -1458,22 +1545,28 @@ 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];
     };
-  }, [index, itemValue, valuesRef]);
+  }, [hasRegistered, index, itemValue, valuesRef]);
   useScrollLock.useIsoLayoutEffect(() => {
+    if (!hasRegistered) {
+      return;
+    }
     const selectedValue = store.state.value;
     let selectedCandidate = selectedValue;
     if (multiple && Array.isArray(selectedValue)) {
@@ -1489,7 +1582,8 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
         selectedItemTextRef.current = textRef.current;
       }
     }
-  }, [index, multiple, isItemEqualToValue, store, itemValue, selectedItemTextRef]);
+  }, [hasRegistered, index, multiple, isItemEqualToValue, store, itemValue, selectedItemTextRef]);
+  const lastKeyRef = React__namespace.useRef(null);
   const pointerTypeRef = React__namespace.useRef('mouse');
   const allowMouseSelectionRef = React__namespace.useRef(false);
   const {
@@ -1530,15 +1624,14 @@ 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 = pointerTypeRef.current !== 'touch';
+      const isMouseClick = event.type === 'click' && 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
@@ -1550,9 +1643,15 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
       // assistive technology activation.
       const isInvalidMouseClick = isMouseClick && !isVirtualMouseClick && !allowMouseSelectionRef.current;
       allowMouseSelectionRef.current = false;
-      if (disabled || isInvalidMouseClick) {
+
+      // Prevent double commit on {Enter}
+      if (event.type === 'keydown' && lastKeyRef.current === null) {
+        return;
+      }
+      if (disabled || event.type === 'keydown' && lastKeyRef.current === ' ' && typingRef.current || isInvalidMouseClick) {
         return;
       }
+      lastKeyRef.current = null;
       commitSelection(event.nativeEvent);
     },
     onPointerEnter(event) {
@@ -1601,8 +1700,9 @@ const SelectItem = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__namesp
     selected,
     index,
     textRef,
-    selectedByFocus
-  }), [selected, index, textRef, selectedByFocus]);
+    selectedByFocus,
+    hasRegistered
+  }), [selected, index, textRef, selectedByFocus, hasRegistered]);
   return /*#__PURE__*/jsxRuntime.jsx(SelectItemContext.Provider, {
     value: contextValue,
     children: element
@@ -1611,10 +1711,11 @@ 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 = componentProps.keepMounted || selected;
+  const shouldRender = keepMounted || selected;
   if (!shouldRender) {
     return null;
   }
@@ -1680,7 +1781,8 @@ const SelectItemText = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__na
   const {
     index,
     textRef,
-    selectedByFocus
+    selectedByFocus,
+    hasRegistered
   } = useSelectItemContext();
   const {
     firstItemTextRef,
@@ -1696,13 +1798,13 @@ const SelectItemText = /*#__PURE__*/React__namespace.memo(/*#__PURE__*/React__na
     if (!node) {
       return;
     }
-    if (index === 0) {
+    if (hasRegistered && index === 0) {
       firstItemTextRef.current = node;
     }
-    if (selectedByFocus) {
+    if (hasRegistered && selectedByFocus) {
       selectedItemTextRef.current = node;
     }
-  }, [firstItemTextRef, selectedItemTextRef, index, selectedByFocus]);
+  }, [firstItemTextRef, selectedItemTextRef, index, selectedByFocus, hasRegistered]);
   const element = useRenderElement.useRenderElement('div', componentProps, {
     ref: [localRef, forwardedRef, textRef],
     props: elementProps
@@ -1767,9 +1869,6 @@ 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,