@jobber/components 9.6.0 → 9.6.2

package/dist/unstyledPrimitives/index.cjs

@@ -1,23 +1,24 @@
 'use strict';
 
 var React = require('react');
-var ComboboxSeparator = require('../ComboboxSeparator-cjs.js');
+var ComboboxChipRemove = require('../ComboboxChipRemove-cjs.js');
 var useCompositeListItem = require('../useCompositeListItem-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var useScrollLock = require('../useScrollLock-cjs.js');
+var Separator = require('../Separator-cjs.js');
 var DrawerDescription = require('../DrawerDescription-cjs.js');
 var DrawerTitle = require('../DrawerTitle-cjs.js');
 var ScrollAreaViewport = require('../ScrollAreaViewport-cjs.js');
 var useRenderElement = require('../useRenderElement-cjs.js');
+var floatingUi_utils = require('../floating-ui.utils-cjs.js');
 var scrollEdges = require('../scrollEdges-cjs.js');
-var scrollable = require('../scrollable-cjs.js');
 var MenuSubmenuTrigger = require('../MenuSubmenuTrigger-cjs.js');
 var ReactDOM = require('react-dom');
 var SelectGroupLabel = require('../SelectGroupLabel-cjs.js');
-var Separator = require('../Separator-cjs.js');
 var NumberFieldInput = require('../NumberFieldInput-cjs.js');
 var useLabel = require('../useLabel-cjs.js');
 require('../stringifyLocale-cjs.js');
+require('../floating-ui.react-dom-cjs.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -72,9 +73,7 @@ function AutocompleteRoot(props) {
   } else {
     resolvedInputValue = internalValue;
   }
-  const collator = ComboboxSeparator.useCoreFilter({
-    locale: other.locale
-  });
+  const collator = ComboboxChipRemove.useCoreFilter();
   const baseFilter = React__namespace.useMemo(() => {
     if (other.filter !== undefined) {
       return other.filter;
@@ -107,9 +106,17 @@ function AutocompleteRoot(props) {
     if (eventDetails.reason === useScrollLock.pointer) {
       return;
     }
-    setInlineInputValue(enableInline && highlightedValue != null ? useCompositeListItem.stringifyAsLabel(highlightedValue, itemToStringValue) : '');
+    if (enableInline) {
+      if (highlightedValue == null) {
+        setInlineInputValue('');
+      } else {
+        setInlineInputValue(useCompositeListItem.stringifyAsLabel(highlightedValue, itemToStringValue));
+      }
+    } else {
+      setInlineInputValue('');
+    }
   }
-  return /*#__PURE__*/jsxRuntime.jsx(ComboboxSeparator.AriaCombobox, {
+  return /*#__PURE__*/jsxRuntime.jsx(ComboboxChipRemove.AriaCombobox, {
     ...other,
     itemToStringLabel: itemToStringValue,
     openOnInputClick: openOnInputClick,
@@ -128,7 +135,7 @@ function AutocompleteValue(props) {
   const {
     children
   } = props;
-  const inputValue = ComboboxSeparator.useComboboxInputValueContext();
+  const inputValue = ComboboxChipRemove.useComboboxInputValueContext();
   let returnValue = null;
   if (typeof children === 'function') {
     returnValue = children(String(inputValue));
@@ -148,7 +155,7 @@ function AutocompleteValue(props) {
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteTrigger = ComboboxSeparator.ComboboxTrigger;
+const AutocompleteTrigger = ComboboxChipRemove.ComboboxTrigger;
 
 /**
  * A wrapper for the input and its associated controls.
@@ -156,7 +163,7 @@ const AutocompleteTrigger = ComboboxSeparator.ComboboxTrigger;
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteInputGroup = ComboboxSeparator.ComboboxInputGroup;
+const AutocompleteInputGroup = ComboboxChipRemove.ComboboxInputGroup;
 
 /**
  * An individual item in the list.
@@ -164,41 +171,33 @@ const AutocompleteInputGroup = ComboboxSeparator.ComboboxInputGroup;
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteItem = ComboboxSeparator.ComboboxItem;
-
-/**
- * A visual separator between items or groups.
- * Renders a `<div>` element.
- *
- * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
- */
-const AutocompleteSeparator = ComboboxSeparator.ListboxSeparator;
+const AutocompleteItem = ComboboxChipRemove.ComboboxItem;
 
 var index_parts$7 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Arrow: ComboboxSeparator.ComboboxArrow,
-  Backdrop: ComboboxSeparator.ComboboxBackdrop,
-  Clear: ComboboxSeparator.ComboboxClear,
-  Collection: ComboboxSeparator.ComboboxCollection,
-  Empty: ComboboxSeparator.ComboboxEmpty,
-  Group: ComboboxSeparator.ComboboxGroup,
-  GroupLabel: ComboboxSeparator.ComboboxGroupLabel,
-  Icon: ComboboxSeparator.ComboboxIcon,
-  Input: ComboboxSeparator.ComboboxInput,
+  Arrow: ComboboxChipRemove.ComboboxArrow,
+  Backdrop: ComboboxChipRemove.ComboboxBackdrop,
+  Clear: ComboboxChipRemove.ComboboxClear,
+  Collection: ComboboxChipRemove.ComboboxCollection,
+  Empty: ComboboxChipRemove.ComboboxEmpty,
+  Group: ComboboxChipRemove.ComboboxGroup,
+  GroupLabel: ComboboxChipRemove.ComboboxGroupLabel,
+  Icon: ComboboxChipRemove.ComboboxIcon,
+  Input: ComboboxChipRemove.ComboboxInput,
   InputGroup: AutocompleteInputGroup,
   Item: AutocompleteItem,
-  List: ComboboxSeparator.ComboboxList,
-  Popup: ComboboxSeparator.ComboboxPopup,
-  Portal: ComboboxSeparator.ComboboxPortal,
-  Positioner: ComboboxSeparator.ComboboxPositioner,
+  List: ComboboxChipRemove.ComboboxList,
+  Popup: ComboboxChipRemove.ComboboxPopup,
+  Portal: ComboboxChipRemove.ComboboxPortal,
+  Positioner: ComboboxChipRemove.ComboboxPositioner,
   Root: AutocompleteRoot,
-  Row: ComboboxSeparator.ComboboxRow,
-  Separator: AutocompleteSeparator,
-  Status: ComboboxSeparator.ComboboxStatus,
+  Row: ComboboxChipRemove.ComboboxRow,
+  Separator: Separator.Separator,
+  Status: ComboboxChipRemove.ComboboxStatus,
   Trigger: AutocompleteTrigger,
   Value: AutocompleteValue,
-  useFilter: ComboboxSeparator.useCoreFilter,
-  useFilteredItems: ComboboxSeparator.useFilteredItems
+  useFilter: ComboboxChipRemove.useCoreFilter,
+  useFilteredItems: ComboboxChipRemove.useFilteredItems
 });
 
 var index_parts$6 = /*#__PURE__*/Object.freeze({
@@ -209,14 +208,14 @@ var index_parts$6 = /*#__PURE__*/Object.freeze({
   Handle: DrawerDescription.DialogHandle,
   Popup: DrawerDescription.DialogPopup,
   Portal: ScrollAreaViewport.DialogPortal,
-  Root: DrawerDescription.DialogRoot,
+  Root: ScrollAreaViewport.DialogRoot,
   Title: DrawerTitle.DialogTitle,
   Trigger: ScrollAreaViewport.DialogTrigger,
   Viewport: ScrollAreaViewport.DialogViewport,
   createHandle: DrawerDescription.createDialogHandle
 });
 
-const stateAttributesMapping$3 = {
+const stateAttributesMapping$5 = {
   active(value) {
     if (value) {
       return {
@@ -287,12 +286,12 @@ const DrawerIndent = /*#__PURE__*/React__namespace.forwardRef(function DrawerInd
         [ScrollAreaViewport.DrawerBackdropCssVars.swipeProgress]: '0'
       }
     }, elementProps],
-    stateAttributesMapping: stateAttributesMapping$3
+    stateAttributesMapping: stateAttributesMapping$5
   });
 });
 if (process.env.NODE_ENV !== "production") DrawerIndent.displayName = "DrawerIndent";
 
-const stateAttributesMapping$2 = {
+const stateAttributesMapping$4 = {
   active(value) {
     if (value) {
       return {
@@ -327,7 +326,7 @@ const DrawerIndentBackground = /*#__PURE__*/React__namespace.forwardRef(function
     ref: forwardedRef,
     state,
     props: elementProps,
-    stateAttributesMapping: stateAttributesMapping$2
+    stateAttributesMapping: stateAttributesMapping$4
   });
 });
 if (process.env.NODE_ENV !== "production") DrawerIndentBackground.displayName = "DrawerIndentBackground";
@@ -336,26 +335,37 @@ function DrawerProvider(props) {
   const {
     children
   } = props;
-  const [openDrawers, setOpenDrawers] = React__namespace.useState(() => new Set());
+  const [openById, setOpenById] = React__namespace.useState(() => new Map());
   const [visualStateStore] = React__namespace.useState(createVisualStateStore);
-  const setDrawerOpen = useScrollLock.useStableCallback((drawer, open) => {
-    setOpenDrawers(prev => {
-      if (prev.has(drawer) === open) {
+  const setDrawerOpen = useScrollLock.useStableCallback((drawerId, open) => {
+    setOpenById(prev => {
+      const prevOpen = prev.get(drawerId);
+      if (prevOpen === open) {
         return prev;
       }
-      const next = new Set(prev);
-      if (open) {
-        next.add(drawer);
-      } else {
-        next.delete(drawer);
-      }
+      const next = new Map(prev);
+      next.set(drawerId, open);
       return next;
     });
   });
-  const removeDrawer = useScrollLock.useStableCallback(drawer => {
-    setDrawerOpen(drawer, false);
+  const removeDrawer = useScrollLock.useStableCallback(drawerId => {
+    setOpenById(prev => {
+      if (!prev.has(drawerId)) {
+        return prev;
+      }
+      const next = new Map(prev);
+      next.delete(drawerId);
+      return next;
+    });
   });
-  const active = openDrawers.size > 0;
+  const active = React__namespace.useMemo(() => {
+    for (const open of openById.values()) {
+      if (open) {
+        return true;
+      }
+    }
+    return false;
+  }, [openById]);
   const contextValue = React__namespace.useMemo(() => ({
     setDrawerOpen,
     removeDrawer,
@@ -445,7 +455,7 @@ const SWIPE_AREA_SWIPING_HOOK = {
 const SWIPE_AREA_DISABLED_HOOK = {
   [DrawerSwipeAreaDataAttributes.disabled]: ''
 };
-const stateAttributesMapping$1 = {
+const stateAttributesMapping$3 = {
   open(value) {
     return value ? SWIPE_AREA_OPEN_HOOK : SWIPE_AREA_CLOSED_HOOK;
   },
@@ -453,9 +463,9 @@ const stateAttributesMapping$1 = {
     return value ? SWIPE_AREA_SWIPING_HOOK : null;
   },
   swipeDirection(value) {
-    return {
+    return value ? {
       [DrawerSwipeAreaDataAttributes.swipeDirection]: value
-    };
+    } : null;
   },
   disabled(value) {
     return value ? SWIPE_AREA_DISABLED_HOOK : null;
@@ -486,14 +496,16 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     swipeDirection: swipeDirectionProp,
     ...elementProps
   } = componentProps;
-  const store = ScrollAreaViewport.useDialogRootContext();
+  const {
+    store
+  } = ScrollAreaViewport.useDialogRootContext();
   const {
     swipeDirection,
-    frontmostHeight,
-    swipeAreaActiveRef
+    frontmostHeight
   } = ScrollAreaViewport.useDrawerRootContext();
   const providerContext = ScrollAreaViewport.useDrawerProviderContext();
   const [swipeActive, setSwipeActive] = React__namespace.useState(false);
+  const releaseDismissTimeout = useScrollLock.useTimeout();
   const swipeAreaRef = React__namespace.useRef(null);
   const swipeStartEventRef = React__namespace.useRef(null);
   const openedBySwipeRef = React__namespace.useRef(false);
@@ -503,10 +515,7 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   });
   const closedOffsetRef = React__namespace.useRef(null);
   const appliedSwipeStylesRef = React__namespace.useRef(false);
-  const swipePopupElementRef = React__namespace.useRef(null);
-  const swipeBackdropElementRef = React__namespace.useRef(null);
   const popupTransitionRef = React__namespace.useRef(null);
-  const releaseGuardCleanupRef = React__namespace.useRef(useRenderElement.NOOP);
   const swipeAreaId = useScrollLock.useBaseUiId(componentProps.id);
   const registerTrigger = useScrollLock.useTriggerRegistration(swipeAreaId, store);
   const open = store.useState('open');
@@ -518,40 +527,21 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   const dismissDirection = oppositeSwipeDirection[resolvedSwipeDirection];
   const enabled = !disabled && (!open || swipeActive);
   function disableDismissForSwipe() {
-    releaseGuardCleanupRef.current();
+    releaseDismissTimeout.clear();
     store.context.outsidePressEnabledRef.current = false;
   }
-  const enableDismissAfterRelease = useScrollLock.useStableCallback(() => {
-    releaseGuardCleanupRef.current();
-    const doc = useScrollLock.ownerDocument(swipeAreaRef.current);
-    function restore(event) {
-      // The gesture's trailing release click is the one physical click with no `pointerdown` of
-      // its own. Ignore it and keep waiting, so it cannot dismiss the drawer it just opened,
-      // while a click-only activation (keyboard or assistive tech) still re-enables in time.
-      if (event?.type === 'click' && event.detail !== 0 && !useScrollLock.isVirtualClick(event)) {
-        return;
-      }
-      releaseGuardCleanupRef.current = useRenderElement.NOOP;
-      doc.removeEventListener('pointerdown', restore, true);
-      doc.removeEventListener('click', restore, true);
+  function enableDismissAfterRelease() {
+    // Safari can dispatch outside-press for the same swipe-open gesture
+    // after release, so defer re-enabling dismissal to the next macrotask.
+    releaseDismissTimeout.start(0, () => {
       store.context.outsidePressEnabledRef.current = true;
+    });
+  }
+  function resolvePopupSize() {
+    const popupElement = store.context.popupRef.current;
+    if (!popupElement) {
+      return null;
     }
-
-    // The pointerup that ends a swipe-open gesture synthesizes a `click`. When the drag released
-    // outside the popup (e.g. it was dragged past the popup's size), that click would be treated as
-    // an outside press and immediately dismiss the drawer that was just opened. Keep outside-press
-    // dismissal disabled until the next interaction that isn't that release click: a deliberate
-    // outside press starts with a `pointerdown`, and a click-only activation (keyboard or
-    // assistive tech) is distinguishable from a physical release. This is deterministic, unlike
-    // re-enabling on a timer that can race the synthesized click and dismiss at random.
-    //
-    // `restore` runs in document capture, ahead of floating-ui's own outside-press check (which
-    // happens on the event target, after capture), so the triggering press still dismisses.
-    releaseGuardCleanupRef.current = restore;
-    doc.addEventListener('pointerdown', restore, true);
-    doc.addEventListener('click', restore, true);
-  });
-  function getPopupSize(popupElement) {
     const isHorizontal = dismissDirection === 'left' || dismissDirection === 'right';
     const size = isHorizontal ? popupElement.offsetWidth : popupElement.offsetHeight;
     if (size <= 0) {
@@ -559,15 +549,15 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     }
     return size;
   }
-  function resolvePopupSize() {
-    const popupElement = store.context.popupRef.current;
-    return popupElement ? getPopupSize(popupElement) : null;
-  }
-  function resolveClosedOffset(popupElement) {
-    const offset = getPopupSize(popupElement);
+  function resolveClosedOffset() {
+    const offset = resolvePopupSize();
     if (offset == null) {
       return null;
     }
+    const popupElement = store.context.popupRef.current;
+    if (!popupElement) {
+      return offset;
+    }
     const isHorizontal = dismissDirection === 'left' || dismissDirection === 'right';
     const transform = ScrollAreaViewport.getElementTransform(popupElement);
     const transformOffset = isHorizontal ? transform.x : transform.y;
@@ -584,6 +574,9 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     return popupSize * DEFAULT_SWIPE_OPEN_RATIO;
   }
   function applySwipeMovement() {
+    if (!swipeActive) {
+      return;
+    }
     const popupElement = store.context.popupRef.current;
     if (!popupElement) {
       return;
@@ -592,10 +585,10 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       return;
     }
     if (closedOffsetRef.current == null) {
-      closedOffsetRef.current = resolveClosedOffset(popupElement);
+      closedOffsetRef.current = resolveClosedOffset();
     }
     const closedOffset = closedOffsetRef.current;
-    if (closedOffset === null) {
+    if (!closedOffset || !Number.isFinite(closedOffset) || closedOffset <= 0) {
       return;
     }
     const {
@@ -616,7 +609,6 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     popupElement.style.setProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementX, `${movementX}px`);
     popupElement.style.setProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementY, `${movementY}px`);
     popupElement.setAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping, '');
-    swipePopupElementRef.current = popupElement;
     if (popupTransitionRef.current === null) {
       popupTransitionRef.current = popupElement.style.transition;
     }
@@ -624,7 +616,6 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     const backdropElement = store.context.backdropRef.current;
     if (backdropElement) {
       backdropElement.setAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping, '');
-      swipeBackdropElementRef.current = backdropElement;
       backdropElement.style.setProperty(ScrollAreaViewport.DrawerBackdropCssVars.swipeProgress, `${backdropProgress}`);
       if (openProgress > 0 && frontmostHeight > 0) {
         backdropElement.style.setProperty(ScrollAreaViewport.DrawerPopupCssVars.height, `${frontmostHeight}px`);
@@ -637,11 +628,10 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       frontmostHeight: openProgress > 0 ? frontmostHeight : 0
     });
     appliedSwipeStylesRef.current = true;
-    swipeAreaActiveRef.current = true;
   }
   const clearSwipeStyles = useScrollLock.useStableCallback(() => {
-    const popupElement = swipePopupElementRef.current;
-    if (popupElement) {
+    const popupElement = store.context.popupRef.current;
+    if (popupElement && appliedSwipeStylesRef.current) {
       popupElement.style.removeProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementX);
       popupElement.style.removeProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementY);
       popupElement.removeAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping);
@@ -650,7 +640,7 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       popupElement.style.transition = popupTransitionRef.current;
       popupTransitionRef.current = null;
     }
-    const backdropElement = swipeBackdropElementRef.current;
+    const backdropElement = store.context.backdropRef.current;
     if (backdropElement) {
       backdropElement.removeAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping);
       backdropElement.style.setProperty(ScrollAreaViewport.DrawerBackdropCssVars.swipeProgress, '0');
@@ -661,16 +651,19 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       frontmostHeight: 0
     });
     appliedSwipeStylesRef.current = false;
-    swipePopupElementRef.current = null;
-    swipeBackdropElementRef.current = null;
-    swipeAreaActiveRef.current = false;
   });
   function openDrawer(event) {
+    if (store.select('open')) {
+      return;
+    }
     openedBySwipeRef.current = true;
-    store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current));
+    store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current ?? undefined));
   }
   function closeDrawer(event) {
-    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current));
+    if (!store.select('open')) {
+      return;
+    }
+    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current ?? undefined));
   }
   function resetSwipeInteractionState() {
     swipeStartEventRef.current = null;
@@ -713,10 +706,10 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
         return;
       }
       const displacement = ScrollAreaViewport.getDisplacement(resolvedSwipeDirection, details.deltaX, details.deltaY);
-      if (!openedBySwipeRef.current && displacement < MIN_SWIPE_START_DISTANCE) {
+      if (displacement < MIN_SWIPE_START_DISTANCE && !openedBySwipeRef.current) {
         return;
       }
-      if (!openedBySwipeRef.current && !store.select('open')) {
+      if (!openedBySwipeRef.current) {
         openDrawer(swipeStartEventRef.current);
       }
       applySwipeMovement();
@@ -732,14 +725,14 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       const displacement = ScrollAreaViewport.getDisplacement(resolvedSwipeDirection, deltaX, deltaY);
       const releaseVelocity = ScrollAreaViewport.getDisplacement(resolvedSwipeDirection, releaseVelocityX, releaseVelocityY);
       const threshold = resolveSwipeOpenThreshold();
-      const hasEnoughDistance = displacement >= threshold;
+      const hasEnoughDistance = threshold != null && displacement >= threshold;
       const hasEnoughVelocity = releaseVelocity >= VELOCITY_THRESHOLD;
-      const shouldOpen = direction === resolvedSwipeDirection && (hasEnoughDistance || hasEnoughVelocity) && !disabled;
+      const shouldOpen = threshold != null && direction === resolvedSwipeDirection && (hasEnoughDistance || hasEnoughVelocity) && !disabled;
       if (shouldOpen) {
         if (!store.select('open')) {
           openDrawer(event);
         }
-      } else if (openedBySwipeRef.current && store.select('open')) {
+      } else if (openedBySwipeRef.current) {
         closeDrawer(event);
       }
       finishSwipeInteraction();
@@ -750,29 +743,16 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   const swipePointerProps = swipe.getPointerProps();
   const swipeTouchProps = swipe.getTouchProps();
   const resetSwipe = swipe.reset;
-
-  // The commit that opens the drawer re-renders the popup, resetting `--swipe-movement-*` to `0px`
-  // (the viewport isn't swiping). Re-assert after the DOM mutation but before paint. No deps: must
-  // run on every commit the swipe area participates in.
-  useScrollLock.useIsoLayoutEffect(() => {
-    if (swipeActive && appliedSwipeStylesRef.current) {
-      applySwipeMovement();
-    }
-  });
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (!enabled) {
-      if (swipeActive) {
-        enableDismissAfterRelease();
-      }
       resetSwipe();
       resetDragDelta();
       clearSwipeStyles();
       resetSwipeInteractionState();
     }
-  }, [clearSwipeStyles, enableDismissAfterRelease, enabled, resetDragDelta, resetSwipe, swipeActive]);
+  }, [clearSwipeStyles, enabled, resetDragDelta, resetSwipe]);
   React__namespace.useEffect(() => {
     return () => {
-      releaseGuardCleanupRef.current();
       store.context.outsidePressEnabledRef.current = true;
     };
   }, [store]);
@@ -785,7 +765,7 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   return useRenderElement.useRenderElement('div', componentProps, {
     state,
     ref: [forwardedRef, swipeAreaRef, registerTrigger],
-    stateAttributesMapping: stateAttributesMapping$1,
+    stateAttributesMapping: stateAttributesMapping$3,
     props: [{
       role: 'presentation',
       'aria-hidden': true,
@@ -845,15 +825,6 @@ const KEYBOARD_VISIBILITY_MARGIN = 16;
 // keyboard overlap, so the field can be scrolled clear of the keyboard instead of
 // ending up flush against it. Only applied when there is actual overlap.
 const KEYBOARD_SCROLL_SLACK = 48;
-// Cadence of the settle-watching realign passes after focus moves with the keyboard open:
-// long enough for a smooth scroll to show progress between passes, short enough to recover
-// quickly from a scroll canceled by WebKit's reveal; the pass count covers CSS transitions
-// reacting to the focus change (e.g. a 260ms footer resize) with room to spare.
-const KEYBOARD_REALIGN_INTERVAL = 150;
-const KEYBOARD_REALIGN_MAX_PASSES = 4;
-// Frames the alignment waits for the scroll destination to stop moving (layout reacting to
-// the focus change, e.g. a footer resizing over a CSS transition) before scrolling anyway.
-const KEYBOARD_SETTLE_FRAME_LIMIT = 60;
 const INPUT_TAP_MOVE_THRESHOLD = 10;
 const INPUT_TAP_HIT_SLOP = 16;
 const KEYBOARD_INPUT_TYPES = new Set(['email', 'number', 'password', 'search', 'tel', 'text', 'url']);
@@ -877,10 +848,11 @@ function DrawerVirtualKeyboardProvider(props) {
   const {
     children
   } = props;
-  const store = ScrollAreaViewport.useDialogRootContext();
+  const {
+    store
+  } = ScrollAreaViewport.useDialogRootContext();
   const open = store.useState('open');
   const mounted = store.useState('mounted');
-  const modal = store.useState('modal');
   const nestedOpenDialogCount = store.useState('nestedOpenDialogCount');
   const viewportElement = store.useState('viewportElement');
 
@@ -893,9 +865,7 @@ function DrawerVirtualKeyboardProvider(props) {
   const keyboardTouchStartRef = React__namespace.useRef(null);
   const focusedKeyboardTargetRef = React__namespace.useRef(null);
   const keyboardScrollAdjustmentRef = React__namespace.useRef(null);
-  const programmaticKeyboardFocusRef = React__namespace.useRef(false);
   const keyboardFocusFrame = useScrollLock.useAnimationFrame();
-  const keyboardRealignTimeout = useScrollLock.useTimeout();
   const restoreKeyboardScrollAdjustment = useScrollLock.useStableCallback(() => {
     const adjustment = keyboardScrollAdjustmentRef.current;
     if (!adjustment) {
@@ -922,7 +892,7 @@ function DrawerVirtualKeyboardProvider(props) {
       adjustment = null;
     }
     if (!adjustment) {
-      const styles = useScrollLock.getComputedStyle(element);
+      const styles = floatingUi_utils.getComputedStyle(element);
       adjustment = {
         element,
         overflowAnchor: element.style.overflowAnchor,
@@ -938,7 +908,7 @@ function DrawerVirtualKeyboardProvider(props) {
     element.style.scrollPaddingBottom = `${adjustment.computedScrollPaddingBottom + KEYBOARD_VISIBILITY_MARGIN}px`;
   });
   const animateKeyboardScroll = useScrollLock.useStableCallback((element, scrollTop) => {
-    const win = useScrollLock.getWindow(element);
+    const win = floatingUi_utils.getWindow(element);
     const behavior = win.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches ? 'auto' : 'smooth';
     element.scrollTo({
       top: scrollTop,
@@ -961,102 +931,48 @@ function DrawerVirtualKeyboardProvider(props) {
       return undefined;
     }
     const doc = useScrollLock.ownerDocument(rootElement);
-    const win = useScrollLock.getWindow(rootElement);
+    const win = floatingUi_utils.getWindow(rootElement);
     const visualViewport = win.visualViewport;
-
-    // Alignment scroll bookkeeping: destination stability, whether a scroll was issued,
-    // and the last observed progress so delayed passes can distinguish moving from stalled.
-    let keyboardScrollElement = null;
-    let keyboardScrollDestination = 0;
-    let keyboardScrollChecks = 0;
-    let keyboardScrollObserved = -1;
     const setDrawerKeyboardInset = inset => {
       rootElement.style.setProperty(DrawerViewportCssVars.keyboardInset, `${Math.max(0, Math.ceil(inset))}px`);
     };
+    const resetDrawerKeyboardInset = () => {
+      setDrawerKeyboardInset(0);
+    };
     const clearFocusedKeyboardTarget = () => {
       focusedKeyboardTargetRef.current = null;
-      keyboardScrollElement = null;
-      setDrawerKeyboardInset(0);
+      resetDrawerKeyboardInset();
       restoreKeyboardScrollAdjustment();
       keyboardFocusFrame.cancel();
-      keyboardRealignTimeout.clear();
-    };
-
-    // WebKit's native reveal scroll can move the page even while the scroll lock hides
-    // overflow (e.g. when the software keyboard's previous/next field arrows move focus).
-    // While the drawer is modal, any window scroll during keyboard interaction is spurious,
-    // so pin the page to the position it had when the drawer opened.
-    const baseScrollX = win.scrollX;
-    const baseScrollY = win.scrollY;
-    const restoreWindowScroll = () => {
-      if (modal !== true || nestedDrawerOpen || !focusedKeyboardTargetRef.current || getKeyboardVisualViewport(win) == null) {
-        return false;
-      }
-      if (win.scrollX !== baseScrollX || win.scrollY !== baseScrollY) {
-        // Force an instant jump: the two-argument form defaults `behavior` to `auto`, which
-        // obeys the page's `scroll-behavior`, so a global `scroll-behavior: smooth` would
-        // animate the restore. The measurements that follow assume the page is already back
-        // at rest, and a smooth restore also re-emits `scroll`, re-entering this handler.
-        win.scrollTo({
-          left: baseScrollX,
-          top: baseScrollY,
-          behavior: 'instant'
-        });
-        return true;
-      }
-      return false;
-    };
-
-    // Focus moved by the drawer itself goes through `focusKeyboardInputWithoutPageScroll`,
-    // but native focus changes (the iOS keyboard's previous/next field arrows) commit
-    // WebKit's reveal scroll before `focusin` reaches us — cancelling it afterwards
-    // visibly jitters the sheet. `focusout` on the outgoing field fires before focus
-    // lands, so override the incoming field's geometry there and restore it in `focusin`.
-    let restorePreemptedFocus = null;
-    const consumePreemptedFocus = () => {
-      restorePreemptedFocus?.();
-      restorePreemptedFocus = null;
-    };
-    const preemptFocusReveal = (target, keyboardViewport) => {
-      consumePreemptedFocus();
-
-      // Native focus carries no preventScroll, so a fake off-screen rect would make WebKit
-      // scroll the drawer's own scroll containers thousands of pixels chasing it. Presenting
-      // the field as already centered in the visible band above the keyboard instead makes
-      // both the in-page reveal and the viewport pan no-ops.
-      const rect = target.getBoundingClientRect();
-      restorePreemptedFocus = overrideGeometryDuringFocus(target, (keyboardViewport.top + keyboardViewport.bottom - rect.top - rect.bottom) / 2);
     };
     const alignFocusedKeyboardTarget = () => {
-      // If focus never lands on a preempted target, the focusout-scheduled alignment still
-      // restores it on the next frame before paint.
-      consumePreemptedFocus();
       const target = focusedKeyboardTargetRef.current;
       // If the focused field is removed from the DOM without firing `focusout` (e.g. it is
       // conditionally rendered away), any applied scroll slack is restored here on the next
       // focus/viewport event or when the drawer closes. This self-corrects rather than
       // tracking each field's lifecycle.
       if (nestedDrawerOpen || !target || !useScrollLock.contains(rootElement, target)) {
-        setDrawerKeyboardInset(0);
+        resetDrawerKeyboardInset();
         restoreKeyboardScrollAdjustment();
         return;
       }
-
-      // Undo any reveal scroll WebKit applied to the locked page before measuring, so the
-      // keyboard inset and alignment are computed against the resting viewport.
-      restoreWindowScroll();
       const keyboardViewport = getKeyboardVisualViewport(win);
       if (!keyboardViewport) {
-        setDrawerKeyboardInset(0);
+        resetDrawerKeyboardInset();
         restoreKeyboardScrollAdjustment();
         return;
       }
-      setDrawerKeyboardInset(Math.max(0, win.innerHeight - keyboardViewport.bottom));
+      setDrawerKeyboardInset(getDrawerKeyboardInset(win, keyboardViewport));
       const scrollTarget = findKeyboardScrollTarget(target, rootElement);
       if (!scrollTarget) {
         restoreKeyboardScrollAdjustment();
         return;
       }
+      if (!scrollTarget.isConnected || !useScrollLock.contains(rootElement, scrollTarget)) {
+        resetDrawerKeyboardInset();
+        restoreKeyboardScrollAdjustment();
+        return;
+      }
       const scrollTargetRect = scrollTarget.getBoundingClientRect();
       const clippedBottom = Math.min(scrollTargetRect.bottom, keyboardViewport.bottom);
       const overlap = Math.max(0, scrollTargetRect.bottom - keyboardViewport.bottom);
@@ -1072,70 +988,14 @@ function DrawerVirtualKeyboardProvider(props) {
         return;
       }
       const targetRect = target.getBoundingClientRect();
-      const nextScrollTop = scrollTarget.scrollTop + (targetRect.top + targetRect.bottom - visibleTop - visibleBottom) / 2;
-      const destination = Math.round(scrollEdges.clamp(nextScrollTop, 0, maxScrollTop));
-      const settled = keyboardScrollElement === scrollTarget && Math.abs(keyboardScrollDestination - destination) <= 1;
-      if (!settled) {
-        // Commit the scroll only once the destination holds across two consecutive checks.
-        // Layout may still be reacting to the focus change (e.g. a footer sized by
-        // `:focus-within` resizing over a transition), and scrolling toward a
-        // mid-transition destination overshoots, then visibly pulls back once corrected.
-        // The destination is scroll-position-invariant, so an in-flight scroll of the
-        // container itself never defers the commit.
-        const checks = keyboardScrollElement === scrollTarget ? keyboardScrollChecks + 1 : 1;
-        keyboardScrollElement = scrollTarget;
-        keyboardScrollDestination = destination;
-        keyboardScrollChecks = checks;
-        keyboardScrollObserved = -1;
-        // Re-check next frame; give up and scroll anyway if layout never settles.
-        if (checks <= KEYBOARD_SETTLE_FRAME_LIMIT) {
-          keyboardFocusFrame.request(alignFocusedKeyboardTarget);
-          return;
-        }
-      } else if (keyboardScrollObserved >= 0) {
-        // A scroll toward this destination is already out. Leave it alone while it has
-        // arrived or is still progressing — re-issuing restarts the smooth-scroll easing
-        // curve, a visible stutter on every realign pass — and re-issue only when it
-        // stalled short (WebKit cancels in-flight smooth scrolls when its native reveal
-        // for the focus resolves).
-        const current = scrollTarget.scrollTop;
-        if (Math.abs(current - destination) <= 1) {
-          return;
-        }
-        if (current !== keyboardScrollObserved) {
-          keyboardScrollObserved = current;
-          return;
-        }
-      }
-      keyboardScrollElement = scrollTarget;
-      keyboardScrollDestination = destination;
-      keyboardScrollChecks = 0;
-      keyboardScrollObserved = scrollTarget.scrollTop;
-      animateKeyboardScroll(scrollTarget, destination);
+      const targetCenter = (targetRect.top + targetRect.bottom) / 2;
+      const visibleCenter = (visibleTop + visibleBottom) / 2;
+      const nextScrollTop = scrollTarget.scrollTop + targetCenter - visibleCenter;
+      animateKeyboardScroll(scrollTarget, scrollEdges.clamp(nextScrollTop, 0, maxScrollTop));
     };
     const scheduleKeyboardFocusAlignment = () => {
       keyboardFocusFrame.request(alignFocusedKeyboardTarget);
     };
-
-    // When focus moves with the keyboard already up, no viewport resize events follow to
-    // re-run alignment, and the single frame-scheduled pass is unreliable: WebKit resolves
-    // the reveal for the focus asynchronously (a UI-process round trip) and cancels any
-    // in-flight scroll the pass started when it lands, and layout reacting to the focus
-    // change (e.g. a footer sized by `:focus-within` and the keyboard inset) settles only
-    // after its transition, so the pass measures stale geometry. Re-align on an interval
-    // until both settle; the alignment's scroll bookkeeping observes before re-issuing,
-    // so passes that find the scroll on course are inert.
-    const scheduleDelayedKeyboardRealign = () => {
-      let remainingPasses = KEYBOARD_REALIGN_MAX_PASSES;
-      const realign = () => {
-        alignFocusedKeyboardTarget();
-        remainingPasses -= 1;
-        if (remainingPasses > 0) {
-          keyboardRealignTimeout.start(KEYBOARD_REALIGN_INTERVAL, realign);
-        }
-      };
-      keyboardRealignTimeout.start(KEYBOARD_REALIGN_INTERVAL, realign);
-    };
     const captureFocusedKeyboardTarget = eventTarget => {
       if (nestedDrawerOpen) {
         return false;
@@ -1147,56 +1007,16 @@ function DrawerVirtualKeyboardProvider(props) {
       if (!target || !useScrollLock.contains(rootElement, target)) {
         return false;
       }
-
-      // A new field starts a fresh alignment; the scroll bookkeeping must not carry
-      // over from the previous field's scroll.
-      if (focusedKeyboardTargetRef.current !== target) {
-        keyboardScrollElement = null;
-      }
       focusedKeyboardTargetRef.current = target;
       return true;
     };
     const handleFocusIn = event => {
-      // The programmatic transition is over once focus lands, which happens before
-      // `.focus()` returns. Any later `focusout` is the consumer's own — an `onFocus`
-      // handler that blurs or moves focus — and must be reconciled rather than
-      // suppressed, so stop suppressing here instead of waiting for `.focus()` to return.
-      programmaticKeyboardFocusRef.current = false;
-      consumePreemptedFocus();
-      if (!captureFocusedKeyboardTarget(useScrollLock.getTarget(event))) {
-        // Focus landed outside any drawer keyboard input. The `focusout` on the previous
-        // field normally clears the tracked target, but the tap path suppresses that
-        // `focusout` via `programmaticKeyboardFocusRef`, so a consumer `onFocus` handler that
-        // redirects focus out of the drawer would otherwise leave a stale target holding its
-        // inset, slack, and pending realign. Reconcile against the real focus here.
-        // A handler that ends focus entirely emits no `focusin` to reconcile from; that case
-        // is covered by clearing the suppression flag above so its `focusout` is handled.
-        clearFocusedKeyboardTarget();
-        return;
-      }
-
-      // Covers every way focus can land with the keyboard already up: native moves (the
-      // keyboard's previous/next arrows) and the tap path (which suppresses `focusout`
-      // handling via the programmatic flag).
-      if (getKeyboardVisualViewport(win) != null) {
-        scheduleDelayedKeyboardRealign();
+      if (captureFocusedKeyboardTarget(useScrollLock.getTarget(event))) {
+        scheduleKeyboardFocusAlignment();
       }
-      scheduleKeyboardFocusAlignment();
     };
     const handleFocusOut = event => {
-      // The blur inside `focusKeyboardInputWithoutPageScroll` is followed synchronously by
-      // a re-focus; clearing state here would drop the keyboard inset for a frame.
-      if (programmaticKeyboardFocusRef.current) {
-        return;
-      }
       if (captureFocusedKeyboardTarget(event.relatedTarget)) {
-        const target = focusedKeyboardTargetRef.current;
-        const keyboardViewport = getKeyboardVisualViewport(win);
-        // The delayed realign passes are scheduled by the `focusin` that follows once
-        // focus lands on the captured target.
-        if (target && keyboardViewport) {
-          preemptFocusReveal(target, keyboardViewport);
-        }
         scheduleKeyboardFocusAlignment();
         return;
       }
@@ -1211,36 +1031,25 @@ function DrawerVirtualKeyboardProvider(props) {
     if (visualViewport) {
       cleanupListeners.push(useScrollLock.addEventListener(visualViewport, 'resize', handleViewportUpdate), useScrollLock.addEventListener(visualViewport, 'scroll', handleViewportUpdate));
     }
-    const handleWindowScroll = () => {
-      if (restoreWindowScroll()) {
-        // Recompute the keyboard inset once the page is back at rest; measurements taken
-        // mid-reveal (a non-zero visual viewport offset) inflate it and push the popup up.
-        scheduleKeyboardFocusAlignment();
-      }
-    };
-
-    // Once the user puts a finger down they own the scroll position. Stop both the frame settle
-    // loop, which can center after changing layout settles, and the delayed passes, which can't
-    // distinguish a user scroll from a reveal scroll WebKit canceled. A later focus or viewport
-    // change reschedules alignment if it's still needed.
-    const cancelKeyboardRealignOnPointerDown = () => {
-      keyboardFocusFrame.cancel();
-      keyboardRealignTimeout.clear();
-      keyboardScrollElement = null;
-    };
-    cleanupListeners.push(useScrollLock.addEventListener(doc, 'focusin', handleFocusIn, true), useScrollLock.addEventListener(doc, 'focusout', handleFocusOut, true), useScrollLock.addEventListener(win, 'scroll', handleWindowScroll), useScrollLock.addEventListener(doc, 'pointerdown', cancelKeyboardRealignOnPointerDown, true));
+    cleanupListeners.push(useScrollLock.addEventListener(doc, 'focusin', handleFocusIn, true), useScrollLock.addEventListener(doc, 'focusout', handleFocusOut, true));
     if (captureFocusedKeyboardTarget(useScrollLock.activeElement(doc))) {
       scheduleKeyboardFocusAlignment();
     }
     return () => {
       cleanupListeners.forEach(cleanup => cleanup());
-      consumePreemptedFocus();
       clearFocusedKeyboardTarget();
       rootElement.style.removeProperty(DrawerViewportCssVars.keyboardInset);
     };
-  }, [animateKeyboardScroll, keyboardFocusFrame, keyboardRealignTimeout, modal, mounted, nestedDrawerOpen, open, restoreKeyboardScrollAdjustment, rootElement, setKeyboardScrollSlack]);
+  }, [animateKeyboardScroll, keyboardFocusFrame, mounted, nestedDrawerOpen, open, restoreKeyboardScrollAdjustment, rootElement, setKeyboardScrollSlack]);
   const onTouchStart = useScrollLock.useStableCallback(event => {
+    if (!open || !mounted || nestedDrawerOpen) {
+      resetTouchTrackingState();
+      return;
+    }
     const touch = event.touches[0];
+    if (!touch) {
+      return;
+    }
     pendingKeyboardFocusMovedRef.current = false;
     keyboardTouchStartRef.current = {
       x: touch.clientX,
@@ -1266,9 +1075,9 @@ function DrawerVirtualKeyboardProvider(props) {
       return;
     }
     const touch = event.changedTouches[0] ?? event.touches[0];
-    const root = rootElement.getRootNode();
+    const doc = useScrollLock.ownerDocument(event.currentTarget);
     const nativeEventTarget = useScrollLock.getTarget(event.nativeEvent);
-    const pointTarget = touch ? resolveKeyboardTouchTargetFromPoint(root, touch.clientX, touch.clientY) : null;
+    const pointTarget = touch ? resolveKeyboardTouchTargetFromPoint(doc, touch.clientX, touch.clientY) : null;
 
     // The lift point landed on another interactive/label element; let its native tap
     // through instead of stealing it for the touchstart input.
@@ -1286,7 +1095,7 @@ function DrawerVirtualKeyboardProvider(props) {
         clickTarget: keyboardClickTarget,
         focusTarget: keyboardFocusTarget
       } = keyboardTarget;
-      const win = useScrollLock.getWindow(keyboardFocusTarget);
+      const win = floatingUi_utils.getWindow(keyboardFocusTarget);
 
       // While pinch-zoomed, keyboard alignment is suspended; let native behavior
       // handle focus and caret placement instead of blurring and re-focusing.
@@ -1297,24 +1106,15 @@ function DrawerVirtualKeyboardProvider(props) {
 
       // Already focused with the keyboard up: let the native tap through so it can
       // reposition the caret, rather than blurring and re-focusing the same input.
-      if (useScrollLock.activeElement(useScrollLock.ownerDocument(keyboardFocusTarget)) === keyboardFocusTarget && (!win.visualViewport || getKeyboardVisualViewport(win) != null)) {
+      if (useScrollLock.activeElement(useScrollLock.ownerDocument(keyboardFocusTarget)) === keyboardFocusTarget && isKeyboardVisualViewportOpen(win)) {
         resetTouchTrackingState();
         return;
       }
 
       // iOS only opens the software keyboard when focus happens synchronously
-      // inside the touch gesture. The flag suppresses the `focusout` cleanup the
-      // intermediate blur would otherwise trigger, so the keyboard inset isn't
-      // dropped for a frame between the blur and the re-focus. It is cleared by the
-      // `focusin` that lands, so only that blur is suppressed; the `finally` is the
-      // backstop for a target that never takes focus.
+      // inside the touch gesture.
       event.preventDefault();
-      programmaticKeyboardFocusRef.current = true;
-      try {
-        focusKeyboardInputWithoutPageScroll(keyboardFocusTarget);
-      } finally {
-        programmaticKeyboardFocusRef.current = false;
-      }
+      focusKeyboardInputWithoutPageScroll(keyboardFocusTarget);
       // Preventing the touchend default also suppresses the compatibility mouse
       // events, including `click`; redispatch an untrusted replacement on the
       // original tap target so click handlers still run with the tap coordinates.
@@ -1339,7 +1139,7 @@ function isKeyboardInputElement(element) {
   if (element.isContentEditable) {
     return true;
   }
-  const win = useScrollLock.getWindow(element);
+  const win = floatingUi_utils.getWindow(element);
   if (element instanceof win.HTMLTextAreaElement || element instanceof win.HTMLInputElement && KEYBOARD_INPUT_TYPES.has(element.type)) {
     // Disabled controls can't focus or open the keyboard, so tap-to-focus must skip them —
     // otherwise the dispatched click fires handlers a native tap on a disabled control never would.
@@ -1348,7 +1148,7 @@ function isKeyboardInputElement(element) {
   return false;
 }
 function resolveKeyboardInputTarget(target) {
-  if (!useScrollLock.isHTMLElement(target)) {
+  if (!floatingUi_utils.isHTMLElement(target)) {
     return null;
   }
   if (isKeyboardInputElement(target)) {
@@ -1356,19 +1156,16 @@ function resolveKeyboardInputTarget(target) {
   }
   const label = target.closest('label');
   const control = label?.control ?? null;
-  return useScrollLock.isHTMLElement(control) && isKeyboardInputElement(control) ? control : null;
+  return floatingUi_utils.isHTMLElement(control) && isKeyboardInputElement(control) ? control : null;
 }
 function resolveKeyboardTouchTarget(target) {
-  if (!useScrollLock.isHTMLElement(target)) {
-    return null;
-  }
   const focusTarget = resolveKeyboardInputTarget(target);
   if (!focusTarget) {
     return null;
   }
   return {
     focusTarget,
-    clickTarget: target
+    clickTarget: floatingUi_utils.isHTMLElement(target) ? target : focusTarget
   };
 }
 
@@ -1381,16 +1178,14 @@ function getContentEditableHost(element) {
   }
   return host;
 }
-function resolveKeyboardTouchTargetFromPoint(root, clientX, clientY) {
-  const exactTarget = ScrollAreaViewport.getElementAtPoint(root, clientX, clientY);
-  if (useScrollLock.isHTMLElement(exactTarget)) {
-    const exactKeyboardTarget = resolveKeyboardInputTarget(exactTarget);
-    if (exactKeyboardTarget) {
-      return {
-        focusTarget: exactKeyboardTarget,
-        clickTarget: exactTarget
-      };
-    }
+function resolveKeyboardTouchTargetFromPoint(doc, clientX, clientY) {
+  const exactTarget = ScrollAreaViewport.getElementAtPoint(doc, clientX, clientY);
+  const exactKeyboardTarget = resolveKeyboardInputTarget(exactTarget);
+  if (exactKeyboardTarget) {
+    return {
+      focusTarget: exactKeyboardTarget,
+      clickTarget: floatingUi_utils.isHTMLElement(exactTarget) ? exactTarget : exactKeyboardTarget
+    };
   }
 
   // Probing nearby points compensates for iOS retargeting taps while the page reacts
@@ -1403,7 +1198,7 @@ function resolveKeyboardTouchTargetFromPoint(root, clientX, clientY) {
     return KEYBOARD_TAP_BLOCKED;
   }
   for (const [offsetX, offsetY] of [[0, INPUT_TAP_HIT_SLOP], [0, -INPUT_TAP_HIT_SLOP], [INPUT_TAP_HIT_SLOP, 0], [-INPUT_TAP_HIT_SLOP, 0]]) {
-    const keyboardTarget = resolveKeyboardInputTarget(ScrollAreaViewport.getElementAtPoint(root, clientX + offsetX, clientY + offsetY));
+    const keyboardTarget = resolveKeyboardInputTarget(ScrollAreaViewport.getElementAtPoint(doc, clientX + offsetX, clientY + offsetY));
     if (keyboardTarget) {
       return {
         focusTarget: keyboardTarget,
@@ -1414,7 +1209,7 @@ function resolveKeyboardTouchTargetFromPoint(root, clientX, clientY) {
   return null;
 }
 function dispatchKeyboardClick(target, touch) {
-  const win = useScrollLock.getWindow(target);
+  const win = floatingUi_utils.getWindow(target);
   const ClickEvent = win.PointerEvent ?? win.MouseEvent;
   target.dispatchEvent(new ClickEvent('click', {
     bubbles: true,
@@ -1427,10 +1222,15 @@ function dispatchKeyboardClick(target, touch) {
 }
 function focusKeyboardInputWithoutPageScroll(target) {
   const wasFocused = useScrollLock.activeElement(useScrollLock.ownerDocument(target)) === target;
+  const previousOpacity = target.style.opacity;
+  const previousTransform = target.style.transform;
+  const previousTransition = target.style.transition;
+
   // iOS Safari can still scroll the page for transformed sheets even with preventScroll.
-  // Move the input off-screen only for the synchronous focus call; `preventScroll`
-  // suppresses the in-page ancestor scrolling that would otherwise chase the fake rect.
-  const restoreStyles = overrideGeometryDuringFocus(target, -2000);
+  // Move the input off-screen only for the synchronous focus call.
+  target.style.transition = 'none';
+  target.style.opacity = '0';
+  target.style.transform = 'translateY(-2000px)';
   try {
     if (wasFocused) {
       target.blur();
@@ -1439,25 +1239,10 @@ function focusKeyboardInputWithoutPageScroll(target) {
       preventScroll: true
     });
   } finally {
-    restoreStyles();
-  }
-}
-
-// Overrides the painted geometry WebKit samples when an element gains focus. The rect is
-// hidden (opacity) rather than detached so layout is unaffected; the caller must restore
-// synchronously before the next paint.
-function overrideGeometryDuringFocus(target, translateY) {
-  const previousOpacity = target.style.opacity;
-  const previousTransform = target.style.transform;
-  const previousTransition = target.style.transition;
-  target.style.transition = 'none';
-  target.style.opacity = '0';
-  target.style.transform = `translateY(${translateY}px)`;
-  return () => {
     target.style.opacity = previousOpacity;
     target.style.transform = previousTransform;
     target.style.transition = previousTransition;
-  };
+  }
 }
 function findKeyboardScrollTarget(target, root) {
   // Start at the parent: scrolling the focused field's own content (an overflowing
@@ -1466,8 +1251,8 @@ function findKeyboardScrollTarget(target, root) {
   // the drawer body scroller. Prefer an already-scrollable ancestor, then fall back to one
   // that only becomes scrollable once keyboard slack is added (overflow intent without
   // current overflow).
-  const scrollStart = useScrollLock.getParentNode(target);
-  return scrollable.findScrollableTouchTarget(scrollStart, root, 'vertical') ?? scrollable.findScrollableTouchTarget(scrollStart, root, 'vertical', true);
+  const scrollStart = floatingUi_utils.getParentNode(target);
+  return ScrollAreaViewport.findScrollableTouchTarget(scrollStart, root, 'vertical') ?? ScrollAreaViewport.findScrollableTouchTarget(scrollStart, root, 'vertical', true);
 }
 function getKeyboardVisualViewport(win) {
   const visualViewport = win.visualViewport;
@@ -1485,22 +1270,11 @@ function getKeyboardVisualViewport(win) {
     bottom: Math.min(win.innerHeight, top + visualViewport.height)
   };
 }
-
-/**
- * Controls a Drawer imperatively and associates detached `Drawer.Trigger` components with a
- * `Drawer.Root`. Create one with `Drawer.createHandle()` and pass it to the `handle` prop of the
- * root and of any triggers rendered outside of it.
- *
- * The imperative methods take effect only while a root using this handle is mounted; calls made
- * before a root attaches (or after it unmounts) are ignored.
- */
-class DrawerHandle extends DrawerDescription.DialogHandle {}
-
-/**
- * Creates a new handle to connect a Drawer.Root with detached Drawer.Trigger components.
- */
-function createDrawerHandle() {
-  return new DrawerHandle();
+function getDrawerKeyboardInset(win, keyboardViewport) {
+  return Math.max(0, win.innerHeight - keyboardViewport.bottom);
+}
+function isKeyboardVisualViewportOpen(win) {
+  return !win.visualViewport || getKeyboardVisualViewport(win) != null;
 }
 
 var index_parts$5 = /*#__PURE__*/Object.freeze({
@@ -1509,7 +1283,7 @@ var index_parts$5 = /*#__PURE__*/Object.freeze({
   Close: DrawerTitle.DrawerClose,
   Content: ScrollAreaViewport.DrawerContent,
   Description: DrawerDescription.DrawerDescription,
-  Handle: DrawerHandle,
+  Handle: DrawerDescription.DialogHandle,
   Indent: DrawerIndent,
   IndentBackground: DrawerIndentBackground,
   Popup: ScrollAreaViewport.DrawerPopup,
@@ -1521,7 +1295,7 @@ var index_parts$5 = /*#__PURE__*/Object.freeze({
   Trigger: ScrollAreaViewport.DrawerTrigger,
   Viewport: ScrollAreaViewport.DrawerViewport,
   VirtualKeyboardProvider: DrawerVirtualKeyboardProvider,
-  createHandle: createDrawerHandle
+  createHandle: DrawerDescription.createDialogHandle
 });
 
 /**
@@ -1590,7 +1364,7 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
     id: idProp,
     label,
     nativeButton = false,
-    disabled: disabledProp = false,
+    disabled = false,
     closeOnClick = false,
     checked: checkedProp,
     defaultChecked,
@@ -1599,7 +1373,6 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
     ...elementProps
   } = componentProps;
   const listItem = useCompositeListItem.useCompositeListItem({
-    guess: true,
     label
   });
   const menuPositionerContext = MenuSubmenuTrigger.useMenuPositionerContext(true);
@@ -1607,8 +1380,6 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
   const {
     store
   } = MenuSubmenuTrigger.useMenuRootContext();
-  const rootDisabled = store.useState('disabled');
-  const disabled = disabledProp || rootDisabled;
   const highlighted = store.useState('isActive', listItem.index);
   const itemProps = store.useState('itemProps');
   const [checked, setChecked] = useScrollLock.useControlled({
@@ -1637,7 +1408,7 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
   }), [disabled, highlighted, checked]);
   function handleClick(event) {
     const details = useScrollLock.createChangeEventDetails(useScrollLock.itemPress, event.nativeEvent, undefined, {
-      preventUnmountOnClose: useRenderElement.NOOP
+      preventUnmountOnClose() {}
     });
     onCheckedChange?.(!checked, details);
     if (details.isCanceled) {
@@ -1680,7 +1451,6 @@ const MenuCheckboxItemIndicator = /*#__PURE__*/React__namespace.forwardRef(funct
   const indicatorRef = React__namespace.useRef(null);
   const {
     transitionStatus,
-    mounted,
     setMounted
   } = useScrollLock.useTransitionStatus(item.checked);
   useScrollLock.useOpenChangeComplete({
@@ -1706,22 +1476,22 @@ const MenuCheckboxItemIndicator = /*#__PURE__*/React__namespace.forwardRef(funct
       'aria-hidden': true,
       ...elementProps
     },
-    enabled: keepMounted || mounted
+    enabled: keepMounted || item.checked
   });
   return element;
 });
 if (process.env.NODE_ENV !== "production") MenuCheckboxItemIndicator.displayName = "MenuCheckboxItemIndicator";
 
 function getCssDimensions(element) {
-  const css = useScrollLock.getComputedStyle(element);
+  const css = floatingUi_utils.getComputedStyle(element);
   // In testing environments, the `width` and `height` properties are empty
   // strings for SVG elements, returning NaN. Fallback to `0` in this case.
   let width = parseFloat(css.width) || 0;
   let height = parseFloat(css.height) || 0;
-  const hasOffset = useScrollLock.isHTMLElement(element);
+  const hasOffset = floatingUi_utils.isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = useScrollLock.round(width) !== offsetWidth || useScrollLock.round(height) !== offsetHeight;
+  const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -1746,14 +1516,30 @@ function usePopupAutoResize(parameters) {
     side,
     direction
   } = parameters;
-  const runOnceAnimationsFinish = useScrollLock.useAnimationsFinished(popupElement, true);
+  const runOnceAnimationsFinish = useScrollLock.useAnimationsFinished(popupElement, true, false);
   const animationFrame = useScrollLock.useAnimationFrame();
   const committedDimensionsRef = React__namespace.useRef(null);
   const isInitialRenderRef = React__namespace.useRef(true);
   const restoreAnchoringStylesRef = React__namespace.useRef(useRenderElement.NOOP);
   const onMeasureLayout = useScrollLock.useStableCallback(onMeasureLayoutParam);
   const onMeasureLayoutComplete = useScrollLock.useStableCallback(onMeasureLayoutCompleteParam);
-  const anchoringStyles = React__namespace.useMemo(() => getPopupAnchoringStyles(side, direction), [side, direction]);
+  const anchoringStyles = React__namespace.useMemo(() => {
+    // Ensure popup size transitions correctly when anchored to `bottom` (side=top) or `right` (side=left).
+    let isOriginSide = side === 'top';
+    let isPhysicalLeft = side === 'left';
+    if (direction === 'rtl') {
+      isOriginSide = isOriginSide || side === 'inline-end';
+      isPhysicalLeft = isPhysicalLeft || side === 'inline-end';
+    } else {
+      isOriginSide = isOriginSide || side === 'inline-start';
+      isPhysicalLeft = isPhysicalLeft || side === 'inline-start';
+    }
+    return isOriginSide ? {
+      position: 'absolute',
+      [side === 'top' ? 'bottom' : 'top']: '0',
+      [isPhysicalLeft ? 'right' : 'left']: '0'
+    } : useRenderElement.EMPTY_OBJECT;
+  }, [side, direction]);
   useScrollLock.useIsoLayoutEffect(() => {
     // Reset the state when the popup is closed.
     if (!mounted) {
@@ -1829,19 +1615,6 @@ function usePopupAutoResize(parameters) {
     };
   }, [content, popupElement, positionerElement, runOnceAnimationsFinish, animationFrame, mounted, onMeasureLayout, onMeasureLayoutComplete, anchoringStyles]);
 }
-function getPopupAnchoringStyles(side, direction) {
-  // Ensure popup size transitions correctly when anchored to `bottom` (side=top) or `right` (side=left).
-  const isPhysicalTop = side === 'top';
-  const isPhysicalLeft = side === 'left' || side === (direction === 'rtl' ? 'inline-end' : 'inline-start');
-  if (!isPhysicalTop && !isPhysicalLeft) {
-    return useRenderElement.EMPTY_OBJECT;
-  }
-  return {
-    position: 'absolute',
-    [isPhysicalTop ? 'bottom' : 'top']: '0',
-    [isPhysicalLeft ? 'right' : 'left']: '0'
-  };
-}
 function overrideElementStyle(element, property, value) {
   const originalValue = element.style.getPropertyValue(property);
   element.style.setProperty(property, value);
@@ -1871,80 +1644,6 @@ function setPositionerCssSize(positionerElement, size) {
   positionerElement.style.setProperty('--positioner-height', height);
 }
 
-const adaptiveOrigin = {
-  name: 'adaptiveOrigin',
-  async fn(state) {
-    const {
-      x: rawX,
-      y: rawY,
-      rects: {
-        floating: floatRect
-      },
-      elements: {
-        floating
-      },
-      platform,
-      strategy,
-      placement
-    } = state;
-    const win = useScrollLock.getWindow(floating);
-    const styles = win.getComputedStyle(floating);
-    const hasTransition = styles.transitionDuration !== '0s' && styles.transitionDuration !== '';
-    if (!hasTransition) {
-      return {
-        x: rawX,
-        y: rawY,
-        data: useCompositeListItem.DEFAULT_SIDES
-      };
-    }
-    const offsetParent = await platform.getOffsetParent?.(floating);
-    let offsetDimensions = {
-      width: 0,
-      height: 0
-    };
-
-    // For fixed strategy, prefer visualViewport if available
-    if (strategy === 'fixed' && win?.visualViewport) {
-      offsetDimensions = {
-        width: win.visualViewport.width,
-        height: win.visualViewport.height
-      };
-    } else if (offsetParent === win) {
-      const doc = useScrollLock.ownerDocument(floating);
-      offsetDimensions = {
-        width: doc.documentElement.clientWidth,
-        height: doc.documentElement.clientHeight
-      };
-    } else if (await platform.isElement?.(offsetParent)) {
-      offsetDimensions = await platform.getDimensions(offsetParent);
-    }
-    const currentSide = useScrollLock.getSide(placement);
-    let x = rawX;
-    let y = rawY;
-    if (currentSide === 'left') {
-      x = offsetDimensions.width - (rawX + floatRect.width);
-    }
-    if (currentSide === 'top') {
-      y = offsetDimensions.height - (rawY + floatRect.height);
-    }
-    const sideX = currentSide === 'left' ? 'right' : useCompositeListItem.DEFAULT_SIDES.sideX;
-    const sideY = currentSide === 'top' ? 'bottom' : useCompositeListItem.DEFAULT_SIDES.sideY;
-    return {
-      x,
-      y,
-      data: {
-        sideX,
-        sideY
-      }
-    };
-  }
-};
-
-const popupViewportStateMapping = {
-  activationDirection: value => value ? {
-    'data-activation-direction': value
-  } : null
-};
 /**
  * Builds morphing viewport containers for popups that animate between trigger-based content.
  * Handles previous-content snapshots, auto-resize, and state attributes for transitions.
@@ -1953,6 +1652,7 @@ function usePopupViewport(parameters) {
   const {
     store,
     side,
+    cssVars,
     children
   } = parameters;
   const direction = useScrollLock.useDirection();
@@ -1972,15 +1672,14 @@ function usePopupViewport(parameters) {
   const [newTriggerOffset, setNewTriggerOffset] = React__namespace.useState(null);
   const currentContainerRef = React__namespace.useRef(null);
   const previousContainerRef = React__namespace.useRef(null);
-  const onAnimationsFinished = useScrollLock.useAnimationsFinished(currentContainerRef, true);
+  const onAnimationsFinished = useScrollLock.useAnimationsFinished(currentContainerRef, true, false);
   const cleanupFrame = useScrollLock.useAnimationFrame();
-  const cleanupControllerRef = React__namespace.useRef(null);
   const [previousContentDimensions, setPreviousContentDimensions] = React__namespace.useState(null);
   const [showStartingStyleAttribute, setShowStartingStyleAttribute] = React__namespace.useState(false);
   useScrollLock.useIsoLayoutEffect(() => {
-    store.set('adaptiveOrigin', adaptiveOrigin);
+    store.set('hasViewport', true);
     return () => {
-      store.set('adaptiveOrigin', undefined);
+      store.set('hasViewport', false);
     };
   }, [store]);
   const handleMeasureLayout = useScrollLock.useStableCallback(() => {
@@ -1996,16 +1695,6 @@ function usePopupViewport(parameters) {
       setPreviousContentDimensions(previousDimensions);
     }
   });
-  const armViewportCleanup = useScrollLock.useStableCallback(() => {
-    cleanupControllerRef.current?.abort();
-    const controller = new AbortController();
-    cleanupControllerRef.current = controller;
-    onAnimationsFinished(() => {
-      setPreviousContentNode(null);
-      setPreviousContentDimensions(null);
-      capturedNodeRef.current = null;
-    }, controller.signal);
-  });
   const lastHandledTriggerRef = React__namespace.useRef(null);
   useScrollLock.useIsoLayoutEffect(() => {
     if (!open || !mounted) {
@@ -2023,33 +1712,19 @@ function usePopupViewport(parameters) {
       // so we can pass it to the style hook for animation purposes.
       const offset = calculateRelativePosition(previousActiveTrigger, activeTrigger);
       setNewTriggerOffset(offset);
+      cleanupFrame.request(() => {
+        ReactDOM__namespace.flushSync(() => {
+          setShowStartingStyleAttribute(false);
+        });
+        onAnimationsFinished(() => {
+          setPreviousContentNode(null);
+          setPreviousContentDimensions(null);
+          capturedNodeRef.current = null;
+        });
+      });
       lastHandledTriggerRef.current = activeTrigger;
     }
-  }, [activeTrigger, previousActiveTrigger]);
-
-  // Arm cleanup after a trigger change, and re-arm it if the current container remounts
-  // mid-transition when a lagging payload bumps `currentContentKey`. The remount discards
-  // the running entry animation (and with transition-style CSS the replacement mounts at
-  // final styles with no animation at all), so re-run the starting-style choreography —
-  // otherwise the watcher either strands or fires before the previous container's exit
-  // animation finishes.
-  useScrollLock.useIsoLayoutEffect(() => {
-    if (previousContentNode == null) {
-      return;
-    }
-
-    // Abort the stale watcher synchronously. The remount cancels the old container's
-    // animations, and the resulting promise rejection would otherwise run the cleanup
-    // in a microtask before the re-armed watcher below is in place.
-    cleanupControllerRef.current?.abort();
-    setShowStartingStyleAttribute(true);
-    cleanupFrame.request(() => {
-      ReactDOM__namespace.flushSync(() => {
-        setShowStartingStyleAttribute(false);
-      });
-      armViewportCleanup();
-    });
-  }, [currentContentKey, previousContentNode, armViewportCleanup, cleanupFrame]);
+  }, [activeTrigger, previousActiveTrigger, previousContentNode, onAnimationsFinished, cleanupFrame]);
 
   // Capture a clone of the current content DOM subtree when not transitioning.
   // We can't store previous React nodes as they may be stateful; instead we capture DOM clones for visual continuity.
@@ -2086,8 +1761,8 @@ function usePopupViewport(parameters) {
         ref: previousContainerRef,
         style: {
           ...(previousContentDimensions ? {
-            '--popup-width': `${previousContentDimensions.width}px`,
-            '--popup-height': `${previousContentDimensions.height}px`
+            [cssVars.popupWidth]: `${previousContentDimensions.width}px`,
+            [cssVars.popupHeight]: `${previousContentDimensions.height}px`
           } : null),
           position: 'absolute'
         },
@@ -2212,6 +1887,28 @@ function usePopupContentKey(activeTriggerId, payload) {
   return `${activeTriggerId ?? 'current'}-${contentKey}`;
 }
 
+let MenuViewportCssVars = /*#__PURE__*/function (MenuViewportCssVars) {
+  /**
+   * The width of the parent popup.
+   * This variable is placed on the 'previous' container and stores the width of the popup when the previous content was rendered.
+   * It can be used to freeze the dimensions of the popup when animating between different content.
+   */
+  MenuViewportCssVars["popupWidth"] = "--popup-width";
+  /**
+   * The height of the parent popup.
+   * This variable is placed on the 'previous' container and stores the height of the popup when the previous content was rendered.
+   * It can be used to freeze the dimensions of the popup when animating between different content.
+   */
+  MenuViewportCssVars["popupHeight"] = "--popup-height";
+  return MenuViewportCssVars;
+}({});
+
+const stateAttributesMapping$2 = {
+  activationDirection: value => value ? {
+    'data-activation-direction': value
+  } : null
+};
+
 /**
  * A viewport for displaying content transitions.
  * This component is only required if one popup can be opened by multiple triggers, its content
@@ -2241,6 +1938,7 @@ const MenuViewport = /*#__PURE__*/React__namespace.forwardRef(function MenuViewp
   } = usePopupViewport({
     store,
     side,
+    cssVars: MenuViewportCssVars,
     children
   });
   const state = {
@@ -2254,50 +1952,47 @@ const MenuViewport = /*#__PURE__*/React__namespace.forwardRef(function MenuViewp
     props: [elementProps, {
       children: childrenToRender
     }],
-    stateAttributesMapping: popupViewportStateMapping
+    stateAttributesMapping: stateAttributesMapping$2
   });
 });
 if (process.env.NODE_ENV !== "production") MenuViewport.displayName = "MenuViewport";
 
-/**
- * Controls a Menu imperatively and associates detached `Menu.Trigger` components with a `Menu.Root`.
- * Create one with `Menu.createHandle()` and pass it to the `handle` prop of the root and of any
- * triggers rendered outside of it.
- *
- * The imperative methods take effect only while a root using this handle is mounted; calls made
- * before a root attaches (or after it unmounts) are ignored.
- */
-class MenuHandle extends DrawerDescription.BasePopupHandle {
+class MenuHandle {
+  /**
+   * Internal store holding the menu's state.
+   * @internal
+   */
+
   constructor() {
-    super(MenuSubmenuTrigger.createNullMenuStore(), 'Menu');
+    this.store = new MenuSubmenuTrigger.MenuStore();
   }
 
   /**
    * Opens the menu and associates it with the trigger with the given id.
+   * The trigger must be a Menu.Trigger component with this handle passed as a prop.
    *
-   * This method should only be called in an event handler or an effect (not during rendering).
-   *
-   * @param triggerId ID of the trigger to associate with the menu. The trigger must be a matching
-   * `Menu.Trigger` with this handle passed as a prop.
+   * @param triggerId ID of the trigger to associate with the menu.
    */
   open(triggerId) {
-    this.openByTrigger(triggerId);
+    const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : undefined;
+    if (triggerId && !triggerElement) {
+      throw new Error(process.env.NODE_ENV !== "production" ? `Base UI: MenuHandle.open: No trigger found with id "${triggerId}".` : useRenderElement.formatErrorMessage(83, triggerId));
+    }
+    this.store.setOpen(true, useScrollLock.createChangeEventDetails('imperative-action', undefined, triggerElement));
   }
 
   /**
    * Closes the menu.
-   *
-   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close() {
-    this.closePopup();
+    this.store.setOpen(false, useScrollLock.createChangeEventDetails('imperative-action', undefined, undefined));
   }
 
   /**
-   * Whether the menu is currently open. Returns `false` while no root is attached to the handle.
+   * Indicates whether the menu is currently open.
    */
   get isOpen() {
-    return this.attachedStore?.select('open') ?? false;
+    return this.store.select('open');
   }
 }
 
@@ -2344,6 +2039,20 @@ function useScrollAreaScrollbarContext() {
   return context;
 }
 
+let ScrollAreaScrollbarCssVars = /*#__PURE__*/function (ScrollAreaScrollbarCssVars) {
+  /**
+   * The scroll area thumb's height.
+   * @type {number}
+   */
+  ScrollAreaScrollbarCssVars["scrollAreaThumbHeight"] = "--scroll-area-thumb-height";
+  /**
+   * The scroll area thumb's width.
+   * @type {number}
+   */
+  ScrollAreaScrollbarCssVars["scrollAreaThumbWidth"] = "--scroll-area-thumb-width";
+  return ScrollAreaScrollbarCssVars;
+}({});
+
 /**
  * A vertical or horizontal scrollbar for the scroll area.
  * Renders a `<div>` element.
@@ -2364,6 +2073,7 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     scrollingX,
     scrollingY,
     hiddenState,
+    overflowEdges,
     scrollbarYRef,
     scrollbarXRef,
     viewportRef,
@@ -2372,37 +2082,43 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     handlePointerDown,
     handlePointerUp,
     handleScroll,
-    disableViewportSnap,
     rootId,
     thumbSize,
-    hasMeasuredScrollbar,
-    viewportState
+    hasMeasuredScrollbar
   } = ScrollAreaViewport.useScrollAreaRootContext();
-  const vertical = orientation === 'vertical';
   const state = {
-    ...viewportState,
     hovering,
-    scrolling: vertical ? scrollingY : scrollingX,
-    orientation
+    scrolling: {
+      horizontal: scrollingX,
+      vertical: scrollingY
+    }[orientation],
+    orientation,
+    hasOverflowX: !hiddenState.x,
+    hasOverflowY: !hiddenState.y,
+    overflowXStart: overflowEdges.xStart,
+    overflowXEnd: overflowEdges.xEnd,
+    overflowYStart: overflowEdges.yStart,
+    overflowYEnd: overflowEdges.yEnd,
+    cornerHidden: hiddenState.corner
   };
   const direction = useScrollLock.useDirection();
   const hideTrackUntilMeasured = !hasMeasuredScrollbar && !keepMounted;
-  const isHidden = vertical ? hiddenState.y : hiddenState.x;
+  const isHidden = orientation === 'vertical' ? hiddenState.y : hiddenState.x;
   const shouldRender = keepMounted || !isHidden;
   React__namespace.useEffect(() => {
     if (!shouldRender) {
       return undefined;
     }
     const viewportEl = viewportRef.current;
-    const scrollbarEl = vertical ? scrollbarYRef.current : scrollbarXRef.current;
+    const scrollbarEl = orientation === 'vertical' ? scrollbarYRef.current : scrollbarXRef.current;
     if (!scrollbarEl) {
       return undefined;
     }
     function handleWheel(event) {
-      if (!viewportEl || event.ctrlKey) {
+      if (!viewportEl || !scrollbarEl || event.ctrlKey) {
         return;
       }
-      const horizontal = !vertical;
+      const horizontal = orientation === 'horizontal';
       const scrollProperty = horizontal ? 'scrollLeft' : 'scrollTop';
       const delta = horizontal ? event.deltaX : event.deltaY;
       if (delta === 0) {
@@ -2429,7 +2145,7 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     return useScrollLock.addEventListener(scrollbarEl, 'wheel', handleWheel, {
       passive: false
     });
-  }, [direction, handleScroll, vertical, scrollbarXRef, scrollbarYRef, shouldRender, viewportRef]);
+  }, [direction, handleScroll, orientation, scrollbarXRef, scrollbarYRef, shouldRender, viewportRef]);
   const props = {
     ...(rootId && {
       'data-id': `${rootId}-scrollbar`
@@ -2439,55 +2155,58 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
         return;
       }
       const target = useScrollLock.getTarget(event.nativeEvent);
-      const thumbEl = vertical ? thumbYRef.current : thumbXRef.current;
+      const thumb = orientation === 'vertical' ? thumbYRef.current : thumbXRef.current;
 
       // Ignore clicks on thumb, including cases where React retargets the
       // synthetic event to the track host across a shadow boundary.
-      if (thumbEl && useScrollLock.contains(thumbEl, target)) {
-        return;
-      }
-      const viewportEl = viewportRef.current;
-      if (!viewportEl) {
-        return;
-      }
-      const scrollbarEl = vertical ? scrollbarYRef.current : scrollbarXRef.current;
-      if (!thumbEl || !scrollbarEl) {
+      if (thumb && useScrollLock.contains(thumb, target)) {
         return;
       }
-      const axis = vertical ? 'y' : 'x';
-      const thumbOffset = ScrollAreaViewport.getOffset(thumbEl, 'margin', axis);
-      const scrollbarOffset = ScrollAreaViewport.getOffset(scrollbarEl, 'padding', axis);
-      const thumbSizePx = vertical ? thumbEl.offsetHeight : thumbEl.offsetWidth;
-      const trackRect = scrollbarEl.getBoundingClientRect();
-      const clickPosition = vertical ? event.clientY - trackRect.top - thumbSizePx / 2 - scrollbarOffset + thumbOffset / 2 : event.clientX - trackRect.left - thumbSizePx / 2 - scrollbarOffset + thumbOffset / 2;
-      const scrollableSize = vertical ? viewportEl.scrollHeight : viewportEl.scrollWidth;
-      const viewportSize = vertical ? viewportEl.clientHeight : viewportEl.clientWidth;
-      const trackSize = vertical ? scrollbarEl.offsetHeight : scrollbarEl.offsetWidth;
-      const maxThumbOffset = trackSize - thumbSizePx - scrollbarOffset - thumbOffset;
-      // A short or heavily padded track can drive `maxThumbOffset` to zero or
-      // negative once the thumb hits its `MIN_THUMB_SIZE` floor. Dividing by it
-      // would yield a non-finite (`Infinity`/`NaN`) or inverted scroll position.
-      if (maxThumbOffset <= 0) {
+      if (!viewportRef.current) {
         return;
       }
-      const scrollRatio = clickPosition / maxThumbOffset;
-      const maxScrollDistance = scrollableSize - viewportSize;
-
-      // Disable snapping before the jump-to-click assignment, or the
-      // assigned position quantizes to the nearest snap point and the thumb
-      // stays offset from the pointer for the whole drag. `handlePointerDown`
-      // below re-runs this as a guarded no-op for the thumb-drag path.
-      disableViewportSnap();
-      if (vertical) {
-        viewportEl.scrollTop = scrollRatio * maxScrollDistance;
-      } else if (direction === 'rtl') {
-        viewportEl.scrollLeft = -(1 - scrollRatio) * maxScrollDistance;
-      } else {
-        viewportEl.scrollLeft = scrollRatio * maxScrollDistance;
+
+      // Handle Y-axis (vertical) scroll
+      if (thumbYRef.current && scrollbarYRef.current && orientation === 'vertical') {
+        const thumbYOffset = ScrollAreaViewport.getOffset(thumbYRef.current, 'margin', 'y');
+        const scrollbarYOffset = ScrollAreaViewport.getOffset(scrollbarYRef.current, 'padding', 'y');
+        const thumbHeight = thumbYRef.current.offsetHeight;
+        const trackRectY = scrollbarYRef.current.getBoundingClientRect();
+        const clickY = event.clientY - trackRectY.top - thumbHeight / 2 - scrollbarYOffset + thumbYOffset / 2;
+        const scrollableContentHeight = viewportRef.current.scrollHeight;
+        const viewportHeight = viewportRef.current.clientHeight;
+        const maxThumbOffsetY = scrollbarYRef.current.offsetHeight - thumbHeight - scrollbarYOffset - thumbYOffset;
+        const scrollRatioY = clickY / maxThumbOffsetY;
+        const newScrollTop = scrollRatioY * (scrollableContentHeight - viewportHeight);
+        viewportRef.current.scrollTop = newScrollTop;
+      }
+      if (thumbXRef.current && scrollbarXRef.current && orientation === 'horizontal') {
+        const thumbXOffset = ScrollAreaViewport.getOffset(thumbXRef.current, 'margin', 'x');
+        const scrollbarXOffset = ScrollAreaViewport.getOffset(scrollbarXRef.current, 'padding', 'x');
+        const thumbWidth = thumbXRef.current.offsetWidth;
+        const trackRectX = scrollbarXRef.current.getBoundingClientRect();
+        const clickX = event.clientX - trackRectX.left - thumbWidth / 2 - scrollbarXOffset + thumbXOffset / 2;
+        const scrollableContentWidth = viewportRef.current.scrollWidth;
+        const viewportWidth = viewportRef.current.clientWidth;
+        const maxThumbOffsetX = scrollbarXRef.current.offsetWidth - thumbWidth - scrollbarXOffset - thumbXOffset;
+        const scrollRatioX = clickX / maxThumbOffsetX;
+        let newScrollLeft;
+        if (direction === 'rtl') {
+          // In RTL, invert the scroll direction
+          newScrollLeft = (1 - scrollRatioX) * (scrollableContentWidth - viewportWidth);
+
+          // Adjust for browsers that use negative scrollLeft in RTL
+          if (viewportRef.current.scrollLeft <= 0) {
+            newScrollLeft = -newScrollLeft;
+          }
+        } else {
+          newScrollLeft = scrollRatioX * (scrollableContentWidth - viewportWidth);
+        }
+        viewportRef.current.scrollLeft = newScrollLeft;
       }
       handleScroll({
-        x: viewportEl.scrollLeft,
-        y: viewportEl.scrollTop
+        x: viewportRef.current.scrollLeft,
+        y: viewportRef.current.scrollTop
       });
       handlePointerDown(event);
     },
@@ -2501,30 +2220,34 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
       WebkitUserSelect: 'none',
       userSelect: 'none',
       visibility: hideTrackUntilMeasured ? 'hidden' : undefined,
-      ...(vertical ? {
+      ...(orientation === 'vertical' && {
         top: 0,
-        bottom: 'var(--scroll-area-corner-height)',
+        bottom: `var(${ScrollAreaViewport.ScrollAreaRootCssVars.scrollAreaCornerHeight})`,
         insetInlineEnd: 0,
-        ['--scroll-area-thumb-height']: `${thumbSize.height}px`
-      } : {
+        [ScrollAreaScrollbarCssVars.scrollAreaThumbHeight]: `${thumbSize.height}px`
+      }),
+      ...(orientation === 'horizontal' && {
         insetInlineStart: 0,
-        insetInlineEnd: 'var(--scroll-area-corner-width)',
+        insetInlineEnd: `var(${ScrollAreaViewport.ScrollAreaRootCssVars.scrollAreaCornerWidth})`,
         bottom: 0,
-        ['--scroll-area-thumb-width']: `${thumbSize.width}px`
+        [ScrollAreaScrollbarCssVars.scrollAreaThumbWidth]: `${thumbSize.width}px`
       })
     }
   };
   const element = useRenderElement.useRenderElement('div', componentProps, {
-    ref: [forwardedRef, vertical ? scrollbarYRef : scrollbarXRef],
+    ref: [forwardedRef, orientation === 'vertical' ? scrollbarYRef : scrollbarXRef],
     state,
     props: [props, elementProps],
     stateAttributesMapping: ScrollAreaViewport.scrollAreaStateAttributesMapping
   });
+  const contextValue = React__namespace.useMemo(() => ({
+    orientation
+  }), [orientation]);
   if (!shouldRender) {
     return null;
   }
   return /*#__PURE__*/jsxRuntime.jsx(ScrollAreaScrollbarContext.Provider, {
-    value: orientation,
+    value: contextValue,
     children: element
   });
 });
@@ -2612,30 +2335,43 @@ const ScrollAreaThumb = /*#__PURE__*/React__namespace.forwardRef(function Scroll
     handlePointerDown,
     handlePointerMove,
     handlePointerUp,
+    setScrollingX,
+    setScrollingY,
     scrollingX,
     scrollingY,
     hasMeasuredScrollbar
   } = ScrollAreaViewport.useScrollAreaRootContext();
-  const orientation = useScrollAreaScrollbarContext();
-  const vertical = orientation === 'vertical';
+  const {
+    orientation
+  } = useScrollAreaScrollbarContext();
   const state = {
-    scrolling: vertical ? scrollingY : scrollingX,
+    scrolling: orientation === 'horizontal' ? scrollingX : scrollingY,
     orientation
   };
+  function endDrag(event) {
+    if (orientation === 'vertical') {
+      setScrollingY(false);
+    }
+    if (orientation === 'horizontal') {
+      setScrollingX(false);
+    }
+    handlePointerUp(event);
+  }
   const element = useRenderElement.useRenderElement('div', componentProps, {
-    ref: [forwardedRef, vertical ? thumbYRef : thumbXRef],
+    ref: [forwardedRef, orientation === 'vertical' ? thumbYRef : thumbXRef],
     state,
     props: [{
       onPointerDown: handlePointerDown,
       onPointerMove: handlePointerMove,
-      onPointerUp: handlePointerUp,
-      onPointerCancel: handlePointerUp,
+      onPointerUp: endDrag,
+      onPointerCancel: endDrag,
       style: {
         visibility: hasMeasuredScrollbar ? undefined : 'hidden',
-        ...(vertical ? {
-          height: 'var(--scroll-area-thumb-height)'
-        } : {
-          width: 'var(--scroll-area-thumb-width)'
+        ...(orientation === 'vertical' && {
+          height: `var(${ScrollAreaScrollbarCssVars.scrollAreaThumbHeight})`
+        }),
+        ...(orientation === 'horizontal' && {
+          width: `var(${ScrollAreaScrollbarCssVars.scrollAreaThumbWidth})`
         })
       }
     }, elementProps]
@@ -2693,34 +2429,34 @@ var index_parts$3 = /*#__PURE__*/Object.freeze({
 
 var index_parts$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Arrow: ComboboxSeparator.ComboboxArrow,
-  Backdrop: ComboboxSeparator.ComboboxBackdrop,
-  Chip: ComboboxSeparator.ComboboxChip,
-  ChipRemove: ComboboxSeparator.ComboboxChipRemove,
-  Chips: ComboboxSeparator.ComboboxChips,
-  Clear: ComboboxSeparator.ComboboxClear,
-  Collection: ComboboxSeparator.ComboboxCollection,
-  Empty: ComboboxSeparator.ComboboxEmpty,
-  Group: ComboboxSeparator.ComboboxGroup,
-  GroupLabel: ComboboxSeparator.ComboboxGroupLabel,
-  Icon: ComboboxSeparator.ComboboxIcon,
-  Input: ComboboxSeparator.ComboboxInput,
-  InputGroup: ComboboxSeparator.ComboboxInputGroup,
-  Item: ComboboxSeparator.ComboboxItem,
-  ItemIndicator: ComboboxSeparator.ComboboxItemIndicator,
-  Label: ComboboxSeparator.ComboboxLabel,
-  List: ComboboxSeparator.ComboboxList,
-  Popup: ComboboxSeparator.ComboboxPopup,
-  Portal: ComboboxSeparator.ComboboxPortal,
-  Positioner: ComboboxSeparator.ComboboxPositioner,
-  Root: ComboboxSeparator.ComboboxRoot,
-  Row: ComboboxSeparator.ComboboxRow,
-  Separator: ComboboxSeparator.ComboboxSeparator,
-  Status: ComboboxSeparator.ComboboxStatus,
-  Trigger: ComboboxSeparator.ComboboxTrigger,
-  Value: ComboboxSeparator.ComboboxValue,
-  useFilter: ComboboxSeparator.useComboboxFilter,
-  useFilteredItems: ComboboxSeparator.useFilteredItems
+  Arrow: ComboboxChipRemove.ComboboxArrow,
+  Backdrop: ComboboxChipRemove.ComboboxBackdrop,
+  Chip: ComboboxChipRemove.ComboboxChip,
+  ChipRemove: ComboboxChipRemove.ComboboxChipRemove,
+  Chips: ComboboxChipRemove.ComboboxChips,
+  Clear: ComboboxChipRemove.ComboboxClear,
+  Collection: ComboboxChipRemove.ComboboxCollection,
+  Empty: ComboboxChipRemove.ComboboxEmpty,
+  Group: ComboboxChipRemove.ComboboxGroup,
+  GroupLabel: ComboboxChipRemove.ComboboxGroupLabel,
+  Icon: ComboboxChipRemove.ComboboxIcon,
+  Input: ComboboxChipRemove.ComboboxInput,
+  InputGroup: ComboboxChipRemove.ComboboxInputGroup,
+  Item: ComboboxChipRemove.ComboboxItem,
+  ItemIndicator: ComboboxChipRemove.ComboboxItemIndicator,
+  Label: ComboboxChipRemove.ComboboxLabel,
+  List: ComboboxChipRemove.ComboboxList,
+  Popup: ComboboxChipRemove.ComboboxPopup,
+  Portal: ComboboxChipRemove.ComboboxPortal,
+  Positioner: ComboboxChipRemove.ComboboxPositioner,
+  Root: ComboboxChipRemove.ComboboxRoot,
+  Row: ComboboxChipRemove.ComboboxRow,
+  Separator: Separator.Separator,
+  Status: ComboboxChipRemove.ComboboxStatus,
+  Trigger: ComboboxChipRemove.ComboboxTrigger,
+  Value: ComboboxChipRemove.ComboboxValue,
+  useFilter: ComboboxChipRemove.useComboboxFilter,
+  useFilteredItems: ComboboxChipRemove.useFilteredItems
 });
 
 const NumberFieldScrubAreaContext = /*#__PURE__*/React__namespace.createContext(undefined);
@@ -2735,7 +2471,7 @@ function useNumberFieldScrubAreaContext() {
 
 // Calculates the bounds the virtual cursor wraps within, as absolute edge coordinates.
 function getViewportRect(teleportDistance, scrubAreaEl) {
-  const win = useScrollLock.getWindow(scrubAreaEl);
+  const win = floatingUi_utils.getWindow(scrubAreaEl);
   if (teleportDistance != null) {
     const rect = scrubAreaEl.getBoundingClientRect();
     return {
@@ -2762,6 +2498,22 @@ function getViewportRect(teleportDistance, scrubAreaEl) {
   };
 }
 
+// This lets us invert the scale of the cursor to match the OS scale, in which the cursor doesn't
+// scale with the content on pinch-zoom.
+function subscribeToVisualViewportResize(element, visualScaleRef) {
+  const vV = floatingUi_utils.getWindow(element).visualViewport;
+  if (!vV) {
+    return () => {};
+  }
+  function handleVisualResize() {
+    if (vV) {
+      visualScaleRef.current = vV.scale;
+    }
+  }
+  handleVisualResize();
+  return useScrollLock.addEventListener(vV, 'resize', handleVisualResize);
+}
+
 const SCRUB_AREA_STYLE = {
   touchAction: 'none',
   WebkitUserSelect: 'none',
@@ -2787,6 +2539,8 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
   const {
     state,
     setIsScrubbing: setRootScrubbing,
+    disabled,
+    readOnly,
     inputRef,
     incrementValue,
     allowInputSyncRef,
@@ -2795,10 +2549,6 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
     lastChangedValueRef,
     valueRef
   } = NumberFieldInput.useNumberFieldRootContext();
-  const {
-    disabled,
-    readOnly
-  } = state;
   const scrubAreaRef = React__namespace.useRef(null);
   const isScrubbingRef = React__namespace.useRef(false);
   const didMoveRef = React__namespace.useRef(false);
@@ -2808,15 +2558,21 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
     x: 0,
     y: 0
   });
+  const visualScaleRef = React__namespace.useRef(1);
   const exitPointerLockTimeout = useScrollLock.useTimeout();
   const [isTouchInput, setIsTouchInput] = React__namespace.useState(false);
   const [isPointerLockDenied, setIsPointerLockDenied] = React__namespace.useState(false);
   const [isScrubbing, setIsScrubbing] = React__namespace.useState(false);
-  function updateCursorTransform(virtualCursor, x, y) {
-    // Invert the visual viewport scale so the cursor matches the OS cursor, which doesn't
-    // scale with the content on pinch-zoom.
-    const scale = useScrollLock.getWindow(virtualCursor).visualViewport?.scale ?? 1;
-    virtualCursor.style.transform = `translate3d(${x}px,${y}px,0) scale(${1 / scale})`;
+  React__namespace.useEffect(() => {
+    if (!isScrubbing || !scrubAreaCursorRef.current) {
+      return undefined;
+    }
+    return subscribeToVisualViewportResize(scrubAreaCursorRef.current, visualScaleRef);
+  }, [isScrubbing]);
+  function updateCursorTransform(x, y) {
+    if (scrubAreaCursorRef.current) {
+      scrubAreaCursorRef.current.style.transform = `translate3d(${x}px,${y}px,0) scale(${1 / visualScaleRef.current})`;
+    }
   }
   const onScrub = useScrollLock.useStableCallback(({
     movementX,
@@ -2829,23 +2585,24 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
     }
     const rect = getViewportRect(teleportDistance, scrubAreaEl);
     const coords = virtualCursorCoords.current;
-
-    // Wrap the cursor to the opposite edge when its center crosses a viewport bound.
-    const wrap = (coord, halfSize, low, high) => {
-      if (coord + halfSize < low) {
-        return high - halfSize;
-      }
-      if (coord + halfSize > high) {
-        return low - halfSize;
-      }
-      return coord;
-    };
     const newCoords = {
-      x: wrap(Math.round(coords.x + movementX), virtualCursor.offsetWidth / 2, rect.left, rect.right),
-      y: wrap(Math.round(coords.y + movementY), virtualCursor.offsetHeight / 2, rect.top, rect.bottom)
+      x: Math.round(coords.x + movementX),
+      y: Math.round(coords.y + movementY)
     };
+    const cursorWidth = virtualCursor.offsetWidth;
+    const cursorHeight = virtualCursor.offsetHeight;
+    if (newCoords.x + cursorWidth / 2 < rect.left) {
+      newCoords.x = rect.right - cursorWidth / 2;
+    } else if (newCoords.x + cursorWidth / 2 > rect.right) {
+      newCoords.x = rect.left - cursorWidth / 2;
+    }
+    if (newCoords.y + cursorHeight / 2 < rect.top) {
+      newCoords.y = rect.bottom - cursorHeight / 2;
+    } else if (newCoords.y + cursorHeight / 2 > rect.bottom) {
+      newCoords.y = rect.top - cursorHeight / 2;
+    }
     virtualCursorCoords.current = newCoords;
-    updateCursorTransform(virtualCursor, newCoords.x, newCoords.y);
+    updateCursorTransform(newCoords.x, newCoords.y);
   });
   const onScrubbingChange = useScrollLock.useStableCallback((scrubbingValue, {
     clientX,
@@ -2864,7 +2621,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
       y: clientY - virtualCursor.offsetHeight / 2
     };
     virtualCursorCoords.current = initialCoords;
-    updateCursorTransform(virtualCursor, initialCoords.x, initialCoords.y);
+    updateCursorTransform(initialCoords.x, initialCoords.y);
   });
   React__namespace.useEffect(function registerGlobalScrubbingEventListeners() {
     // Only listen while actively scrubbing; avoids unrelated pointerup events committing.
@@ -2888,7 +2645,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
           const pointerDownTarget = pointerDownTargetRef.current;
           const input = inputRef.current;
           if (!didMoveRef.current && pointerDownTarget != null && input) {
-            pointerDownTarget.dispatchEvent(new (useScrollLock.getWindow(input).MouseEvent)('click', {
+            pointerDownTarget.dispatchEvent(new (floatingUi_utils.getWindow(input).MouseEvent)('click', {
               bubbles: true,
               cancelable: true
             }));
@@ -2906,9 +2663,6 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
       }
     }
     function handleScrubPointerMove(event) {
-      // The effects below can tear down and re-run without unmounting (`<Activity>`), which
-      // clears the ref while `isScrubbing` stays `true` and re-attaches this listener. The ref
-      // is the source of truth for whether a pointer is actually down.
       if (!isScrubbingRef.current) {
         return;
       }
@@ -2937,7 +2691,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
         }
       }
     }
-    const win = useScrollLock.getWindow(inputRef.current);
+    const win = floatingUi_utils.getWindow(inputRef.current);
     const unsubscribe = useScrollLock.mergeCleanups(useScrollLock.addEventListener(win, 'pointerup', handleScrubPointerUp, true), useScrollLock.addEventListener(win, 'pointermove', handleScrubPointerMove, true));
     return () => {
       exitPointerLockTimeout.clear();
@@ -2976,7 +2730,8 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
     role: 'presentation',
     style: SCRUB_AREA_STYLE,
     async onPointerDown(event) {
-      if (event.defaultPrevented || readOnly || event.button || disabled) {
+      const isMainButton = !event.button || event.button === 0;
+      if (event.defaultPrevented || readOnly || !isMainButton || disabled) {
         return;
       }
       const isTouch = event.pointerType === 'touch';
@@ -3116,8 +2871,7 @@ const SelectLabel = /*#__PURE__*/React__namespace.forwardRef(function SelectLabe
     id: defaultLabelId,
     fallbackControlId: triggerElement?.id ?? rootId,
     setLabelId(nextLabelId) {
-      const resolvedLabelId = typeof nextLabelId === 'function' ? nextLabelId(store.state.labelId) : nextLabelId;
-      store.set('labelId', resolvedLabelId);
+      store.set('labelId', nextLabelId);
     }
   });
   return useRenderElement.useRenderElement('div', componentProps, {
@@ -3162,7 +2916,7 @@ const SelectIcon = /*#__PURE__*/React__namespace.forwardRef(function SelectIcon(
 });
 if (process.env.NODE_ENV !== "production") SelectIcon.displayName = "SelectIcon";
 
-const stateAttributesMapping = {
+const stateAttributesMapping$1 = {
   ...useScrollLock.popupStateMapping,
   ...useScrollLock.transitionStatusMapping
 };
@@ -3201,12 +2955,17 @@ const SelectBackdrop = /*#__PURE__*/React__namespace.forwardRef(function SelectB
         WebkitUserSelect: 'none'
       }
     }, elementProps],
-    stateAttributesMapping
+    stateAttributesMapping: stateAttributesMapping$1
   });
   return element;
 });
 if (process.env.NODE_ENV !== "production") SelectBackdrop.displayName = "SelectBackdrop";
 
+const stateAttributesMapping = {
+  ...useScrollLock.popupStateMapping,
+  ...useScrollLock.transitionStatusMapping
+};
+
 /**
  * Displays an element positioned against the select popup anchor.
  * Renders a `<div>` element.
@@ -3245,7 +3004,7 @@ const SelectArrow = /*#__PURE__*/React__namespace.forwardRef(function SelectArro
       style: arrowStyles,
       'aria-hidden': true
     }, elementProps],
-    stateAttributesMapping: useScrollLock.popupTransitionStateMapping
+    stateAttributesMapping
   });
   if (alignItemWithTriggerActive) {
     return null;
@@ -3263,7 +3022,7 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
     className,
     style,
     direction,
-    keepMounted,
+    keepMounted = false,
     ...elementProps
   } = componentProps;
   const isUp = direction === 'up';
@@ -3294,10 +3053,12 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
   } = useScrollLock.useTransitionStatus(visible);
   useScrollLock.useIsoLayoutEffect(() => {
     scrollArrowsMountedCountRef.current += 1;
-    store.set('hasScrollArrows', true);
+    if (!store.state.hasScrollArrows) {
+      store.set('hasScrollArrows', true);
+    }
     return () => {
       scrollArrowsMountedCountRef.current = Math.max(0, scrollArrowsMountedCountRef.current - 1);
-      if (scrollArrowsMountedCountRef.current === 0) {
+      if (scrollArrowsMountedCountRef.current === 0 && store.state.hasScrollArrows) {
         store.set('hasScrollArrows', false);
       }
     };
@@ -3334,7 +3095,7 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
           return;
         }
         store.set('activeIndex', null);
-        handleScrollArrowVisibility(scroller);
+        handleScrollArrowVisibility();
         const maxScrollTop = scrollEdges.getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
         const scrollTop = scrollEdges.normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
         const isScrolledToEdge = scrollTop === (isUp ? 0 : maxScrollTop);
@@ -3342,6 +3103,11 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
         if (scrollTop !== scroller.scrollTop) {
           scroller.scrollTop = scrollTop;
         }
+
+        // Fallback when there are no items registered yet.
+        if (items.length === 0) {
+          store.set(isUp ? 'scrollUpArrowVisible' : 'scrollDownArrowVisible', !isScrolledToEdge);
+        }
         if (isScrolledToEdge) {
           timeout.clear();
           return;
@@ -3430,14 +3196,6 @@ const SelectScrollUpArrow = /*#__PURE__*/React__namespace.forwardRef(function Se
 });
 if (process.env.NODE_ENV !== "production") SelectScrollUpArrow.displayName = "SelectScrollUpArrow";
 
-/**
- * A visual separator between items or groups.
- * Renders a `<div>` element.
- *
- * Documentation: [Base UI Select](https://base-ui.com/react/components/select)
- */
-const SelectSeparator = ComboboxSeparator.ListboxSeparator;
-
 var index_parts = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Arrow: SelectArrow,
@@ -3456,7 +3214,7 @@ var index_parts = /*#__PURE__*/Object.freeze({
   Root: SelectGroupLabel.SelectRoot,
   ScrollDownArrow: SelectScrollDownArrow,
   ScrollUpArrow: SelectScrollUpArrow,
-  Separator: SelectSeparator,
+  Separator: Separator.Separator,
   Trigger: SelectGroupLabel.SelectTrigger,
   Value: SelectGroupLabel.SelectValue
 });