@jobber/components 9.5.3 → 9.6.0

package/dist/unstyledPrimitives/index.cjs

@@ -1,24 +1,23 @@
 'use strict';
 
 var React = require('react');
-var ComboboxChipRemove = require('../ComboboxChipRemove-cjs.js');
+var ComboboxSeparator = require('../ComboboxSeparator-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);
@@ -73,7 +72,9 @@ function AutocompleteRoot(props) {
   } else {
     resolvedInputValue = internalValue;
   }
-  const collator = ComboboxChipRemove.useCoreFilter();
+  const collator = ComboboxSeparator.useCoreFilter({
+    locale: other.locale
+  });
   const baseFilter = React__namespace.useMemo(() => {
     if (other.filter !== undefined) {
       return other.filter;
@@ -106,17 +107,9 @@ function AutocompleteRoot(props) {
     if (eventDetails.reason === useScrollLock.pointer) {
       return;
     }
-    if (enableInline) {
-      if (highlightedValue == null) {
-        setInlineInputValue('');
-      } else {
-        setInlineInputValue(useCompositeListItem.stringifyAsLabel(highlightedValue, itemToStringValue));
-      }
-    } else {
-      setInlineInputValue('');
-    }
+    setInlineInputValue(enableInline && highlightedValue != null ? useCompositeListItem.stringifyAsLabel(highlightedValue, itemToStringValue) : '');
   }
-  return /*#__PURE__*/jsxRuntime.jsx(ComboboxChipRemove.AriaCombobox, {
+  return /*#__PURE__*/jsxRuntime.jsx(ComboboxSeparator.AriaCombobox, {
     ...other,
     itemToStringLabel: itemToStringValue,
     openOnInputClick: openOnInputClick,
@@ -135,7 +128,7 @@ function AutocompleteValue(props) {
   const {
     children
   } = props;
-  const inputValue = ComboboxChipRemove.useComboboxInputValueContext();
+  const inputValue = ComboboxSeparator.useComboboxInputValueContext();
   let returnValue = null;
   if (typeof children === 'function') {
     returnValue = children(String(inputValue));
@@ -155,7 +148,7 @@ function AutocompleteValue(props) {
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteTrigger = ComboboxChipRemove.ComboboxTrigger;
+const AutocompleteTrigger = ComboboxSeparator.ComboboxTrigger;
 
 /**
  * A wrapper for the input and its associated controls.
@@ -163,7 +156,7 @@ const AutocompleteTrigger = ComboboxChipRemove.ComboboxTrigger;
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteInputGroup = ComboboxChipRemove.ComboboxInputGroup;
+const AutocompleteInputGroup = ComboboxSeparator.ComboboxInputGroup;
 
 /**
  * An individual item in the list.
@@ -171,33 +164,41 @@ const AutocompleteInputGroup = ComboboxChipRemove.ComboboxInputGroup;
  *
  * Documentation: [Base UI Autocomplete](https://base-ui.com/react/components/autocomplete)
  */
-const AutocompleteItem = ComboboxChipRemove.ComboboxItem;
+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;
 
 var index_parts$7 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  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,
+  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,
   InputGroup: AutocompleteInputGroup,
   Item: AutocompleteItem,
-  List: ComboboxChipRemove.ComboboxList,
-  Popup: ComboboxChipRemove.ComboboxPopup,
-  Portal: ComboboxChipRemove.ComboboxPortal,
-  Positioner: ComboboxChipRemove.ComboboxPositioner,
+  List: ComboboxSeparator.ComboboxList,
+  Popup: ComboboxSeparator.ComboboxPopup,
+  Portal: ComboboxSeparator.ComboboxPortal,
+  Positioner: ComboboxSeparator.ComboboxPositioner,
   Root: AutocompleteRoot,
-  Row: ComboboxChipRemove.ComboboxRow,
-  Separator: Separator.Separator,
-  Status: ComboboxChipRemove.ComboboxStatus,
+  Row: ComboboxSeparator.ComboboxRow,
+  Separator: AutocompleteSeparator,
+  Status: ComboboxSeparator.ComboboxStatus,
   Trigger: AutocompleteTrigger,
   Value: AutocompleteValue,
-  useFilter: ComboboxChipRemove.useCoreFilter,
-  useFilteredItems: ComboboxChipRemove.useFilteredItems
+  useFilter: ComboboxSeparator.useCoreFilter,
+  useFilteredItems: ComboboxSeparator.useFilteredItems
 });
 
 var index_parts$6 = /*#__PURE__*/Object.freeze({
@@ -208,14 +209,14 @@ var index_parts$6 = /*#__PURE__*/Object.freeze({
   Handle: DrawerDescription.DialogHandle,
   Popup: DrawerDescription.DialogPopup,
   Portal: ScrollAreaViewport.DialogPortal,
-  Root: ScrollAreaViewport.DialogRoot,
+  Root: DrawerDescription.DialogRoot,
   Title: DrawerTitle.DialogTitle,
   Trigger: ScrollAreaViewport.DialogTrigger,
   Viewport: ScrollAreaViewport.DialogViewport,
   createHandle: DrawerDescription.createDialogHandle
 });
 
-const stateAttributesMapping$5 = {
+const stateAttributesMapping$3 = {
   active(value) {
     if (value) {
       return {
@@ -286,12 +287,12 @@ const DrawerIndent = /*#__PURE__*/React__namespace.forwardRef(function DrawerInd
         [ScrollAreaViewport.DrawerBackdropCssVars.swipeProgress]: '0'
       }
     }, elementProps],
-    stateAttributesMapping: stateAttributesMapping$5
+    stateAttributesMapping: stateAttributesMapping$3
   });
 });
 if (process.env.NODE_ENV !== "production") DrawerIndent.displayName = "DrawerIndent";
 
-const stateAttributesMapping$4 = {
+const stateAttributesMapping$2 = {
   active(value) {
     if (value) {
       return {
@@ -326,7 +327,7 @@ const DrawerIndentBackground = /*#__PURE__*/React__namespace.forwardRef(function
     ref: forwardedRef,
     state,
     props: elementProps,
-    stateAttributesMapping: stateAttributesMapping$4
+    stateAttributesMapping: stateAttributesMapping$2
   });
 });
 if (process.env.NODE_ENV !== "production") DrawerIndentBackground.displayName = "DrawerIndentBackground";
@@ -335,37 +336,26 @@ function DrawerProvider(props) {
   const {
     children
   } = props;
-  const [openById, setOpenById] = React__namespace.useState(() => new Map());
+  const [openDrawers, setOpenDrawers] = React__namespace.useState(() => new Set());
   const [visualStateStore] = React__namespace.useState(createVisualStateStore);
-  const setDrawerOpen = useScrollLock.useStableCallback((drawerId, open) => {
-    setOpenById(prev => {
-      const prevOpen = prev.get(drawerId);
-      if (prevOpen === open) {
+  const setDrawerOpen = useScrollLock.useStableCallback((drawer, open) => {
+    setOpenDrawers(prev => {
+      if (prev.has(drawer) === open) {
         return prev;
       }
-      const next = new Map(prev);
-      next.set(drawerId, open);
-      return next;
-    });
-  });
-  const removeDrawer = useScrollLock.useStableCallback(drawerId => {
-    setOpenById(prev => {
-      if (!prev.has(drawerId)) {
-        return prev;
+      const next = new Set(prev);
+      if (open) {
+        next.add(drawer);
+      } else {
+        next.delete(drawer);
       }
-      const next = new Map(prev);
-      next.delete(drawerId);
       return next;
     });
   });
-  const active = React__namespace.useMemo(() => {
-    for (const open of openById.values()) {
-      if (open) {
-        return true;
-      }
-    }
-    return false;
-  }, [openById]);
+  const removeDrawer = useScrollLock.useStableCallback(drawer => {
+    setDrawerOpen(drawer, false);
+  });
+  const active = openDrawers.size > 0;
   const contextValue = React__namespace.useMemo(() => ({
     setDrawerOpen,
     removeDrawer,
@@ -455,7 +445,7 @@ const SWIPE_AREA_SWIPING_HOOK = {
 const SWIPE_AREA_DISABLED_HOOK = {
   [DrawerSwipeAreaDataAttributes.disabled]: ''
 };
-const stateAttributesMapping$3 = {
+const stateAttributesMapping$1 = {
   open(value) {
     return value ? SWIPE_AREA_OPEN_HOOK : SWIPE_AREA_CLOSED_HOOK;
   },
@@ -463,9 +453,9 @@ const stateAttributesMapping$3 = {
     return value ? SWIPE_AREA_SWIPING_HOOK : null;
   },
   swipeDirection(value) {
-    return value ? {
+    return {
       [DrawerSwipeAreaDataAttributes.swipeDirection]: value
-    } : null;
+    };
   },
   disabled(value) {
     return value ? SWIPE_AREA_DISABLED_HOOK : null;
@@ -496,16 +486,14 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     swipeDirection: swipeDirectionProp,
     ...elementProps
   } = componentProps;
-  const {
-    store
-  } = ScrollAreaViewport.useDialogRootContext();
+  const store = ScrollAreaViewport.useDialogRootContext();
   const {
     swipeDirection,
-    frontmostHeight
+    frontmostHeight,
+    swipeAreaActiveRef
   } = 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);
@@ -515,7 +503,10 @@ 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');
@@ -527,21 +518,40 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   const dismissDirection = oppositeSwipeDirection[resolvedSwipeDirection];
   const enabled = !disabled && (!open || swipeActive);
   function disableDismissForSwipe() {
-    releaseDismissTimeout.clear();
+    releaseGuardCleanupRef.current();
     store.context.outsidePressEnabledRef.current = false;
   }
-  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, () => {
+  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);
       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) {
@@ -549,15 +559,15 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
     }
     return size;
   }
-  function resolveClosedOffset() {
-    const offset = resolvePopupSize();
+  function resolvePopupSize() {
+    const popupElement = store.context.popupRef.current;
+    return popupElement ? getPopupSize(popupElement) : null;
+  }
+  function resolveClosedOffset(popupElement) {
+    const offset = getPopupSize(popupElement);
     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;
@@ -574,9 +584,6 @@ 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;
@@ -585,10 +592,10 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       return;
     }
     if (closedOffsetRef.current == null) {
-      closedOffsetRef.current = resolveClosedOffset();
+      closedOffsetRef.current = resolveClosedOffset(popupElement);
     }
     const closedOffset = closedOffsetRef.current;
-    if (!closedOffset || !Number.isFinite(closedOffset) || closedOffset <= 0) {
+    if (closedOffset === null) {
       return;
     }
     const {
@@ -609,6 +616,7 @@ 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;
     }
@@ -616,6 +624,7 @@ 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`);
@@ -628,10 +637,11 @@ 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 = store.context.popupRef.current;
-    if (popupElement && appliedSwipeStylesRef.current) {
+    const popupElement = swipePopupElementRef.current;
+    if (popupElement) {
       popupElement.style.removeProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementX);
       popupElement.style.removeProperty(ScrollAreaViewport.DrawerPopupCssVars.swipeMovementY);
       popupElement.removeAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping);
@@ -640,7 +650,7 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
       popupElement.style.transition = popupTransitionRef.current;
       popupTransitionRef.current = null;
     }
-    const backdropElement = store.context.backdropRef.current;
+    const backdropElement = swipeBackdropElementRef.current;
     if (backdropElement) {
       backdropElement.removeAttribute(ScrollAreaViewport.DrawerPopupDataAttributes.swiping);
       backdropElement.style.setProperty(ScrollAreaViewport.DrawerBackdropCssVars.swipeProgress, '0');
@@ -651,19 +661,16 @@ 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 ?? undefined));
+    store.setOpen(true, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current));
   }
   function closeDrawer(event) {
-    if (!store.select('open')) {
-      return;
-    }
-    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current ?? undefined));
+    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event, swipeAreaRef.current));
   }
   function resetSwipeInteractionState() {
     swipeStartEventRef.current = null;
@@ -706,10 +713,10 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
         return;
       }
       const displacement = ScrollAreaViewport.getDisplacement(resolvedSwipeDirection, details.deltaX, details.deltaY);
-      if (displacement < MIN_SWIPE_START_DISTANCE && !openedBySwipeRef.current) {
+      if (!openedBySwipeRef.current && displacement < MIN_SWIPE_START_DISTANCE) {
         return;
       }
-      if (!openedBySwipeRef.current) {
+      if (!openedBySwipeRef.current && !store.select('open')) {
         openDrawer(swipeStartEventRef.current);
       }
       applySwipeMovement();
@@ -725,14 +732,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 = threshold != null && displacement >= threshold;
+      const hasEnoughDistance = displacement >= threshold;
       const hasEnoughVelocity = releaseVelocity >= VELOCITY_THRESHOLD;
-      const shouldOpen = threshold != null && direction === resolvedSwipeDirection && (hasEnoughDistance || hasEnoughVelocity) && !disabled;
+      const shouldOpen = direction === resolvedSwipeDirection && (hasEnoughDistance || hasEnoughVelocity) && !disabled;
       if (shouldOpen) {
         if (!store.select('open')) {
           openDrawer(event);
         }
-      } else if (openedBySwipeRef.current) {
+      } else if (openedBySwipeRef.current && store.select('open')) {
         closeDrawer(event);
       }
       finishSwipeInteraction();
@@ -743,16 +750,29 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   const swipePointerProps = swipe.getPointerProps();
   const swipeTouchProps = swipe.getTouchProps();
   const resetSwipe = swipe.reset;
-  React__namespace.useEffect(() => {
+
+  // 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(() => {
     if (!enabled) {
+      if (swipeActive) {
+        enableDismissAfterRelease();
+      }
       resetSwipe();
       resetDragDelta();
       clearSwipeStyles();
       resetSwipeInteractionState();
     }
-  }, [clearSwipeStyles, enabled, resetDragDelta, resetSwipe]);
+  }, [clearSwipeStyles, enableDismissAfterRelease, enabled, resetDragDelta, resetSwipe, swipeActive]);
   React__namespace.useEffect(() => {
     return () => {
+      releaseGuardCleanupRef.current();
       store.context.outsidePressEnabledRef.current = true;
     };
   }, [store]);
@@ -765,7 +785,7 @@ const DrawerSwipeArea = /*#__PURE__*/React__namespace.forwardRef(function Drawer
   return useRenderElement.useRenderElement('div', componentProps, {
     state,
     ref: [forwardedRef, swipeAreaRef, registerTrigger],
-    stateAttributesMapping: stateAttributesMapping$3,
+    stateAttributesMapping: stateAttributesMapping$1,
     props: [{
       role: 'presentation',
       'aria-hidden': true,
@@ -825,6 +845,15 @@ 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']);
@@ -848,11 +877,10 @@ 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');
 
@@ -865,7 +893,9 @@ 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) {
@@ -892,7 +922,7 @@ function DrawerVirtualKeyboardProvider(props) {
       adjustment = null;
     }
     if (!adjustment) {
-      const styles = floatingUi_utils.getComputedStyle(element);
+      const styles = useScrollLock.getComputedStyle(element);
       adjustment = {
         element,
         overflowAnchor: element.style.overflowAnchor,
@@ -908,7 +938,7 @@ function DrawerVirtualKeyboardProvider(props) {
     element.style.scrollPaddingBottom = `${adjustment.computedScrollPaddingBottom + KEYBOARD_VISIBILITY_MARGIN}px`;
   });
   const animateKeyboardScroll = useScrollLock.useStableCallback((element, scrollTop) => {
-    const win = floatingUi_utils.getWindow(element);
+    const win = useScrollLock.getWindow(element);
     const behavior = win.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches ? 'auto' : 'smooth';
     element.scrollTo({
       top: scrollTop,
@@ -931,48 +961,102 @@ function DrawerVirtualKeyboardProvider(props) {
       return undefined;
     }
     const doc = useScrollLock.ownerDocument(rootElement);
-    const win = floatingUi_utils.getWindow(rootElement);
+    const win = useScrollLock.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;
-      resetDrawerKeyboardInset();
+      keyboardScrollElement = null;
+      setDrawerKeyboardInset(0);
       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)) {
-        resetDrawerKeyboardInset();
+        setDrawerKeyboardInset(0);
         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) {
-        resetDrawerKeyboardInset();
+        setDrawerKeyboardInset(0);
         restoreKeyboardScrollAdjustment();
         return;
       }
-      setDrawerKeyboardInset(getDrawerKeyboardInset(win, keyboardViewport));
+      setDrawerKeyboardInset(Math.max(0, win.innerHeight - keyboardViewport.bottom));
       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);
@@ -988,14 +1072,70 @@ function DrawerVirtualKeyboardProvider(props) {
         return;
       }
       const targetRect = target.getBoundingClientRect();
-      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 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 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;
@@ -1007,16 +1147,56 @@ 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 => {
-      if (captureFocusedKeyboardTarget(useScrollLock.getTarget(event))) {
-        scheduleKeyboardFocusAlignment();
+      // 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();
       }
+      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;
       }
@@ -1031,25 +1211,36 @@ function DrawerVirtualKeyboardProvider(props) {
     if (visualViewport) {
       cleanupListeners.push(useScrollLock.addEventListener(visualViewport, 'resize', handleViewportUpdate), useScrollLock.addEventListener(visualViewport, 'scroll', handleViewportUpdate));
     }
-    cleanupListeners.push(useScrollLock.addEventListener(doc, 'focusin', handleFocusIn, true), useScrollLock.addEventListener(doc, 'focusout', handleFocusOut, true));
+    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));
     if (captureFocusedKeyboardTarget(useScrollLock.activeElement(doc))) {
       scheduleKeyboardFocusAlignment();
     }
     return () => {
       cleanupListeners.forEach(cleanup => cleanup());
+      consumePreemptedFocus();
       clearFocusedKeyboardTarget();
       rootElement.style.removeProperty(DrawerViewportCssVars.keyboardInset);
     };
-  }, [animateKeyboardScroll, keyboardFocusFrame, mounted, nestedDrawerOpen, open, restoreKeyboardScrollAdjustment, rootElement, setKeyboardScrollSlack]);
+  }, [animateKeyboardScroll, keyboardFocusFrame, keyboardRealignTimeout, modal, 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,
@@ -1075,9 +1266,9 @@ function DrawerVirtualKeyboardProvider(props) {
       return;
     }
     const touch = event.changedTouches[0] ?? event.touches[0];
-    const doc = useScrollLock.ownerDocument(event.currentTarget);
+    const root = rootElement.getRootNode();
     const nativeEventTarget = useScrollLock.getTarget(event.nativeEvent);
-    const pointTarget = touch ? resolveKeyboardTouchTargetFromPoint(doc, touch.clientX, touch.clientY) : null;
+    const pointTarget = touch ? resolveKeyboardTouchTargetFromPoint(root, 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.
@@ -1095,7 +1286,7 @@ function DrawerVirtualKeyboardProvider(props) {
         clickTarget: keyboardClickTarget,
         focusTarget: keyboardFocusTarget
       } = keyboardTarget;
-      const win = floatingUi_utils.getWindow(keyboardFocusTarget);
+      const win = useScrollLock.getWindow(keyboardFocusTarget);
 
       // While pinch-zoomed, keyboard alignment is suspended; let native behavior
       // handle focus and caret placement instead of blurring and re-focusing.
@@ -1106,15 +1297,24 @@ 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 && isKeyboardVisualViewportOpen(win)) {
+      if (useScrollLock.activeElement(useScrollLock.ownerDocument(keyboardFocusTarget)) === keyboardFocusTarget && (!win.visualViewport || getKeyboardVisualViewport(win) != null)) {
         resetTouchTrackingState();
         return;
       }
 
       // iOS only opens the software keyboard when focus happens synchronously
-      // inside the touch gesture.
+      // 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.
       event.preventDefault();
-      focusKeyboardInputWithoutPageScroll(keyboardFocusTarget);
+      programmaticKeyboardFocusRef.current = true;
+      try {
+        focusKeyboardInputWithoutPageScroll(keyboardFocusTarget);
+      } finally {
+        programmaticKeyboardFocusRef.current = false;
+      }
       // 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.
@@ -1139,7 +1339,7 @@ function isKeyboardInputElement(element) {
   if (element.isContentEditable) {
     return true;
   }
-  const win = floatingUi_utils.getWindow(element);
+  const win = useScrollLock.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.
@@ -1148,7 +1348,7 @@ function isKeyboardInputElement(element) {
   return false;
 }
 function resolveKeyboardInputTarget(target) {
-  if (!floatingUi_utils.isHTMLElement(target)) {
+  if (!useScrollLock.isHTMLElement(target)) {
     return null;
   }
   if (isKeyboardInputElement(target)) {
@@ -1156,16 +1356,19 @@ function resolveKeyboardInputTarget(target) {
   }
   const label = target.closest('label');
   const control = label?.control ?? null;
-  return floatingUi_utils.isHTMLElement(control) && isKeyboardInputElement(control) ? control : null;
+  return useScrollLock.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: floatingUi_utils.isHTMLElement(target) ? target : focusTarget
+    clickTarget: target
   };
 }
 
@@ -1178,14 +1381,16 @@ function getContentEditableHost(element) {
   }
   return host;
 }
-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
-    };
+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
+      };
+    }
   }
 
   // Probing nearby points compensates for iOS retargeting taps while the page reacts
@@ -1198,7 +1403,7 @@ function resolveKeyboardTouchTargetFromPoint(doc, 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(doc, clientX + offsetX, clientY + offsetY));
+    const keyboardTarget = resolveKeyboardInputTarget(ScrollAreaViewport.getElementAtPoint(root, clientX + offsetX, clientY + offsetY));
     if (keyboardTarget) {
       return {
         focusTarget: keyboardTarget,
@@ -1209,7 +1414,7 @@ function resolveKeyboardTouchTargetFromPoint(doc, clientX, clientY) {
   return null;
 }
 function dispatchKeyboardClick(target, touch) {
-  const win = floatingUi_utils.getWindow(target);
+  const win = useScrollLock.getWindow(target);
   const ClickEvent = win.PointerEvent ?? win.MouseEvent;
   target.dispatchEvent(new ClickEvent('click', {
     bubbles: true,
@@ -1222,15 +1427,10 @@ 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.
-  target.style.transition = 'none';
-  target.style.opacity = '0';
-  target.style.transform = 'translateY(-2000px)';
+  // 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);
   try {
     if (wasFocused) {
       target.blur();
@@ -1239,10 +1439,25 @@ 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
@@ -1251,8 +1466,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 = floatingUi_utils.getParentNode(target);
-  return ScrollAreaViewport.findScrollableTouchTarget(scrollStart, root, 'vertical') ?? ScrollAreaViewport.findScrollableTouchTarget(scrollStart, root, 'vertical', true);
+  const scrollStart = useScrollLock.getParentNode(target);
+  return scrollable.findScrollableTouchTarget(scrollStart, root, 'vertical') ?? scrollable.findScrollableTouchTarget(scrollStart, root, 'vertical', true);
 }
 function getKeyboardVisualViewport(win) {
   const visualViewport = win.visualViewport;
@@ -1270,11 +1485,22 @@ function getKeyboardVisualViewport(win) {
     bottom: Math.min(win.innerHeight, top + visualViewport.height)
   };
 }
-function getDrawerKeyboardInset(win, keyboardViewport) {
-  return Math.max(0, win.innerHeight - keyboardViewport.bottom);
-}
-function isKeyboardVisualViewportOpen(win) {
-  return !win.visualViewport || getKeyboardVisualViewport(win) != null;
+
+/**
+ * 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();
 }
 
 var index_parts$5 = /*#__PURE__*/Object.freeze({
@@ -1283,7 +1509,7 @@ var index_parts$5 = /*#__PURE__*/Object.freeze({
   Close: DrawerTitle.DrawerClose,
   Content: ScrollAreaViewport.DrawerContent,
   Description: DrawerDescription.DrawerDescription,
-  Handle: DrawerDescription.DialogHandle,
+  Handle: DrawerHandle,
   Indent: DrawerIndent,
   IndentBackground: DrawerIndentBackground,
   Popup: ScrollAreaViewport.DrawerPopup,
@@ -1295,7 +1521,7 @@ var index_parts$5 = /*#__PURE__*/Object.freeze({
   Trigger: ScrollAreaViewport.DrawerTrigger,
   Viewport: ScrollAreaViewport.DrawerViewport,
   VirtualKeyboardProvider: DrawerVirtualKeyboardProvider,
-  createHandle: DrawerDescription.createDialogHandle
+  createHandle: createDrawerHandle
 });
 
 /**
@@ -1364,7 +1590,7 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
     id: idProp,
     label,
     nativeButton = false,
-    disabled = false,
+    disabled: disabledProp = false,
     closeOnClick = false,
     checked: checkedProp,
     defaultChecked,
@@ -1373,6 +1599,7 @@ const MenuCheckboxItem = /*#__PURE__*/React__namespace.forwardRef(function MenuC
     ...elementProps
   } = componentProps;
   const listItem = useCompositeListItem.useCompositeListItem({
+    guess: true,
     label
   });
   const menuPositionerContext = MenuSubmenuTrigger.useMenuPositionerContext(true);
@@ -1380,6 +1607,8 @@ 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({
@@ -1408,7 +1637,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() {}
+      preventUnmountOnClose: useRenderElement.NOOP
     });
     onCheckedChange?.(!checked, details);
     if (details.isCanceled) {
@@ -1451,6 +1680,7 @@ const MenuCheckboxItemIndicator = /*#__PURE__*/React__namespace.forwardRef(funct
   const indicatorRef = React__namespace.useRef(null);
   const {
     transitionStatus,
+    mounted,
     setMounted
   } = useScrollLock.useTransitionStatus(item.checked);
   useScrollLock.useOpenChangeComplete({
@@ -1476,22 +1706,22 @@ const MenuCheckboxItemIndicator = /*#__PURE__*/React__namespace.forwardRef(funct
       'aria-hidden': true,
       ...elementProps
     },
-    enabled: keepMounted || item.checked
+    enabled: keepMounted || mounted
   });
   return element;
 });
 if (process.env.NODE_ENV !== "production") MenuCheckboxItemIndicator.displayName = "MenuCheckboxItemIndicator";
 
 function getCssDimensions(element) {
-  const css = floatingUi_utils.getComputedStyle(element);
+  const css = useScrollLock.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 = floatingUi_utils.isHTMLElement(element);
+  const hasOffset = useScrollLock.isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
+  const shouldFallback = useScrollLock.round(width) !== offsetWidth || useScrollLock.round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -1516,30 +1746,14 @@ function usePopupAutoResize(parameters) {
     side,
     direction
   } = parameters;
-  const runOnceAnimationsFinish = useScrollLock.useAnimationsFinished(popupElement, true, false);
+  const runOnceAnimationsFinish = useScrollLock.useAnimationsFinished(popupElement, true);
   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(() => {
-    // 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]);
+  const anchoringStyles = React__namespace.useMemo(() => getPopupAnchoringStyles(side, direction), [side, direction]);
   useScrollLock.useIsoLayoutEffect(() => {
     // Reset the state when the popup is closed.
     if (!mounted) {
@@ -1615,6 +1829,19 @@ 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);
@@ -1644,6 +1871,80 @@ 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.
@@ -1652,7 +1953,6 @@ function usePopupViewport(parameters) {
   const {
     store,
     side,
-    cssVars,
     children
   } = parameters;
   const direction = useScrollLock.useDirection();
@@ -1672,14 +1972,15 @@ 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, false);
+  const onAnimationsFinished = useScrollLock.useAnimationsFinished(currentContainerRef, true);
   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('hasViewport', true);
+    store.set('adaptiveOrigin', adaptiveOrigin);
     return () => {
-      store.set('hasViewport', false);
+      store.set('adaptiveOrigin', undefined);
     };
   }, [store]);
   const handleMeasureLayout = useScrollLock.useStableCallback(() => {
@@ -1695,6 +1996,16 @@ 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) {
@@ -1712,19 +2023,33 @@ 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, previousContentNode, onAnimationsFinished, cleanupFrame]);
+  }, [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]);
 
   // 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.
@@ -1761,8 +2086,8 @@ function usePopupViewport(parameters) {
         ref: previousContainerRef,
         style: {
           ...(previousContentDimensions ? {
-            [cssVars.popupWidth]: `${previousContentDimensions.width}px`,
-            [cssVars.popupHeight]: `${previousContentDimensions.height}px`
+            '--popup-width': `${previousContentDimensions.width}px`,
+            '--popup-height': `${previousContentDimensions.height}px`
           } : null),
           position: 'absolute'
         },
@@ -1887,28 +2212,6 @@ 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
@@ -1938,7 +2241,6 @@ const MenuViewport = /*#__PURE__*/React__namespace.forwardRef(function MenuViewp
   } = usePopupViewport({
     store,
     side,
-    cssVars: MenuViewportCssVars,
     children
   });
   const state = {
@@ -1952,47 +2254,50 @@ const MenuViewport = /*#__PURE__*/React__namespace.forwardRef(function MenuViewp
     props: [elementProps, {
       children: childrenToRender
     }],
-    stateAttributesMapping: stateAttributesMapping$2
+    stateAttributesMapping: popupViewportStateMapping
   });
 });
 if (process.env.NODE_ENV !== "production") MenuViewport.displayName = "MenuViewport";
 
-class MenuHandle {
-  /**
-   * Internal store holding the menu's state.
-   * @internal
-   */
-
+/**
+ * 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 {
   constructor() {
-    this.store = new MenuSubmenuTrigger.MenuStore();
+    super(MenuSubmenuTrigger.createNullMenuStore(), 'Menu');
   }
 
   /**
    * 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.
    *
-   * @param triggerId ID of the trigger to associate with the menu.
+   * 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.
    */
   open(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));
+    this.openByTrigger(triggerId);
   }
 
   /**
    * Closes the menu.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close() {
-    this.store.setOpen(false, useScrollLock.createChangeEventDetails('imperative-action', undefined, undefined));
+    this.closePopup();
   }
 
   /**
-   * Indicates whether the menu is currently open.
+   * Whether the menu is currently open. Returns `false` while no root is attached to the handle.
    */
   get isOpen() {
-    return this.store.select('open');
+    return this.attachedStore?.select('open') ?? false;
   }
 }
 
@@ -2039,20 +2344,6 @@ 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.
@@ -2073,7 +2364,6 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     scrollingX,
     scrollingY,
     hiddenState,
-    overflowEdges,
     scrollbarYRef,
     scrollbarXRef,
     viewportRef,
@@ -2082,43 +2372,37 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     handlePointerDown,
     handlePointerUp,
     handleScroll,
+    disableViewportSnap,
     rootId,
     thumbSize,
-    hasMeasuredScrollbar
+    hasMeasuredScrollbar,
+    viewportState
   } = ScrollAreaViewport.useScrollAreaRootContext();
+  const vertical = orientation === 'vertical';
   const state = {
+    ...viewportState,
     hovering,
-    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
+    scrolling: vertical ? scrollingY : scrollingX,
+    orientation
   };
   const direction = useScrollLock.useDirection();
   const hideTrackUntilMeasured = !hasMeasuredScrollbar && !keepMounted;
-  const isHidden = orientation === 'vertical' ? hiddenState.y : hiddenState.x;
+  const isHidden = vertical ? hiddenState.y : hiddenState.x;
   const shouldRender = keepMounted || !isHidden;
   React__namespace.useEffect(() => {
     if (!shouldRender) {
       return undefined;
     }
     const viewportEl = viewportRef.current;
-    const scrollbarEl = orientation === 'vertical' ? scrollbarYRef.current : scrollbarXRef.current;
+    const scrollbarEl = vertical ? scrollbarYRef.current : scrollbarXRef.current;
     if (!scrollbarEl) {
       return undefined;
     }
     function handleWheel(event) {
-      if (!viewportEl || !scrollbarEl || event.ctrlKey) {
+      if (!viewportEl || event.ctrlKey) {
         return;
       }
-      const horizontal = orientation === 'horizontal';
+      const horizontal = !vertical;
       const scrollProperty = horizontal ? 'scrollLeft' : 'scrollTop';
       const delta = horizontal ? event.deltaX : event.deltaY;
       if (delta === 0) {
@@ -2145,7 +2429,7 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
     return useScrollLock.addEventListener(scrollbarEl, 'wheel', handleWheel, {
       passive: false
     });
-  }, [direction, handleScroll, orientation, scrollbarXRef, scrollbarYRef, shouldRender, viewportRef]);
+  }, [direction, handleScroll, vertical, scrollbarXRef, scrollbarYRef, shouldRender, viewportRef]);
   const props = {
     ...(rootId && {
       'data-id': `${rootId}-scrollbar`
@@ -2155,58 +2439,55 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
         return;
       }
       const target = useScrollLock.getTarget(event.nativeEvent);
-      const thumb = orientation === 'vertical' ? thumbYRef.current : thumbXRef.current;
+      const thumbEl = 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 (thumb && useScrollLock.contains(thumb, target)) {
+      if (thumbEl && useScrollLock.contains(thumbEl, target)) {
         return;
       }
-      if (!viewportRef.current) {
+      const viewportEl = viewportRef.current;
+      if (!viewportEl) {
         return;
       }
-
-      // 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;
+      const scrollbarEl = vertical ? scrollbarYRef.current : scrollbarXRef.current;
+      if (!thumbEl || !scrollbarEl) {
+        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) {
+        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;
       }
       handleScroll({
-        x: viewportRef.current.scrollLeft,
-        y: viewportRef.current.scrollTop
+        x: viewportEl.scrollLeft,
+        y: viewportEl.scrollTop
       });
       handlePointerDown(event);
     },
@@ -2220,34 +2501,30 @@ const ScrollAreaScrollbar = /*#__PURE__*/React__namespace.forwardRef(function Sc
       WebkitUserSelect: 'none',
       userSelect: 'none',
       visibility: hideTrackUntilMeasured ? 'hidden' : undefined,
-      ...(orientation === 'vertical' && {
+      ...(vertical ? {
         top: 0,
-        bottom: `var(${ScrollAreaViewport.ScrollAreaRootCssVars.scrollAreaCornerHeight})`,
+        bottom: 'var(--scroll-area-corner-height)',
         insetInlineEnd: 0,
-        [ScrollAreaScrollbarCssVars.scrollAreaThumbHeight]: `${thumbSize.height}px`
-      }),
-      ...(orientation === 'horizontal' && {
+        ['--scroll-area-thumb-height']: `${thumbSize.height}px`
+      } : {
         insetInlineStart: 0,
-        insetInlineEnd: `var(${ScrollAreaViewport.ScrollAreaRootCssVars.scrollAreaCornerWidth})`,
+        insetInlineEnd: 'var(--scroll-area-corner-width)',
         bottom: 0,
-        [ScrollAreaScrollbarCssVars.scrollAreaThumbWidth]: `${thumbSize.width}px`
+        ['--scroll-area-thumb-width']: `${thumbSize.width}px`
       })
     }
   };
   const element = useRenderElement.useRenderElement('div', componentProps, {
-    ref: [forwardedRef, orientation === 'vertical' ? scrollbarYRef : scrollbarXRef],
+    ref: [forwardedRef, 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: contextValue,
+    value: orientation,
     children: element
   });
 });
@@ -2335,43 +2612,30 @@ const ScrollAreaThumb = /*#__PURE__*/React__namespace.forwardRef(function Scroll
     handlePointerDown,
     handlePointerMove,
     handlePointerUp,
-    setScrollingX,
-    setScrollingY,
     scrollingX,
     scrollingY,
     hasMeasuredScrollbar
   } = ScrollAreaViewport.useScrollAreaRootContext();
-  const {
-    orientation
-  } = useScrollAreaScrollbarContext();
+  const orientation = useScrollAreaScrollbarContext();
+  const vertical = orientation === 'vertical';
   const state = {
-    scrolling: orientation === 'horizontal' ? scrollingX : scrollingY,
+    scrolling: vertical ? scrollingY : scrollingX,
     orientation
   };
-  function endDrag(event) {
-    if (orientation === 'vertical') {
-      setScrollingY(false);
-    }
-    if (orientation === 'horizontal') {
-      setScrollingX(false);
-    }
-    handlePointerUp(event);
-  }
   const element = useRenderElement.useRenderElement('div', componentProps, {
-    ref: [forwardedRef, orientation === 'vertical' ? thumbYRef : thumbXRef],
+    ref: [forwardedRef, vertical ? thumbYRef : thumbXRef],
     state,
     props: [{
       onPointerDown: handlePointerDown,
       onPointerMove: handlePointerMove,
-      onPointerUp: endDrag,
-      onPointerCancel: endDrag,
+      onPointerUp: handlePointerUp,
+      onPointerCancel: handlePointerUp,
       style: {
         visibility: hasMeasuredScrollbar ? undefined : 'hidden',
-        ...(orientation === 'vertical' && {
-          height: `var(${ScrollAreaScrollbarCssVars.scrollAreaThumbHeight})`
-        }),
-        ...(orientation === 'horizontal' && {
-          width: `var(${ScrollAreaScrollbarCssVars.scrollAreaThumbWidth})`
+        ...(vertical ? {
+          height: 'var(--scroll-area-thumb-height)'
+        } : {
+          width: 'var(--scroll-area-thumb-width)'
         })
       }
     }, elementProps]
@@ -2429,34 +2693,34 @@ var index_parts$3 = /*#__PURE__*/Object.freeze({
 
 var index_parts$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  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
+  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
 });
 
 const NumberFieldScrubAreaContext = /*#__PURE__*/React__namespace.createContext(undefined);
@@ -2471,7 +2735,7 @@ function useNumberFieldScrubAreaContext() {
 
 // Calculates the bounds the virtual cursor wraps within, as absolute edge coordinates.
 function getViewportRect(teleportDistance, scrubAreaEl) {
-  const win = floatingUi_utils.getWindow(scrubAreaEl);
+  const win = useScrollLock.getWindow(scrubAreaEl);
   if (teleportDistance != null) {
     const rect = scrubAreaEl.getBoundingClientRect();
     return {
@@ -2498,22 +2762,6 @@ 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',
@@ -2539,8 +2787,6 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
   const {
     state,
     setIsScrubbing: setRootScrubbing,
-    disabled,
-    readOnly,
     inputRef,
     incrementValue,
     allowInputSyncRef,
@@ -2549,6 +2795,10 @@ 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);
@@ -2558,21 +2808,15 @@ 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);
-  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})`;
-    }
+  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})`;
   }
   const onScrub = useScrollLock.useStableCallback(({
     movementX,
@@ -2585,24 +2829,23 @@ 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: Math.round(coords.x + movementX),
-      y: Math.round(coords.y + movementY)
+      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)
     };
-    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(newCoords.x, newCoords.y);
+    updateCursorTransform(virtualCursor, newCoords.x, newCoords.y);
   });
   const onScrubbingChange = useScrollLock.useStableCallback((scrubbingValue, {
     clientX,
@@ -2621,7 +2864,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
       y: clientY - virtualCursor.offsetHeight / 2
     };
     virtualCursorCoords.current = initialCoords;
-    updateCursorTransform(initialCoords.x, initialCoords.y);
+    updateCursorTransform(virtualCursor, initialCoords.x, initialCoords.y);
   });
   React__namespace.useEffect(function registerGlobalScrubbingEventListeners() {
     // Only listen while actively scrubbing; avoids unrelated pointerup events committing.
@@ -2645,7 +2888,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 (floatingUi_utils.getWindow(input).MouseEvent)('click', {
+            pointerDownTarget.dispatchEvent(new (useScrollLock.getWindow(input).MouseEvent)('click', {
               bubbles: true,
               cancelable: true
             }));
@@ -2663,6 +2906,9 @@ 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;
       }
@@ -2691,7 +2937,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
         }
       }
     }
-    const win = floatingUi_utils.getWindow(inputRef.current);
+    const win = useScrollLock.getWindow(inputRef.current);
     const unsubscribe = useScrollLock.mergeCleanups(useScrollLock.addEventListener(win, 'pointerup', handleScrubPointerUp, true), useScrollLock.addEventListener(win, 'pointermove', handleScrubPointerMove, true));
     return () => {
       exitPointerLockTimeout.clear();
@@ -2730,8 +2976,7 @@ const NumberFieldScrubArea = /*#__PURE__*/React__namespace.forwardRef(function N
     role: 'presentation',
     style: SCRUB_AREA_STYLE,
     async onPointerDown(event) {
-      const isMainButton = !event.button || event.button === 0;
-      if (event.defaultPrevented || readOnly || !isMainButton || disabled) {
+      if (event.defaultPrevented || readOnly || event.button || disabled) {
         return;
       }
       const isTouch = event.pointerType === 'touch';
@@ -2871,7 +3116,8 @@ const SelectLabel = /*#__PURE__*/React__namespace.forwardRef(function SelectLabe
     id: defaultLabelId,
     fallbackControlId: triggerElement?.id ?? rootId,
     setLabelId(nextLabelId) {
-      store.set('labelId', nextLabelId);
+      const resolvedLabelId = typeof nextLabelId === 'function' ? nextLabelId(store.state.labelId) : nextLabelId;
+      store.set('labelId', resolvedLabelId);
     }
   });
   return useRenderElement.useRenderElement('div', componentProps, {
@@ -2916,7 +3162,7 @@ const SelectIcon = /*#__PURE__*/React__namespace.forwardRef(function SelectIcon(
 });
 if (process.env.NODE_ENV !== "production") SelectIcon.displayName = "SelectIcon";
 
-const stateAttributesMapping$1 = {
+const stateAttributesMapping = {
   ...useScrollLock.popupStateMapping,
   ...useScrollLock.transitionStatusMapping
 };
@@ -2955,17 +3201,12 @@ const SelectBackdrop = /*#__PURE__*/React__namespace.forwardRef(function SelectB
         WebkitUserSelect: 'none'
       }
     }, elementProps],
-    stateAttributesMapping: stateAttributesMapping$1
+    stateAttributesMapping
   });
   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.
@@ -3004,7 +3245,7 @@ const SelectArrow = /*#__PURE__*/React__namespace.forwardRef(function SelectArro
       style: arrowStyles,
       'aria-hidden': true
     }, elementProps],
-    stateAttributesMapping
+    stateAttributesMapping: useScrollLock.popupTransitionStateMapping
   });
   if (alignItemWithTriggerActive) {
     return null;
@@ -3022,7 +3263,7 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
     className,
     style,
     direction,
-    keepMounted = false,
+    keepMounted,
     ...elementProps
   } = componentProps;
   const isUp = direction === 'up';
@@ -3053,12 +3294,10 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
   } = useScrollLock.useTransitionStatus(visible);
   useScrollLock.useIsoLayoutEffect(() => {
     scrollArrowsMountedCountRef.current += 1;
-    if (!store.state.hasScrollArrows) {
-      store.set('hasScrollArrows', true);
-    }
+    store.set('hasScrollArrows', true);
     return () => {
       scrollArrowsMountedCountRef.current = Math.max(0, scrollArrowsMountedCountRef.current - 1);
-      if (scrollArrowsMountedCountRef.current === 0 && store.state.hasScrollArrows) {
+      if (scrollArrowsMountedCountRef.current === 0) {
         store.set('hasScrollArrows', false);
       }
     };
@@ -3095,7 +3334,7 @@ const SelectScrollArrow = /*#__PURE__*/React__namespace.forwardRef(function Sele
           return;
         }
         store.set('activeIndex', null);
-        handleScrollArrowVisibility();
+        handleScrollArrowVisibility(scroller);
         const maxScrollTop = scrollEdges.getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
         const scrollTop = scrollEdges.normalizeScrollOffset(scroller.scrollTop, maxScrollTop);
         const isScrolledToEdge = scrollTop === (isUp ? 0 : maxScrollTop);
@@ -3103,11 +3342,6 @@ 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;
@@ -3196,6 +3430,14 @@ 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,
@@ -3214,7 +3456,7 @@ var index_parts = /*#__PURE__*/Object.freeze({
   Root: SelectGroupLabel.SelectRoot,
   ScrollDownArrow: SelectScrollDownArrow,
   ScrollUpArrow: SelectScrollUpArrow,
-  Separator: Separator.Separator,
+  Separator: SelectSeparator,
   Trigger: SelectGroupLabel.SelectTrigger,
   Value: SelectGroupLabel.SelectValue
 });