@jobber/components 9.6.0 → 9.6.2

package/dist/ScrollAreaViewport-cjs.js

@@ -5,8 +5,8 @@ var useRenderElement = require('./useRenderElement-cjs.js');
 var useScrollLock = require('./useScrollLock-cjs.js');
 var scrollEdges = require('./scrollEdges-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var ReactDOM = require('react-dom');
-var scrollable = require('./scrollable-cjs.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -80,12 +80,12 @@ function createPopupFloatingRootContext(triggerElements, floatingId, nested = fa
     onOpenChange: undefined
   });
 }
-const activeTriggerIdSelector = state => state.triggerIdProp ?? state.activeTriggerId;
-const openSelector = state => state.openProp ?? state.open;
-const popupIdSelector = state => {
+const activeTriggerIdSelector = useScrollLock.createSelector(state => state.triggerIdProp ?? state.activeTriggerId);
+const openSelector = useScrollLock.createSelector(state => state.openProp ?? state.open);
+const popupIdSelector = useScrollLock.createSelector(state => {
   const popupId = state.popupElement?.id ?? state.floatingId;
   return popupId || undefined;
-};
+});
 function triggerOwnsOpenPopup(state, triggerId) {
   return triggerId !== undefined && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
 }
@@ -97,81 +97,47 @@ function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
 }
 const popupStoreSelectors = {
   open: openSelector,
-  mounted: state => state.mounted,
-  transitionStatus: state => state.transitionStatus,
-  floatingRootContext: state => state.floatingRootContext,
-  triggerCount: state => state.triggerCount,
-  preventUnmountingOnClose: state => state.preventUnmountingOnClose,
-  payload: state => state.payload,
+  mounted: useScrollLock.createSelector(state => state.mounted),
+  transitionStatus: useScrollLock.createSelector(state => state.transitionStatus),
+  floatingRootContext: useScrollLock.createSelector(state => state.floatingRootContext),
+  triggerCount: useScrollLock.createSelector(state => state.triggerCount),
+  preventUnmountingOnClose: useScrollLock.createSelector(state => state.preventUnmountingOnClose),
+  payload: useScrollLock.createSelector(state => state.payload),
   activeTriggerId: activeTriggerIdSelector,
-  activeTriggerElement: state => state.mounted ? state.activeTriggerElement : null,
+  activeTriggerElement: useScrollLock.createSelector(state => state.mounted ? state.activeTriggerElement : null),
   popupId: popupIdSelector,
   /**
    * Whether the trigger with the given ID was used to open the popup.
    */
-  isTriggerActive: (state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId,
+  isTriggerActive: useScrollLock.createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId),
   /**
    * Whether the popup is open and was activated by a trigger with the given ID.
    */
-  isOpenedByTrigger: (state, triggerId) => triggerOwnsOpenPopup(state, triggerId),
+  isOpenedByTrigger: useScrollLock.createSelector((state, triggerId) => triggerOwnsOpenPopup(state, triggerId)),
   /**
    * Whether the popup is mounted and was activated by a trigger with the given ID.
    */
-  isMountedByTrigger: (state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.mounted,
-  triggerProps: (state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps,
+  isMountedByTrigger: useScrollLock.createSelector((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.mounted),
+  triggerProps: useScrollLock.createSelector((state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps),
   /**
    * Popup id for the trigger that currently owns the open popup.
    */
-  triggerPopupId: (state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : undefined,
-  popupProps: state => state.popupProps,
-  popupElement: state => state.popupElement,
-  positionerElement: state => state.positionerElement
+  triggerPopupId: useScrollLock.createSelector((state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : undefined),
+  popupProps: useScrollLock.createSelector(state => state.popupProps),
+  popupElement: useScrollLock.createSelector(state => state.popupElement),
+  positionerElement: useScrollLock.createSelector(state => state.positionerElement)
 };
 
-/**
- * Store members a detached handle-backed trigger reads or invokes for trigger registration and data
- * forwarding. `set`/`update` are included only for trigger-count and trigger-data bookkeeping; on a
- * detached (inert) store they are intentionally no-ops, so a write through them is not guaranteed to
- * be durable. Component handle-store views Pick these from their concrete store (preserving its
- * context and selectors) and add any component-specific trigger-invoked members such as `setOpen`.
- */
-
-/**
- * The subset of a popup store that trigger registration and data forwarding rely on. Narrow enough
- * that an inert store can be passed while detached.
- */
-
-/**
- * Reads the store currently exposed by a popup handle and subscribes to store-pointer changes.
- * Detached triggers use this to follow a handle as a root attaches or detaches: while no root is
- * attached, the handle exposes its fallback store; once a root attaches, subscribers re-render and
- * read from the live root store.
- *
- * Returns `undefined` when no handle is provided so callers can fall back to their root context.
- *
- * @param handle The popup handle to read from, or `undefined` when the trigger is not handle-bound.
- */
-function usePopupHandleStore(handle) {
-  const subscribe = React__namespace.useCallback(listener => {
-    if (handle === undefined) {
-      return useRenderElement.NOOP;
-    }
-    return handle.subscribeStore(listener);
-  }, [handle]);
-  const getSnapshot = React__namespace.useCallback(() => {
-    return handle === undefined ? undefined : handle.store;
-  }, [handle]);
-  return useScrollLock.shimExports.useSyncExternalStore(subscribe, getSnapshot, () => handle?.serverStore);
-}
-
+const IsDrawerContext = /*#__PURE__*/React__namespace.createContext(false);
+if (process.env.NODE_ENV !== "production") IsDrawerContext.displayName = "IsDrawerContext";
 const DialogRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DialogRootContext.displayName = "DialogRootContext";
 function useDialogRootContext(optional) {
-  const store = React__namespace.useContext(DialogRootContext);
-  if (!optional && store === undefined) {
+  const dialogRootContext = React__namespace.useContext(DialogRootContext);
+  if (optional === false && dialogRootContext === undefined) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: DialogRootContext is missing. Dialog parts must be placed within <Dialog.Root>.' : useRenderElement.formatErrorMessage(27));
   }
-  return store;
+  return dialogRootContext;
 }
 
 const DialogPortalContext = /*#__PURE__*/React__namespace.createContext(undefined);
@@ -184,26 +150,14 @@ function useDialogPortalContext() {
   return value;
 }
 
-/**
- * Shared by `Dialog.Popup` and `Dialog.Viewport`, whose states have the same shape.
- * `nested` is not mapped: unmapped `true` booleans already render as `data-nested`.
- */
-const dialogStateAttributesMapping = {
-  ...useScrollLock.popupStateMapping,
-  ...useScrollLock.transitionStatusMapping,
-  nestedDialogOpen(value) {
-    return value ? {
-      'data-nested-dialog-open': ''
-    } : null;
-  }
-};
-
 const DialogPortal = /*#__PURE__*/React__namespace.forwardRef(function DialogPortal(props, forwardedRef) {
   const {
     keepMounted = false,
     ...portalProps
   } = props;
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const mounted = store.useState('mounted');
   const modal = store.useState('modal');
   const open = store.useState('open');
@@ -225,6 +179,25 @@ const DialogPortal = /*#__PURE__*/React__namespace.forwardRef(function DialogPor
 });
 if (process.env.NODE_ENV !== "production") DialogPortal.displayName = "DialogPortal";
 
+function useDialogRoot(params) {
+  const {
+    store,
+    actionsRef
+  } = params;
+  const open = store.useState('open');
+  useScrollLock.usePopupRootSync(store, open);
+  useScrollLock.useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useScrollLock.useOpenStateTransitions(open, store);
+  const handleImperativeClose = React__namespace.useCallback(() => {
+    store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.imperativeAction));
+  }, [store]);
+  React__namespace.useImperativeHandle(actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+}
 function DialogInteractions({
   store,
   parentContext,
@@ -260,18 +233,8 @@ function DialogInteractions({
       if ('button' in event && event.button !== 0) {
         return false;
       }
-      if ('touches' in event) {
-        // Outside press can be handled on `touchend`, where the lifted point is
-        // reported in `changedTouches` and `touches` contains any remaining
-        // active points. Treat it as a single-finger tap only when exactly one
-        // touch ended and no other fingers are still down.
-        if (event.type === 'touchend') {
-          if (event.changedTouches.length !== 1 || event.touches.length !== 0) {
-            return false;
-          }
-        } else if (event.touches.length !== 1) {
-          return false;
-        }
+      if ('touches' in event && event.touches.length !== 1) {
+        return false;
       }
       const target = useScrollLock.getTarget(event);
       if (isTopmost && !disablePointerDismissal) {
@@ -279,9 +242,7 @@ function DialogInteractions({
         // This supports multiple modal dialogs that aren't nested in the React tree:
         // https://github.com/mui/base-ui/issues/1320
         if (modal) {
-          const internalBackdrop = store.context.internalBackdropRef.current;
-          const backdrop = store.context.backdropRef.current;
-          return internalBackdrop || backdrop ? internalBackdrop === target || backdrop === target || useScrollLock.contains(target, popupElement) && !target?.hasAttribute('data-base-ui-portal') : true;
+          return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === target || store.context.backdropRef.current === target || useScrollLock.contains(target, popupElement) && !target?.hasAttribute('data-base-ui-portal') : true;
         }
         return true;
       }
@@ -292,82 +253,73 @@ function DialogInteractions({
   useScrollLock.useScrollLock(open && modal === true, popupElement);
 
   // Listen for nested open/close events on this store to maintain the counts.
-  // A close notification is an open notification with zeroed counts.
   store.useContextCallback('onNestedDialogOpen', (dialogCount, drawerCount) => {
     setOwnNestedOpenDialogs(dialogCount);
     setOwnNestedOpenDrawers(drawerCount);
   });
+  store.useContextCallback('onNestedDialogClose', () => {
+    setOwnNestedOpenDialogs(0);
+    setOwnNestedOpenDrawers(0);
+  });
 
   // Notify parent of our open/close state using parent callbacks, if any
-  useScrollLock.useIsoLayoutEffect(() => {
-    if (parentContext?.onNestedDialogOpen) {
-      if (open) {
-        parentContext.onNestedDialogOpen(ownNestedOpenDialogs + 1, ownNestedOpenDrawers + (isDrawer ? 1 : 0));
-      } else {
-        parentContext.onNestedDialogOpen(0, 0);
-      }
+  React__namespace.useEffect(() => {
+    if (parentContext?.onNestedDialogOpen && open) {
+      parentContext.onNestedDialogOpen(ownNestedOpenDialogs + 1, ownNestedOpenDrawers + (isDrawer ? 1 : 0));
+    }
+    if (parentContext?.onNestedDialogClose && !open) {
+      parentContext.onNestedDialogClose();
     }
     return () => {
-      if (parentContext?.onNestedDialogOpen && open) {
-        parentContext.onNestedDialogOpen(0, 0);
+      if (parentContext?.onNestedDialogClose && open) {
+        parentContext.onNestedDialogClose();
       }
     };
   }, [isDrawer, open, ownNestedOpenDialogs, ownNestedOpenDrawers, parentContext]);
+  const activeTriggerProps = dismiss.reference ?? useRenderElement.EMPTY_OBJECT;
+  const inactiveTriggerProps = dismiss.trigger ?? useRenderElement.EMPTY_OBJECT;
+  // Consumers (DialogPopup/DrawerPopup) already spread `FOCUSABLE_POPUP_PROPS`
+  // directly, so the popup props only need to carry the dismiss handlers.
+  const popupProps = dismiss.floating ?? useRenderElement.EMPTY_OBJECT;
   useScrollLock.usePopupInteractionProps(store, {
-    // `enabled` is not passed to `useDismiss`, so its props are always defined,
-    // and `trigger` is the same object as `reference`.
-    activeTriggerProps: dismiss.reference,
-    inactiveTriggerProps: dismiss.trigger,
-    // DialogPopup and DrawerPopup spread `FOCUSABLE_POPUP_PROPS` directly, so
-    // this only needs to carry the dismiss handlers.
-    popupProps: dismiss.floating,
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps,
     nestedOpenDialogCount: ownNestedOpenDialogs,
     nestedOpenDrawerCount: ownNestedOpenDrawers
   });
   return null;
 }
 
-/**
- * A `ReactStore` whose state never changes.
- *
- * Useful for fallback stores that need to support normal store reads while detached from the
- * component that owns real state. Context values may still contain mutable refs or maps.
- */
-class NullStore extends useScrollLock.ReactStore {
-  // `update`/`set`/`notifyAll` funnel through `setState` in the base `Store`, so overriding
-  // `setState` alone would neutralize them today. They are overridden explicitly so the store stays
-  // inert even if a future base-class change stops routing a mutator through `setState`.
-  setState(_newState) {}
-  update(_changes) {}
-  set(_key, _value) {}
-  notifyAll() {}
-}
-
 const selectors = {
   ...popupStoreSelectors,
-  modal: state => state.modal,
-  nested: state => state.nested,
-  nestedOpenDialogCount: state => state.nestedOpenDialogCount,
-  nestedOpenDrawerCount: state => state.nestedOpenDrawerCount,
-  disablePointerDismissal: state => state.disablePointerDismissal,
-  openMethod: state => state.openMethod,
-  descriptionElementId: state => state.descriptionElementId,
-  titleElementId: state => state.titleElementId,
-  viewportElement: state => state.viewportElement,
-  role: state => state.role
+  modal: useScrollLock.createSelector(state => state.modal),
+  nested: useScrollLock.createSelector(state => state.nested),
+  nestedOpenDialogCount: useScrollLock.createSelector(state => state.nestedOpenDialogCount),
+  nestedOpenDrawerCount: useScrollLock.createSelector(state => state.nestedOpenDrawerCount),
+  disablePointerDismissal: useScrollLock.createSelector(state => state.disablePointerDismissal),
+  openMethod: useScrollLock.createSelector(state => state.openMethod),
+  descriptionElementId: useScrollLock.createSelector(state => state.descriptionElementId),
+  titleElementId: useScrollLock.createSelector(state => state.titleElementId),
+  viewportElement: useScrollLock.createSelector(state => state.viewportElement),
+  role: useScrollLock.createSelector(state => state.role)
 };
-
-/**
- * The subset of `DialogStore` that detached handle-backed triggers rely on. Both the real
- * `DialogStore` and the inert fallback store satisfy it, so a trigger can read from whichever
- * store the handle currently exposes.
- */
-
 class DialogStore extends useScrollLock.ReactStore {
-  constructor(initialState, floatingId, nested) {
+  constructor(initialState, floatingId, nested = false) {
     const triggerElements = new useScrollLock.PopupTriggerMap();
-    const state = createInitialState(initialState, triggerElements, floatingId, nested);
-    super(state, createInitialContext(triggerElements), selectors);
+    const state = createInitialState(initialState);
+    state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
+    super(state, {
+      popupRef: /*#__PURE__*/React__namespace.createRef(),
+      backdropRef: /*#__PURE__*/React__namespace.createRef(),
+      internalBackdropRef: /*#__PURE__*/React__namespace.createRef(),
+      outsidePressEnabledRef: {
+        current: true
+      },
+      triggerElements,
+      onOpenChange: undefined,
+      onOpenChangeComplete: undefined
+    }, selectors);
   }
   setOpen = (nextOpen, eventDetails) => {
     eventDetails.preventUnmountOnClose = () => {
@@ -389,22 +341,20 @@ class DialogStore extends useScrollLock.ReactStore {
     useScrollLock.setPopupOpenState(updatedState, nextOpen, eventDetails.trigger);
     this.update(updatedState);
   };
-}
+  static useStore(externalStore, initialState) {
+    /* eslint-disable react-hooks/rules-of-hooks */
+    const store = useScrollLock.usePopupStore(externalStore, (floatingId, nested) => new DialogStore(initialState, floatingId, nested), true).store;
+    /* eslint-enable react-hooks/rules-of-hooks */
 
-/**
- * Creates the inert fallback store used by detached handle-backed triggers while no
- * `Dialog.Root` is attached. It preserves a dialog-specific trigger registry in context so
- * detached triggers can register before migrating to the live root store.
- */
-function createNullDialogStore() {
-  const triggerElements = new useScrollLock.PopupTriggerMap();
-  return new NullStore(Object.freeze(createInitialState(undefined, triggerElements)), Object.freeze(createInitialContext(triggerElements)), selectors);
+    return store;
+  }
 }
-function createInitialState(initialState, triggerElements, floatingId, nested = false) {
-  const state = {
+function createInitialState(initialState = {}) {
+  return {
     ...createInitialPopupStoreState(),
     modal: true,
     disablePointerDismissal: false,
+    popupElement: null,
     viewportElement: null,
     descriptionElementId: undefined,
     titleElementId: undefined,
@@ -415,24 +365,9 @@ function createInitialState(initialState, triggerElements, floatingId, nested =
     role: 'dialog',
     ...initialState
   };
-  state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
-  return state;
-}
-function createInitialContext(triggerElements) {
-  return {
-    popupRef: /*#__PURE__*/React__namespace.createRef(),
-    backdropRef: /*#__PURE__*/React__namespace.createRef(),
-    internalBackdropRef: /*#__PURE__*/React__namespace.createRef(),
-    outsidePressEnabledRef: {
-      current: true
-    },
-    triggerElements,
-    onOpenChange: undefined,
-    onOpenChangeComplete: undefined
-  };
 }
 
-function useRenderDialogRoot(mode, props) {
+function useRenderDialogRoot(props, mode = 'dialog') {
   const {
     children,
     open: openProp,
@@ -451,26 +386,38 @@ function useRenderDialogRoot(mode, props) {
   const modal = isAlertDialog ? true : modalProp;
   const disablePointerDismissal = isAlertDialog || disablePointerDismissalProp;
   const role = isAlertDialog ? 'alertdialog' : 'dialog';
-  const parentStore = useDialogRootContext(true);
-  const nested = parentStore != null;
+  const parentDialogRootContext = useDialogRootContext(true);
+  const nested = Boolean(parentDialogRootContext);
   const rootState = {
     modal,
     disablePointerDismissal,
     nested,
     role
   };
-
-  // The store is owned by this Root instance and created exactly once. It is not tied to the handle:
-  // the handle attaches to it, so swapping the handle re-attaches rather than recreating state.
-  // Default values are only initial values; controlled values and root state are synced after creation.
-  // Dialogs pass the popup element to Floating UI as the floating element (`treatPopupAsFloatingElement`).
-  const store = useScrollLock.usePopupRootStore((floatingId, floatingNested) => new DialogStore({
+  const store = DialogStore.useStore(handle?.store, {
     open: defaultOpen,
     openProp,
     activeTriggerId: defaultTriggerIdProp,
     triggerIdProp,
     ...rootState
-  }, floatingId, floatingNested), true);
+  });
+
+  // Support initially open state when uncontrolled
+  useScrollLock.useOnFirstRender(() => {
+    const nextState = openProp === undefined && store.state.open === false && defaultOpen === true ? {
+      open: true,
+      activeTriggerId: defaultTriggerIdProp
+    } : null;
+    if (isAlertDialog) {
+      // Handles can reuse plain Dialog stores; alert dialog invariants must exist immediately.
+      store.update(nextState ? {
+        ...rootState,
+        ...nextState
+      } : rootState);
+    } else if (nextState) {
+      store.update(nextState);
+    }
+  });
   store.useControlledProp('openProp', openProp);
   store.useControlledProp('triggerIdProp', triggerIdProp);
   store.useSyncedValues(rootState);
@@ -479,31 +426,83 @@ function useRenderDialogRoot(mode, props) {
   const open = store.useState('open');
   const mounted = store.useState('mounted');
   const payload = store.useState('payload');
-  useScrollLock.usePopupRootSync(store, open);
-  useScrollLock.useImplicitActiveTrigger(store);
-  const {
-    forceUnmount
-  } = useScrollLock.useOpenStateTransitions(open, store);
-  React__namespace.useImperativeHandle(actionsRef, () => ({
-    unmount: forceUnmount,
-    close: () => store.setOpen(false, useScrollLock.createChangeEventDetails(useScrollLock.imperativeAction))
-  }), [forceUnmount, store]);
+  useDialogRoot({
+    store,
+    actionsRef
+  });
   const shouldRenderInteractions = open || mounted;
-  return /*#__PURE__*/jsxRuntime.jsxs(DialogRootContext.Provider, {
-    value: store,
-    children: [handle && /*#__PURE__*/jsxRuntime.jsx(useScrollLock.PopupHandleAttachment, {
-      handle: handle,
-      store: store
-    }), shouldRenderInteractions && /*#__PURE__*/jsxRuntime.jsx(DialogInteractions, {
-      store: store,
-      parentContext: parentStore?.context,
-      isDrawer: isDrawer
-    }), typeof children === 'function' ? children({
-      payload
-    }) : children]
+  const contextValue = React__namespace.useMemo(() => ({
+    store
+  }), [store]);
+  return /*#__PURE__*/jsxRuntime.jsx(IsDrawerContext.Provider, {
+    value: false,
+    children: /*#__PURE__*/jsxRuntime.jsxs(DialogRootContext.Provider, {
+      value: contextValue,
+      children: [shouldRenderInteractions && /*#__PURE__*/jsxRuntime.jsx(DialogInteractions, {
+        store: store,
+        parentContext: parentDialogRootContext?.store.context,
+        isDrawer: isDrawer
+      }), typeof children === 'function' ? children({
+        payload
+      }) : children]
+    })
   });
 }
 
+/**
+ * Groups all parts of the dialog.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+function DialogRoot(props) {
+  const mode = React__namespace.useContext(IsDrawerContext) ? 'drawer' : 'dialog';
+  return useRenderDialogRoot(props, mode);
+}
+
+let DialogViewportDataAttributes = function (DialogViewportDataAttributes) {
+  /**
+   * Present when the dialog is open.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["open"] = useScrollLock.CommonPopupDataAttributes.open] = "open";
+  /**
+   * Present when the dialog is closed.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["closed"] = useScrollLock.CommonPopupDataAttributes.closed] = "closed";
+  /**
+   * Present when the dialog is animating in.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["startingStyle"] = useScrollLock.CommonPopupDataAttributes.startingStyle] = "startingStyle";
+  /**
+   * Present when the dialog is animating out.
+   */
+  DialogViewportDataAttributes[DialogViewportDataAttributes["endingStyle"] = useScrollLock.CommonPopupDataAttributes.endingStyle] = "endingStyle";
+  /**
+   * Present when the dialog is nested within another dialog.
+   */
+  DialogViewportDataAttributes["nested"] = "data-nested";
+  /**
+   * Present when the dialog has other open dialogs nested within it.
+   */
+  DialogViewportDataAttributes["nestedDialogOpen"] = "data-nested-dialog-open";
+  return DialogViewportDataAttributes;
+}({});
+
+const stateAttributesMapping$2 = {
+  ...useScrollLock.popupStateMapping,
+  ...useScrollLock.transitionStatusMapping,
+  nested(value) {
+    return value ? {
+      [DialogViewportDataAttributes.nested]: ''
+    } : null;
+  },
+  nestedDialogOpen(value) {
+    return value ? {
+      [DialogViewportDataAttributes.nestedDialogOpen]: ''
+    } : null;
+  }
+};
+
 /**
  * A positioning container for the dialog popup that can be made scrollable.
  * Renders a `<div>` element.
@@ -519,7 +518,9 @@ const DialogViewport = /*#__PURE__*/React__namespace.forwardRef(function DialogV
     ...elementProps
   } = componentProps;
   const keepMounted = useDialogPortalContext();
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const open = store.useState('open');
   const nested = store.useState('nested');
   const transitionStatus = store.useState('transitionStatus');
@@ -538,7 +539,7 @@ const DialogViewport = /*#__PURE__*/React__namespace.forwardRef(function DialogV
     enabled: shouldRender,
     state,
     ref: [forwardedRef, setViewportElement],
-    stateAttributesMapping: dialogStateAttributesMapping,
+    stateAttributesMapping: stateAttributesMapping$2,
     props: [{
       role: 'presentation',
       hidden: !mounted,
@@ -569,9 +570,8 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
     handle,
     ...elementProps
   } = componentProps;
-  const dialogRootStore = useDialogRootContext(true);
-  const handleStore = usePopupHandleStore(handle);
-  const store = handleStore ?? dialogRootStore;
+  const dialogRootContext = useDialogRootContext(true);
+  const store = handle?.store ?? dialogRootContext?.store;
   if (!store) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: <Dialog.Trigger> must be used within <Dialog.Root> or provided with a handle.' : useRenderElement.formatErrorMessage(79));
   }
@@ -593,7 +593,9 @@ const DialogTrigger = /*#__PURE__*/React__namespace.forwardRef(function DialogTr
     disabled,
     native: nativeButton
   });
-  const click = useScrollLock.useClick(floatingContext);
+  const click = useScrollLock.useClick(floatingContext, {
+    enabled: floatingContext != null
+  });
   const interactionTypeProps = useScrollLock.useOpenMethodTriggerProps(() => store.select('open'), interactionType => {
     store.set('openMethod', interactionType);
   });
@@ -665,6 +667,11 @@ let DrawerBackdropCssVars = /*#__PURE__*/function (DrawerBackdropCssVars) {
   return DrawerBackdropCssVars;
 }({});
 
+const stateAttributesMapping$1 = {
+  ...useScrollLock.popupStateMapping,
+  ...useScrollLock.transitionStatusMapping
+};
+
 /**
  * An overlay displayed beneath the popup.
  * Renders a `<div>` element.
@@ -679,7 +686,9 @@ const DrawerBackdrop = /*#__PURE__*/React__namespace.forwardRef(function DrawerB
     forceRender = false,
     ...elementProps
   } = componentProps;
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const open = store.useState('open');
   const nested = store.useState('nested');
   const mounted = store.useState('mounted');
@@ -691,7 +700,7 @@ const DrawerBackdrop = /*#__PURE__*/React__namespace.forwardRef(function DrawerB
   return useRenderElement.useRenderElement('div', componentProps, {
     state,
     ref: [store.context.backdropRef, forwardedRef],
-    stateAttributesMapping: useScrollLock.popupTransitionStateMapping,
+    stateAttributesMapping: stateAttributesMapping$1,
     props: [{
       role: 'presentation',
       hidden: !mounted,
@@ -735,8 +744,9 @@ if (process.env.NODE_ENV !== "production") DrawerContent.displayName = "DrawerCo
 
 const DrawerProviderContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DrawerProviderContext.displayName = "DrawerProviderContext";
-function useDrawerProviderContext() {
-  return React__namespace.useContext(DrawerProviderContext);
+function useDrawerProviderContext(optional) {
+  const context = React__namespace.useContext(DrawerProviderContext);
+  return context;
 }
 
 let DrawerPopupDataAttributes = function (DrawerPopupDataAttributes) {
@@ -749,7 +759,7 @@ let DrawerPopupDataAttributes = function (DrawerPopupDataAttributes) {
    */
   DrawerPopupDataAttributes[DrawerPopupDataAttributes["closed"] = useScrollLock.CommonPopupDataAttributes.closed] = "closed";
   /**
-   * Present when the drawer begins animating in.
+   * Present when the drawer is animating in.
    */
   DrawerPopupDataAttributes[DrawerPopupDataAttributes["startingStyle"] = useScrollLock.CommonPopupDataAttributes.startingStyle] = "startingStyle";
   /**
@@ -788,7 +798,7 @@ const DrawerRootContext = /*#__PURE__*/React__namespace.createContext(undefined)
 if (process.env.NODE_ENV !== "production") DrawerRootContext.displayName = "DrawerRootContext";
 function useDrawerRootContext(optional) {
   const drawerRootContext = React__namespace.useContext(DrawerRootContext);
-  if (optional !== true && drawerRootContext === undefined) {
+  if (optional === false && drawerRootContext === undefined) {
     throw new Error(process.env.NODE_ENV !== "production" ? 'Base UI: DrawerRootContext is missing. Drawer parts must be placed within <Drawer.Root>.' : useRenderElement.formatErrorMessage(90));
   }
   return drawerRootContext;
@@ -829,24 +839,22 @@ function resolveSnapPointValue(snapPoint, viewportHeight, rootFontSize) {
   }
   return null;
 }
-
-/**
- * Returns the index of the value closest to `target`, or `-1` if `values` is empty.
- */
-function closestSnapPointIndex(values, target) {
-  let closestIndex = -1;
+function findClosestSnapPoint(height, points) {
+  let closest = null;
   let closestDistance = Infinity;
-  for (let index = 0; index < values.length; index += 1) {
-    const distance = Math.abs(values[index] - target);
+  for (const point of points) {
+    const distance = Math.abs(point.height - height);
     if (distance < closestDistance) {
       closestDistance = distance;
-      closestIndex = index;
+      closest = point;
     }
   }
-  return closestIndex;
+  return closest;
 }
 function useDrawerSnapPoints() {
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const {
     snapPoints,
     activeSnapPoint,
@@ -859,7 +867,12 @@ function useDrawerSnapPoints() {
   const measureViewportHeight = useScrollLock.useStableCallback(() => {
     const doc = useScrollLock.ownerDocument(viewportElement);
     const html = doc.documentElement;
-    setViewportHeight(viewportElement ? viewportElement.offsetHeight : html.clientHeight);
+    if (viewportElement) {
+      setViewportHeight(viewportElement.offsetHeight);
+    }
+    if (!viewportElement) {
+      setViewportHeight(html.clientHeight);
+    }
     const fontSize = parseFloat(getComputedStyle(html).fontSize);
     if (Number.isFinite(fontSize)) {
       setRootFontSize(fontSize);
@@ -881,9 +894,12 @@ function useDrawerSnapPoints() {
       return [];
     }
     const maxHeight = Math.min(popupHeight, viewportHeight);
+    if (!Number.isFinite(maxHeight) || maxHeight <= 0) {
+      return [];
+    }
     const resolved = snapPoints.map(value => {
       const resolvedHeight = resolveSnapPointValue(value, viewportHeight, rootFontSize);
-      if (resolvedHeight === null) {
+      if (resolvedHeight === null || !Number.isFinite(resolvedHeight)) {
         return null;
       }
       const clampedHeight = scrollEdges.clamp(resolvedHeight, 0, maxHeight);
@@ -911,6 +927,9 @@ function useDrawerSnapPoints() {
     return deduped;
   }, [popupHeight, rootFontSize, snapPoints, viewportHeight]);
   const resolvedActiveSnapPoint = React__namespace.useMemo(() => {
+    if (activeSnapPoint === undefined) {
+      return resolvedSnapPoints[0];
+    }
     if (activeSnapPoint === null) {
       return undefined;
     }
@@ -920,11 +939,11 @@ function useDrawerSnapPoints() {
     }
     const maxHeight = Math.min(popupHeight, viewportHeight);
     const resolvedHeight = resolveSnapPointValue(activeSnapPoint, viewportHeight, rootFontSize);
-    if (resolvedHeight === null) {
+    if (resolvedHeight === null || !Number.isFinite(resolvedHeight)) {
       return undefined;
     }
     const clampedHeight = scrollEdges.clamp(resolvedHeight, 0, maxHeight);
-    return resolvedSnapPoints[closestSnapPointIndex(resolvedSnapPoints.map(point => point.height), clampedHeight)];
+    return findClosestSnapPoint(clampedHeight, resolvedSnapPoints) ?? undefined;
   }, [activeSnapPoint, popupHeight, resolvedSnapPoints, rootFontSize, viewportHeight]);
   return {
     snapPoints,
@@ -939,8 +958,9 @@ function useDrawerSnapPoints() {
 
 const DrawerViewportContext = /*#__PURE__*/React__namespace.createContext(null);
 if (process.env.NODE_ENV !== "production") DrawerViewportContext.displayName = "DrawerViewportContext";
-function useDrawerViewportContext() {
-  return React__namespace.useContext(DrawerViewportContext);
+function useDrawerViewportContext(optional) {
+  const context = React__namespace.useContext(DrawerViewportContext);
+  return context;
 }
 
 let drawerSwipeVarsRegistered = false;
@@ -998,7 +1018,8 @@ function removeCSSVariableInheritance$1() {
   drawerSwipeVarsRegistered = true;
 }
 const stateAttributesMapping = {
-  ...useScrollLock.popupTransitionStateMapping,
+  ...useScrollLock.popupStateMapping,
+  ...useScrollLock.transitionStatusMapping,
   expanded(value) {
     return value ? {
       [DrawerPopupDataAttributes.expanded]: ''
@@ -1015,9 +1036,9 @@ const stateAttributesMapping = {
     } : null;
   },
   swipeDirection(value) {
-    return {
+    return value ? {
       [DrawerPopupDataAttributes.swipeDirection]: value
-    };
+    } : null;
   },
   swiping(value) {
     return value ? {
@@ -1041,7 +1062,9 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
     initialFocus,
     ...elementProps
   } = componentProps;
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const popupRef = store.context.popupRef;
   const {
     swipeDirection,
@@ -1080,8 +1103,6 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
   const swipeStrength = swipe?.swipeStrength ?? null;
   const [popupHeight, setPopupHeight] = React__namespace.useState(0);
   const popupHeightRef = React__namespace.useRef(0);
-
-  /* istanbul ignore else -- process.env.NODE_ENV is a build-time constant. */
   if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     React__namespace.useEffect(() => {
@@ -1164,7 +1185,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       }
     };
   }, [nestedSwipeProgressStore, popupRef]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (!open) {
       return undefined;
     }
@@ -1173,7 +1194,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
       notifyParentFrontmostHeight?.(0);
     };
   }, [frontmostHeight, open, notifyParentFrontmostHeight]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (!notifyParentHasNestedDrawer) {
       return undefined;
     }
@@ -1217,7 +1238,7 @@ const DrawerPopup = /*#__PURE__*/React__namespace.forwardRef(function DrawerPopu
   let dragStyles = swipe ? swipe.getDragStyles() : useRenderElement.EMPTY_OBJECT;
   if (shouldApplySnapPoints && swipeDirection === 'down') {
     const baseOffset = activeSnapPointOffset ?? 0;
-    const movementValue = Number.parseFloat(String(dragStyles[DrawerPopupCssVars.swipeMovementY]));
+    const movementValue = Number.parseFloat(String(dragStyles[DrawerPopupCssVars.swipeMovementY] ?? 0));
     if (swiping && Number.isFinite(movementValue)) {
       dragStyles = {
         ...dragStyles,
@@ -1327,7 +1348,6 @@ function DrawerRoot(props) {
     state: 'snapPoint'
   });
   const isNestedDrawerOpenRef = React__namespace.useRef(false);
-  const swipeAreaActiveRef = React__namespace.useRef(false);
   const setActiveSnapPoint = useScrollLock.useStableCallback((nextSnapPoint, eventDetails) => {
     const resolvedEventDetails = eventDetails ?? useScrollLock.createChangeEventDetails(useScrollLock.none);
     onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
@@ -1387,7 +1407,6 @@ function DrawerRoot(props) {
   });
   const contextValue = React__namespace.useMemo(() => ({
     swipeDirection,
-    swipeAreaActiveRef,
     snapToSequentialPoints,
     snapPoints,
     activeSnapPoint: resolvedActiveSnapPoint,
@@ -1406,28 +1425,30 @@ function DrawerRoot(props) {
     notifyParentSwipingChange,
     notifyParentSwipeProgressChange,
     notifyParentHasNestedDrawer
-  }), [resolvedActiveSnapPoint, frontmostHeight, hasNestedDrawer, nestedSwiping, nestedSwipeProgressStore, notifyParentHasNestedDrawer, notifyParentSwipeProgressChange, notifyParentSwipingChange, notifyParentFrontmostHeight, onNestedDrawerPresenceChange, onNestedFrontmostHeightChange, onNestedSwipeProgressChange, onNestedSwipingChange, onPopupHeightChange, popupHeight, setActiveSnapPoint, snapPoints, snapToSequentialPoints, swipeAreaActiveRef, swipeDirection]);
+  }), [resolvedActiveSnapPoint, frontmostHeight, hasNestedDrawer, nestedSwiping, nestedSwipeProgressStore, notifyParentHasNestedDrawer, notifyParentSwipeProgressChange, notifyParentSwipingChange, notifyParentFrontmostHeight, onNestedDrawerPresenceChange, onNestedFrontmostHeightChange, onNestedSwipeProgressChange, onNestedSwipingChange, onPopupHeightChange, popupHeight, setActiveSnapPoint, snapPoints, snapToSequentialPoints, swipeDirection]);
   const resolvedChildren = typeof children === 'function' ? payload => /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
     children: [_DrawerProviderReport || (_DrawerProviderReport = /*#__PURE__*/jsxRuntime.jsx(DrawerProviderReporter, {})), children(payload)]
   }) : /*#__PURE__*/jsxRuntime.jsxs(React__namespace.Fragment, {
     children: [_DrawerProviderReport2 || (_DrawerProviderReport2 = /*#__PURE__*/jsxRuntime.jsx(DrawerProviderReporter, {})), children]
   });
-  const dialog = useRenderDialogRoot('drawer', {
-    open: openProp,
-    defaultOpen,
-    onOpenChange: handleOpenChange,
-    onOpenChangeComplete,
-    disablePointerDismissal,
-    modal,
-    actionsRef,
-    handle,
-    triggerId: triggerIdProp,
-    defaultTriggerId: defaultTriggerIdProp,
-    children: resolvedChildren
-  });
   return /*#__PURE__*/jsxRuntime.jsx(DrawerRootContext.Provider, {
     value: contextValue,
-    children: dialog
+    children: /*#__PURE__*/jsxRuntime.jsx(IsDrawerContext.Provider, {
+      value: true,
+      children: /*#__PURE__*/jsxRuntime.jsx(DialogRoot, {
+        open: openProp,
+        defaultOpen: defaultOpen,
+        onOpenChange: handleOpenChange,
+        onOpenChangeComplete: onOpenChangeComplete,
+        disablePointerDismissal: disablePointerDismissal,
+        modal: modal,
+        actionsRef: actionsRef,
+        handle: handle,
+        triggerId: triggerIdProp,
+        defaultTriggerId: defaultTriggerIdProp,
+        children: resolvedChildren
+      })
+    })
   });
 }
 function createNestedSwipeProgressStore() {
@@ -1454,32 +1475,36 @@ function createNestedSwipeProgressStore() {
   };
 }
 function DrawerProviderReporter() {
+  const drawerId = useScrollLock.useId();
   const providerContext = useDrawerProviderContext();
-  const store = useDialogRootContext(false);
-  const setDrawerOpen = providerContext?.setDrawerOpen;
-  const removeDrawer = providerContext?.removeDrawer;
+  const {
+    store
+  } = useDialogRootContext(false);
   const open = store.useState('open');
   const nestedOpenDialogCount = store.useState('nestedOpenDialogCount');
   const popupElement = store.useState('popupElement');
   const isTopmost = nestedOpenDialogCount === 0;
-  useScrollLock.useIsoLayoutEffect(() => {
-    if (!removeDrawer) {
+  React__namespace.useEffect(() => {
+    if (!providerContext || drawerId == null) {
       return undefined;
     }
     return () => {
-      removeDrawer(store);
+      providerContext.removeDrawer(drawerId);
     };
-  }, [removeDrawer, store]);
-  useScrollLock.useIsoLayoutEffect(() => {
-    setDrawerOpen?.(store, open);
-  }, [open, setDrawerOpen, store]);
+  }, [drawerId, providerContext]);
+  React__namespace.useEffect(() => {
+    if (drawerId == null) {
+      return;
+    }
+    providerContext?.setDrawerOpen(drawerId, open);
+  }, [drawerId, open, providerContext]);
   React__namespace.useEffect(() => {
     // CloseWatcher enables the Android back gesture (Chromium-only).
     // Keep this Android-only for now to avoid interfering with Escape/nesting semantics on desktop due to `useDismiss`.
     if (!open || !isTopmost || !useScrollLock.android) {
       return undefined;
     }
-    const win = useScrollLock.getWindow(popupElement);
+    const win = floatingUi_utils.getWindow(popupElement);
     const CloseWatcherCtor = win.CloseWatcher;
     if (!CloseWatcherCtor) {
       return undefined;
@@ -1500,11 +1525,53 @@ function DrawerProviderReporter() {
   return null;
 }
 
-// `Document.elementFromPoint` retargets shadow content to the shadow host, which then fails
-// `contains()` checks against a popup inside that shadow root, so callers pass `getRootNode()`
-// (a document or a shadow root) rather than `ownerDocument()`.
-function getElementAtPoint(root, x, y) {
-  return typeof root?.elementFromPoint === 'function' ? root.elementFromPoint(x, y) : null;
+function isScrollable(element, axis,
+// When true, a container that overflows only once extra space is added (e.g. drawer
+// keyboard scroll slack) still counts, as long as it has layout size on the axis.
+allowOverflowIntent = false) {
+  const style = floatingUi_utils.getComputedStyle(element);
+  if (axis === 'vertical') {
+    const overflowY = style.overflowY;
+    if (overflowY !== 'auto' && overflowY !== 'scroll') {
+      return false;
+    }
+    return allowOverflowIntent ? element.clientHeight > 0 : element.scrollHeight > element.clientHeight;
+  }
+  const overflowX = style.overflowX;
+  if (overflowX !== 'auto' && overflowX !== 'scroll') {
+    return false;
+  }
+  return allowOverflowIntent ? element.clientWidth > 0 : element.scrollWidth > element.clientWidth;
+}
+function hasScrollableAncestor(target, root, axes) {
+  // `getParentNode` crosses shadow boundaries (and slots), so a target inside a shadow root
+  // still walks up to scrollable ancestors in the light DOM.
+  let node = target;
+  while (floatingUi_utils.isHTMLElement(node) && node !== root && !floatingUi_utils.isLastTraversableNode(node)) {
+    for (const axis of axes) {
+      if (isScrollable(node, axis)) {
+        return true;
+      }
+    }
+    node = floatingUi_utils.getParentNode(node);
+  }
+  return false;
+}
+function findScrollableTouchTarget(target, root, axis = 'vertical', allowOverflowIntent = false) {
+  // `getParentNode` crosses shadow boundaries (and slots), so a target inside a shadow root
+  // still reaches a scrollable ancestor in the light DOM.
+  let node = floatingUi_utils.isHTMLElement(target) ? target : null;
+  while (floatingUi_utils.isHTMLElement(node) && node !== root && !floatingUi_utils.isLastTraversableNode(node)) {
+    if (isScrollable(node, axis, allowOverflowIntent)) {
+      return node;
+    }
+    node = floatingUi_utils.getParentNode(node);
+  }
+  return isScrollable(root, axis, allowOverflowIntent) ? root : null;
+}
+
+function getElementAtPoint(doc, x, y) {
+  return typeof doc?.elementFromPoint === 'function' ? doc.elementFromPoint(x, y) : null;
 }
 
 const DEFAULT_SWIPE_THRESHOLD = 40;
@@ -1529,7 +1596,7 @@ function getDisplacement(direction, deltaX, deltaY) {
   }
 }
 function getElementTransform(element) {
-  const computedStyle = useScrollLock.getWindow(element).getComputedStyle(element);
+  const computedStyle = floatingUi_utils.getWindow(element).getComputedStyle(element);
   const transform = computedStyle.transform;
   let translateX = 0;
   let translateY = 0;
@@ -1651,7 +1718,6 @@ function useSwipeDismiss(options) {
   });
   const swipeProgressRef = React__namespace.useRef(0);
   const swipeThresholdRef = React__namespace.useRef(swipeThresholdDefault);
-  const swipeThresholdFunctionRef = React__namespace.useRef(null);
   const swipeStartTimeRef = React__namespace.useRef(null);
   const lastDragSampleRef = React__namespace.useRef(null);
   const lastDragVelocityRef = React__namespace.useRef({
@@ -1673,12 +1739,15 @@ function useSwipeDismiss(options) {
     if (!direction) {
       return;
     }
+    if (typeof swipeThresholdProp !== 'function') {
+      swipeThresholdRef.current = swipeThresholdDefault;
+      return;
+    }
     const element = elementRef.current;
-    const thresholdFunction = swipeThresholdFunctionRef.current;
-    if (!element || !thresholdFunction) {
+    if (!element) {
       return;
     }
-    const value = thresholdFunction({
+    const value = swipeThresholdProp({
       element,
       direction
     });
@@ -1756,7 +1825,6 @@ function useSwipeDismiss(options) {
     setDragDismissed(false);
     updateSwipeProgress(0);
     swipeThresholdRef.current = swipeThresholdDefault;
-    swipeThresholdFunctionRef.current = null;
     dragStartPosRef.current = {
       x: 0,
       y: 0
@@ -1797,6 +1865,11 @@ function useSwipeDismiss(options) {
     lastProgressDetailsRef.current = null;
     syncDragStyles(false);
   }, [setSwiping, swipeThresholdDefault, syncDragStyles, updateSwipeProgress]);
+  React__namespace.useEffect(() => {
+    if (typeof swipeThresholdProp !== 'function') {
+      swipeThresholdRef.current = swipeThresholdDefault;
+    }
+  }, [swipeThresholdDefault, swipeThresholdProp]);
   function getPrimaryPointerPosition(event) {
     if ('touches' in event) {
       const touch = event.touches[0];
@@ -1817,19 +1890,19 @@ function useSwipeDismiss(options) {
     return event.pointerType === 'touch';
   }
   function getTargetAtPoint(position, nativeEvent) {
-    const root = elementRef.current?.getRootNode();
-    const elementAtPoint = getElementAtPoint(root, position.x, position.y);
+    const doc = useScrollLock.ownerDocument(elementRef.current);
+    const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
     const target = elementAtPoint ?? useScrollLock.getTarget(nativeEvent);
     return target;
   }
   function findGestureScrollableTouchTarget(target, root) {
     if (hasHorizontal && !hasVertical) {
-      return scrollable.findScrollableTouchTarget(target, root, 'horizontal');
+      return findScrollableTouchTarget(target, root, 'horizontal');
     }
     if (hasVertical && !hasHorizontal) {
-      return scrollable.findScrollableTouchTarget(target, root, 'vertical');
+      return findScrollableTouchTarget(target, root, 'vertical');
     }
-    return scrollable.findScrollableTouchTarget(target, root, 'vertical') ?? scrollable.findScrollableTouchTarget(target, root, 'horizontal');
+    return findScrollableTouchTarget(target, root, 'vertical') ?? findScrollableTouchTarget(target, root, 'horizontal');
   }
   function startSwipeAtPosition(event, position, startOptions) {
     swipeFromScrollableRef.current = false;
@@ -1850,7 +1923,7 @@ function useSwipeDismiss(options) {
     const element = elementRef.current;
     if (ignoreScrollableAncestors && element && target && scrollAxes.length > 0) {
       const ignoreAncestors = startOptions?.ignoreScrollableAncestors ?? false;
-      if (!ignoreAncestors && scrollable.hasScrollableAncestor(target, element, scrollAxes)) {
+      if (!ignoreAncestors && hasScrollableAncestor(target, element, scrollAxes)) {
         return false;
       }
     }
@@ -1861,8 +1934,6 @@ function useSwipeDismiss(options) {
     swipeStartTimeRef.current = getValidTimeStamp(event.timeStamp);
     swipeCancelBaselineRef.current = position;
     lastMovePosRef.current = position;
-    swipeThresholdRef.current = swipeThresholdDefault;
-    swipeThresholdFunctionRef.current = typeof swipeThresholdProp === 'function' ? swipeThresholdProp : null;
     if (element) {
       elementSizeRef.current = {
         width: element.offsetWidth,
@@ -1927,9 +1998,12 @@ function useSwipeDismiss(options) {
     onCancel?.(event.nativeEvent);
   }
   function applyDirectionalDamping(deltaX, deltaY) {
-    const exponent = value => Math.sign(value) * Math.abs(value) ** 0.5;
+    const exponent = value => value >= 0 ? value ** 0.5 : -(Math.abs(value) ** 0.5);
     const dampAxis = (delta, allowNegative, allowPositive) => {
-      if (!allowNegative && delta < 0 || !allowPositive && delta > 0) {
+      if (!allowNegative && delta < 0) {
+        return exponent(delta);
+      }
+      if (!allowPositive && delta > 0) {
         return exponent(delta);
       }
       return delta;
@@ -1942,16 +2016,29 @@ function useSwipeDismiss(options) {
     };
   }
   function canSwipeFromScrollEdgeOnPendingMove(scrollTarget, deltaX, deltaY) {
-    // Swiping toward the axis start edge (down/right) is allowed when scrolled to the start;
-    // toward the end edge (up/left) when scrolled to the end.
-    const canSwipeOnAxis = (delta, scrollOffset, maxScrollOffset, allowTowardStart, allowTowardEnd) => delta > 0 && scrollOffset <= 0 && allowTowardStart || delta < 0 && scrollOffset >= Math.max(0, maxScrollOffset) && allowTowardEnd;
     const absDeltaX = Math.abs(deltaX);
     const absDeltaY = Math.abs(deltaY);
-    if (hasVertical && deltaY !== 0 && (!hasHorizontal || absDeltaY >= absDeltaX)) {
-      return canSwipeOnAxis(deltaY, scrollTarget.scrollTop, scrollTarget.scrollHeight - scrollTarget.clientHeight, allowDown, allowUp);
-    }
-    if (hasHorizontal && deltaX !== 0 && (!hasVertical || absDeltaX > absDeltaY)) {
-      return canSwipeOnAxis(deltaX, scrollTarget.scrollLeft, scrollTarget.scrollWidth - scrollTarget.clientWidth, allowRight, allowLeft);
+    const useVerticalAxis = hasVertical && deltaY !== 0 && (!hasHorizontal || absDeltaY >= absDeltaX);
+    if (useVerticalAxis) {
+      const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
+      const atTop = scrollTarget.scrollTop <= 0;
+      const atBottom = scrollTarget.scrollTop >= maxScrollTop;
+      const movingDown = deltaY > 0;
+      const movingUp = deltaY < 0;
+      const canSwipeDown = movingDown && atTop && allowDown;
+      const canSwipeUp = movingUp && atBottom && allowUp;
+      return canSwipeDown || canSwipeUp;
+    }
+    const useHorizontalAxis = hasHorizontal && deltaX !== 0 && (!hasVertical || absDeltaX > absDeltaY);
+    if (useHorizontalAxis) {
+      const maxScrollLeft = Math.max(0, scrollTarget.scrollWidth - scrollTarget.clientWidth);
+      const atLeft = scrollTarget.scrollLeft <= 0;
+      const atRight = scrollTarget.scrollLeft >= maxScrollLeft;
+      const movingRight = deltaX > 0;
+      const movingLeft = deltaX < 0;
+      const canSwipeRight = movingRight && atLeft && allowRight;
+      const canSwipeLeft = movingLeft && atRight && allowLeft;
+      return canSwipeRight || canSwipeLeft;
     }
     return null;
   }
@@ -1972,7 +2059,7 @@ function useSwipeDismiss(options) {
     pendingSwipeRef.current = true;
     pendingSwipeStartPosRef.current = startPos;
     swipeFromScrollableRef.current = false;
-    sawPrimaryButtonsOnMoveRef.current = !('touches' in event);
+    sawPrimaryButtonsOnMoveRef.current = false;
     const allowedToStart = canStart ? canStart(startPos, {
       nativeEvent: event.nativeEvent,
       direction: primaryDirection
@@ -2000,21 +2087,14 @@ function useSwipeDismiss(options) {
       event.preventDefault();
     }
     if (isFirstPointerMoveRef.current) {
-      isFirstPointerMoveRef.current = false;
-      // Reset the drag origin to the first move's position to absorb the gap between the press and
-      // the first move event — notably on iOS touch, where the first `touchmove` arrives already
-      // offset from the `touchstart` — which would otherwise make the dragged element jump. This
-      // only matters when an element follows the pointer; when `trackDrag` is false (e.g. the
-      // swipe-area, which only opens the drawer) keep the original press position so a quick flick
-      // still registers: on a low-refresh-rate display the whole travel can land in this single
-      // first move, and discarding it would drop the gesture.
-      if (trackDrag) {
-        dragStartPosRef.current = position;
-        const moveTime = getValidTimeStamp(event.timeStamp);
-        if (moveTime !== null) {
-          swipeStartTimeRef.current = moveTime;
-        }
+      // Adjust the starting position to the current position on the first move
+      // to account for the delay between pointerdown and the first pointermove on iOS.
+      dragStartPosRef.current = position;
+      const moveTime = getValidTimeStamp(event.timeStamp);
+      if (moveTime !== null) {
+        swipeStartTimeRef.current = moveTime;
       }
+      isFirstPointerMoveRef.current = false;
     }
     const clientX = position.x;
     const clientY = position.y;
@@ -2102,45 +2182,51 @@ function useSwipeDismiss(options) {
         newOffsetY += dampedDelta.y;
       }
     }
-
-    // Only rewrite drag styles when the drag offset actually changed. `syncDragStyles` writes the
-    // raw (undamped) frozen transform and movement vars, relying on the consumer's `onProgress`
-    // to overwrite them with damped styles — but `updateSwipeProgress` dedupes unchanged
-    // deltas and skips `onProgress`. A move that doesn't change the offset (e.g. the cursor
-    // pinned at a screen edge during an off-screen drag, jittering only on the ignored axis)
-    // would otherwise reinstate the raw styles with no correction, jumping the element to the
-    // undamped position.
-    const previousOffset = dragOffsetRef.current;
-    const offsetChanged = newOffsetX !== previousOffset.x || newOffsetY !== previousOffset.y;
     dragOffsetRef.current = {
       x: newOffsetX,
       y: newOffsetY
     };
-    if (offsetChanged) {
-      syncDragStyles(true);
-    }
+    syncDragStyles(true);
     recordDragSample({
       x: newOffsetX,
       y: newOffsetY
     }, getValidTimeStamp(event.timeStamp));
     const dragDeltaX = newOffsetX - initialTransformRef.current.x;
     const dragDeltaY = newOffsetY - initialTransformRef.current.y;
-    const progressDetails = {
-      deltaX: dragDeltaX,
-      deltaY: dragDeltaY,
-      direction: intendedSwipeDirectionRef.current
-    };
-    let progress = 0;
+    const swipeDirectionDetails = intendedSwipeDirectionRef.current;
     const progressDirection = primaryDirection ?? intendedSwipeDirectionRef.current;
-    if (progressDirection) {
-      const size = progressDirection === 'left' || progressDirection === 'right' ? elementSizeRef.current.width : elementSizeRef.current.height;
-      const scale = initialTransformRef.current.scale || 1;
-      const progressDisplacement = getDisplacement(progressDirection, dragDeltaX, dragDeltaY);
-      if (size > 0 && scale > 0 && progressDisplacement > 0) {
-        progress = progressDisplacement / (size * scale);
-      }
+    if (!progressDirection) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
     }
-    updateSwipeProgress(progress, progressDetails);
+    const size = progressDirection === 'left' || progressDirection === 'right' ? elementSizeRef.current.width : elementSizeRef.current.height;
+    const scale = initialTransformRef.current.scale || 1;
+    if (size <= 0 || scale <= 0) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
+    }
+    const progressDisplacement = getDisplacement(progressDirection, newOffsetX - initialTransformRef.current.x, newOffsetY - initialTransformRef.current.y);
+    if (progressDisplacement <= 0) {
+      updateSwipeProgress(0, {
+        deltaX: dragDeltaX,
+        deltaY: dragDeltaY,
+        direction: swipeDirectionDetails
+      });
+      return;
+    }
+    updateSwipeProgress(progressDisplacement / (size * scale), {
+      deltaX: dragDeltaX,
+      deltaY: dragDeltaY,
+      direction: swipeDirectionDetails
+    });
   }
   const handleEnd = useScrollLock.useStableCallback(event => {
     if (!enabled) {
@@ -2228,9 +2314,33 @@ function useSwipeDismiss(options) {
       dismissDirection = intendedSwipeDirectionRef.current ?? primaryDirection;
     } else {
       for (const direction of directions) {
-        if (getDisplacement(direction, deltaX, deltaY) > swipeThresholdRef.current) {
-          shouldClose = true;
-          dismissDirection = direction;
+        switch (direction) {
+          case 'right':
+            if (deltaX > swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'right';
+            }
+            break;
+          case 'left':
+            if (deltaX < -swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'left';
+            }
+            break;
+          case 'down':
+            if (deltaY > swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'down';
+            }
+            break;
+          case 'up':
+            if (deltaY < -swipeThresholdRef.current) {
+              shouldClose = true;
+              dismissDirection = 'up';
+            }
+            break;
+        }
+        if (shouldClose) {
           break;
         }
       }
@@ -2372,29 +2482,25 @@ function useSwipeDismiss(options) {
     });
   });
   const getDragStyles = React__namespace.useCallback(() => {
-    // Read `isSwipingRef`, not the lagging `isSwiping` state, to match the imperative writer
-    // `syncDragStyles`. Otherwise a render that commits before `setSwiping(true)` flushes strips the
-    // transform it just wrote, flashing the popup to its resting position for a frame.
-    const swiping = isSwipingRef.current;
     const dragOffset = dragOffsetRef.current;
     const initialTransform = initialTransformRef.current;
     const deltaX = dragOffset.x - initialTransform.x;
     const deltaY = dragOffset.y - initialTransform.y;
-    if (!swiping && deltaX === 0 && deltaY === 0 && !dragDismissed) {
+    if (!isSwiping && deltaX === 0 && deltaY === 0 && !dragDismissed) {
       return {
         [movementCssVars.x]: '0px',
         [movementCssVars.y]: '0px'
       };
     }
     return {
-      transition: swiping ? 'none' : undefined,
+      transition: isSwiping ? 'none' : undefined,
       // While swiping, freeze the element at its current visual transform so it doesn't snap to the
       // end position.
-      transform: swiping ? getDragTransform(dragOffset, initialTransform.scale) : undefined,
+      transform: isSwiping ? getDragTransform(dragOffset, initialTransform.scale) : undefined,
       [movementCssVars.x]: `${deltaX}px`,
       [movementCssVars.y]: `${deltaY}px`
     };
-  }, [dragDismissed, movementCssVars]);
+  }, [dragDismissed, isSwiping, movementCssVars]);
   const getPointerProps = React__namespace.useCallback(() => {
     if (!enabled) {
       return {};
@@ -2454,8 +2560,6 @@ const MIN_SWIPE_RELEASE_DURATION_MS = 80;
 const MAX_SWIPE_RELEASE_DURATION_MS = 360;
 const MIN_SWIPE_RELEASE_SCALAR = 0.1;
 const MAX_SWIPE_RELEASE_SCALAR = 1;
-const AXIS_LOCK_SLOP = 6;
-const AXIS_LOCK_BIAS = 2;
 const DRAWER_CONTENT_SELECTOR = `[${DRAWER_CONTENT_ATTRIBUTE}]`;
 /**
  * A positioning container for the drawer popup that can be made scrollable.
@@ -2471,7 +2575,9 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     children,
     ...elementProps
   } = props;
-  const store = useDialogRootContext();
+  const {
+    store
+  } = useDialogRootContext();
   const popupRef = store.context.popupRef;
   const backdropRef = store.context.backdropRef;
   const {
@@ -2479,8 +2585,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     notifyParentSwipingChange,
     notifyParentSwipeProgressChange,
     frontmostHeight,
-    snapToSequentialPoints,
-    swipeAreaActiveRef
+    snapToSequentialPoints
   } = useDrawerRootContext();
   const providerContext = useDrawerProviderContext();
   const {
@@ -2514,13 +2619,30 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
   const touchScrollStateRef = React__namespace.useRef(null);
   const virtualKeyboard = useDrawerVirtualKeyboardContext();
   const snapPointRange = React__namespace.useMemo(() => {
-    if (!snapPoints || snapPoints.length < 2 || resolvedSnapPoints.length < 2 || swipeDirection !== 'down' && swipeDirection !== 'up') {
+    if (!snapPoints || snapPoints.length < 2) {
+      return null;
+    }
+    if (swipeDirection !== 'down' && swipeDirection !== 'up') {
+      return null;
+    }
+    if (resolvedSnapPoints.length < 2) {
+      return null;
+    }
+    const offsets = resolvedSnapPoints.map(point => point.offset).filter(offset => Number.isFinite(offset)).sort((a, b) => a - b);
+    if (offsets.length < 2) {
       return null;
     }
-    const offsets = resolvedSnapPoints.map(point => point.offset).sort((a, b) => a - b);
     const minOffset = offsets[0];
     const nextOffset = offsets[1];
-    const range = nextOffset - minOffset;
+    const maxOffset = offsets[offsets.length - 1];
+    let range = nextOffset - minOffset;
+    if (!Number.isFinite(range) || range <= 0) {
+      const fallbackRange = maxOffset - minOffset;
+      if (!Number.isFinite(fallbackRange) || fallbackRange <= 0) {
+        return null;
+      }
+      range = fallbackRange;
+    }
     return {
       minOffset,
       range
@@ -2539,8 +2661,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     return [swipeDirection];
   }, [snapPoints, swipeDirection]);
   const setSwipeDismissed = useScrollLock.useStableCallback(dismissed => {
-    popupRef.current?.toggleAttribute(DrawerPopupDataAttributes.swipeDismiss, dismissed);
-    backdropRef.current?.toggleAttribute(DrawerPopupDataAttributes.swipeDismiss, dismissed);
+    setSwipeDismissedElements(popupRef.current, backdropRef.current, dismissed);
   });
   const clearSwipeRelease = useScrollLock.useStableCallback(() => {
     setSwipeDismissed(false);
@@ -2554,7 +2675,11 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     nestedSwipeActiveRef.current = false;
     notifyParentSwipingChange?.(false);
   });
-  const applySwipeProgress = useScrollLock.useStableCallback((resolvedProgress, shouldTrackProgress, notifyParent) => {
+  const applySwipeProgress = useScrollLock.useStableCallback(({
+    resolvedProgress,
+    shouldTrackProgress,
+    notifyParent
+  }) => {
     const isActive = open && !nested && shouldTrackProgress;
     const swipeProgress = isActive ? resolvedProgress : 0;
     const nestedSwipeProgress = open && shouldTrackProgress ? resolvedProgress : 0;
@@ -2572,48 +2697,78 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     if (!backdropElement) {
       return;
     }
-    const showProgress = isActive && swipeProgress > 0;
-    backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, showProgress ? `${swipeProgress}` : '0');
-    if (showProgress && frontmostHeight > 0) {
+    if (!isActive || swipeProgress <= 0) {
+      backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, '0');
+      backdropElement.style.removeProperty(DrawerPopupCssVars.height);
+      return;
+    }
+    backdropElement.style.setProperty(DrawerBackdropCssVars.swipeProgress, `${swipeProgress}`);
+    if (frontmostHeight > 0) {
       backdropElement.style.setProperty(DrawerPopupCssVars.height, `${frontmostHeight}px`);
     } else {
       backdropElement.style.removeProperty(DrawerPopupCssVars.height);
     }
   });
-  function resolveSwipeRelease(popupElement, direction, deltaX, deltaY, velocityX, velocityY, releaseVelocityX, releaseVelocityY) {
-    const size = getBaseSwipeSize(popupElement, direction);
-    if (size <= 0) {
+  function resolveSwipeRelease({
+    direction,
+    deltaX,
+    deltaY,
+    velocityX,
+    velocityY,
+    releaseVelocityX,
+    releaseVelocityY
+  }) {
+    if (!direction) {
       return null;
     }
-
-    // The snap point base offset shifts the popup along the dismiss direction for both
-    // `down` (+offset) and `up` (-offset), so it always adds to the directional translation.
-    const snapPointBaseOffset = (direction === 'down' || direction === 'up') && snapPoints && snapPoints.length > 0 ? activeSnapPointOffset ?? 0 : 0;
-    const translationAlongDirection = snapPointBaseOffset + getDisplacement(direction, deltaX, deltaY);
+    const popupElement = store.context.popupRef.current;
+    if (!popupElement) {
+      return null;
+    }
+    const size = direction === 'left' || direction === 'right' ? popupElement.offsetWidth : popupElement.offsetHeight;
+    if (!Number.isFinite(size) || size <= 0) {
+      return null;
+    }
+    const axisDelta = direction === 'left' || direction === 'right' ? deltaX : deltaY;
+    const snapPointBaseOffset = snapPoints && snapPoints.length > 0 ? activeSnapPointOffset ?? 0 : 0;
+    let baseOffset = 0;
+    if (direction === 'down') {
+      baseOffset = snapPointBaseOffset;
+    } else if (direction === 'up') {
+      baseOffset = -snapPointBaseOffset;
+    }
+    const translation = baseOffset + axisDelta;
+    const translationAlongDirection = direction === 'left' || direction === 'up' ? -translation : translation;
     const remainingDistance = Math.max(0, size - translationAlongDirection);
-    if (remainingDistance <= 0) {
+    if (!Number.isFinite(remainingDistance) || remainingDistance <= 0) {
       return null;
     }
-    const releaseVelocity = getDisplacement(direction, releaseVelocityX, releaseVelocityY);
-    const directionalVelocity = Math.abs(releaseVelocity) > 0 ? releaseVelocity : getDisplacement(direction, velocityX, velocityY);
-    if (directionalVelocity <= MIN_SWIPE_RELEASE_VELOCITY) {
+    const axisVelocity = direction === 'left' || direction === 'right' ? releaseVelocityX : releaseVelocityY;
+    const fallbackVelocity = direction === 'left' || direction === 'right' ? velocityX : velocityY;
+    const resolvedVelocity = Math.abs(axisVelocity) > 0 && Number.isFinite(axisVelocity) ? axisVelocity : fallbackVelocity;
+    const directionalVelocity = direction === 'left' || direction === 'up' ? -resolvedVelocity : resolvedVelocity;
+    if (!Number.isFinite(directionalVelocity) || directionalVelocity <= MIN_SWIPE_RELEASE_VELOCITY) {
       return null;
     }
     const clampedVelocity = scrollEdges.clamp(directionalVelocity, MIN_SWIPE_RELEASE_VELOCITY, MAX_SWIPE_RELEASE_VELOCITY);
-    // The gesture hook supplies finite deltas and velocities. The guards above keep the remaining
-    // distance and divisor positive, so the duration stays within [MIN, MAX] and the resulting
-    // scalar within (0, 1].
     const durationMs = scrollEdges.clamp(remainingDistance / clampedVelocity, MIN_SWIPE_RELEASE_DURATION_MS, MAX_SWIPE_RELEASE_DURATION_MS);
+    if (!Number.isFinite(durationMs)) {
+      return null;
+    }
     const normalizedDuration = (durationMs - MIN_SWIPE_RELEASE_DURATION_MS) / (MAX_SWIPE_RELEASE_DURATION_MS - MIN_SWIPE_RELEASE_DURATION_MS);
-    return MIN_SWIPE_RELEASE_SCALAR + normalizedDuration * (MAX_SWIPE_RELEASE_SCALAR - MIN_SWIPE_RELEASE_SCALAR);
+    const durationScalar = scrollEdges.clamp(MIN_SWIPE_RELEASE_SCALAR + normalizedDuration * (MAX_SWIPE_RELEASE_SCALAR - MIN_SWIPE_RELEASE_SCALAR), MIN_SWIPE_RELEASE_SCALAR, MAX_SWIPE_RELEASE_SCALAR);
+    if (!Number.isFinite(durationScalar) || durationScalar <= 0) {
+      return null;
+    }
+    return durationScalar;
   }
   function updateNestedSwipeActive(details) {
     if (nestedSwipeActiveRef.current || !details) {
       return;
     }
     const direction = details.direction ?? swipeDirection;
-    const delta = getDisplacement(direction, details.deltaX, details.deltaY);
-    if (Math.abs(delta) < MIN_SWIPE_THRESHOLD) {
+    const delta = direction === 'left' || direction === 'right' ? details.deltaX : details.deltaY;
+    if (!Number.isFinite(delta) || Math.abs(delta) < MIN_SWIPE_THRESHOLD) {
       return;
     }
     nestedSwipeActiveRef.current = true;
@@ -2630,17 +2785,20 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       y: DrawerPopupCssVars.swipeMovementY
     },
     onSwipeStart(event) {
-      if ('touches' in event || event.pointerType === 'touch') {
+      if ('touches' in event || 'pointerType' in event && event.pointerType === 'touch') {
         return;
       }
       const popupElement = popupRef.current;
+      if (!popupElement) {
+        return;
+      }
       const doc = useScrollLock.ownerDocument(popupElement);
       const selection = doc.getSelection?.();
       if (!selection || selection.isCollapsed) {
         return;
       }
-      const anchorElement = useScrollLock.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
-      const focusElement = useScrollLock.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+      const anchorElement = floatingUi_utils.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+      const focusElement = floatingUi_utils.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
       if (!useScrollLock.contains(popupElement, anchorElement) && !useScrollLock.contains(popupElement, focusElement)) {
         return;
       }
@@ -2665,38 +2823,54 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         return false;
       }
       const doc = popupElement.ownerDocument;
-      const elementAtPoint = getElementAtPoint(popupElement.getRootNode(), position.x, position.y);
+      const elementAtPoint = getElementAtPoint(doc, position.x, position.y);
       if (!elementAtPoint || !useScrollLock.contains(popupElement, elementAtPoint)) {
         return false;
       }
       const nativeEvent = details.nativeEvent;
-      const touchLike = 'touches' in nativeEvent || nativeEvent.pointerType === 'touch';
+      const touchLike = 'touches' in nativeEvent || 'pointerType' in nativeEvent && nativeEvent.pointerType === 'touch';
       if (touchLike && shouldIgnoreSwipeForTextSelection(doc, popupElement)) {
         return false;
       }
+      if (nativeEvent.type === 'touchstart' && isSwipeIgnoredTarget(elementAtPoint)) {
+        return false;
+      }
       return true;
     },
     onProgress(progress, details) {
       updateNestedSwipeActive(details);
       const hasSnapPoints = Boolean(snapPoints && snapPoints.length > 0);
-      if (swipingRef.current && swipeDirection === 'down' && hasSnapPoints && details) {
+      if (swipingRef.current && swipeDirection === 'down' && hasSnapPoints && details && Number.isFinite(details.deltaY)) {
         const popupElement = store.context.popupRef.current;
         if (popupElement) {
           popupElement.style.removeProperty('transform');
           popupElement.style.setProperty(DrawerPopupCssVars.swipeMovementY, `${getSnapPointSwipeMovement(activeSnapPointOffset ?? 0, details.deltaY)}px`);
         }
       }
+      const currentDirection = details?.direction ?? swipe.swipeDirection;
+      const isDismissSwipe = currentDirection === undefined || currentDirection === swipeDirection;
+      const isVerticalSwipe = swipeDirection === 'down' || swipeDirection === 'up';
+      const shouldTrackProgress = hasSnapPoints && isVerticalSwipe || !hasSnapPoints || swipeDirection === 'left' || swipeDirection === 'right' || isDismissSwipe;
       let resolvedProgress = progress;
       if (snapPointRange && popupHeight > 0) {
-        const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
-        const offsetToProgress = nextOffset => scrollEdges.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
         if (details && Number.isFinite(details.deltaY)) {
-          resolvedProgress = offsetToProgress(scrollEdges.clamp(baseOffset + details.deltaY, 0, popupHeight));
+          const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
+          const nextOffset = scrollEdges.clamp(baseOffset + details.deltaY, 0, popupHeight);
+          resolvedProgress = scrollEdges.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
         } else if (snapPointProgress !== null) {
           resolvedProgress = snapPointProgress;
+        } else if (currentDirection === 'down' || currentDirection === 'up') {
+          const displacement = progress * popupHeight;
+          const baseOffset = activeSnapPointOffset ?? snapPointRange.minOffset;
+          const nextOffset = currentDirection === 'down' ? baseOffset + displacement : baseOffset - displacement;
+          resolvedProgress = scrollEdges.clamp((nextOffset - snapPointRange.minOffset) / snapPointRange.range, 0, 1);
         }
       }
-      applySwipeProgress(resolvedProgress, true, true);
+      applySwipeProgress({
+        resolvedProgress,
+        shouldTrackProgress,
+        notifyParent: true
+      });
     },
     onRelease({
       event,
@@ -2708,21 +2882,30 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       releaseVelocityX,
       releaseVelocityY
     }) {
-      const popupElement = store.context.popupRef.current;
-      if (!popupElement) {
-        clearSwipeRelease();
-        return undefined;
-      }
-      const releasePopupElement = popupElement;
+      const swipeReleasePayload = {
+        deltaX,
+        deltaY,
+        velocityX,
+        velocityY,
+        releaseVelocityX,
+        releaseVelocityY
+      };
       function startSwipeRelease(resolvedDirection) {
         // Start ending transition styles earlier and synchronously to prevent a period where
         // the popup appears stuck on release before the actual closing animation starts.
+        const popupElement = store.context.popupRef.current;
+        if (!popupElement) {
+          return;
+        }
         finishNestedSwipe();
         setSwipeDismissed(true);
-        releasePopupElement.style.removeProperty('transition');
-        releasePopupElement.setAttribute(useScrollLock.TransitionStatusDataAttributes.endingStyle, '');
+        popupElement.style.removeProperty('transition');
+        popupElement.setAttribute(useScrollLock.TransitionStatusDataAttributes.endingStyle, '');
         ReactDOM__namespace.flushSync(() => {
-          setSwipeRelease(resolveSwipeRelease(releasePopupElement, resolvedDirection, deltaX, deltaY, velocityX, velocityY, releaseVelocityX, releaseVelocityY));
+          setSwipeRelease(resolveSwipeRelease({
+            direction: resolvedDirection,
+            ...swipeReleasePayload
+          }));
         });
       }
       if (!snapPoints || snapPoints.length === 0) {
@@ -2730,16 +2913,29 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
           clearSwipeRelease();
           return undefined;
         }
-        const directionalDelta = getDisplacement(direction, deltaX, deltaY);
+        const element = store.context.popupRef.current;
+        if (!element) {
+          clearSwipeRelease();
+          return undefined;
+        }
+        const baseThreshold = getBaseSwipeThreshold(element, direction);
+        const delta = direction === 'left' || direction === 'right' ? deltaX : deltaY;
+        if (!Number.isFinite(delta)) {
+          clearSwipeRelease();
+          return undefined;
+        }
+        const directionalDelta = direction === 'left' || direction === 'up' ? -delta : delta;
         if (directionalDelta <= 0) {
           clearSwipeRelease();
           return false;
         }
-        if (getDisplacement(direction, velocityX, velocityY) >= FAST_SWIPE_VELOCITY) {
+        const velocity = direction === 'left' || direction === 'right' ? velocityX : velocityY;
+        const directionalVelocity = direction === 'left' || direction === 'up' ? -velocity : velocity;
+        if (directionalVelocity >= FAST_SWIPE_VELOCITY && directionalDelta > 0) {
           startSwipeRelease(direction);
           return true;
         }
-        const shouldClose = directionalDelta > getBaseSwipeThreshold(releasePopupElement, direction);
+        const shouldClose = directionalDelta > baseThreshold;
         if (shouldClose) {
           startSwipeRelease(direction);
         } else {
@@ -2751,20 +2947,20 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         clearSwipeRelease();
         return undefined;
       }
-      if (!popupHeight) {
+      if (!popupHeight || resolvedSnapPoints.length === 0) {
         clearSwipeRelease();
-        return false;
+        return undefined;
       }
-      if (resolvedSnapPoints.length === 0) {
+      const dragDelta = swipeDirection === 'down' ? deltaY : -deltaY;
+      if (!Number.isFinite(dragDelta)) {
         clearSwipeRelease();
         return undefined;
       }
-      const dragDelta = swipeDirection === 'down' ? deltaY : -deltaY;
       const dragDirection = Math.sign(dragDelta);
       const releaseDirectionalVelocity = swipeDirection === 'down' ? releaseVelocityY : -releaseVelocityY;
       const fallbackDirectionalVelocity = swipeDirection === 'down' ? velocityY : -velocityY;
-      let resolvedDirectionalVelocity = releaseDirectionalVelocity;
-      if (dragDirection !== 0 && Math.abs(dragDelta) >= MIN_SWIPE_THRESHOLD) {
+      let resolvedDirectionalVelocity = Number.isFinite(releaseDirectionalVelocity) ? releaseDirectionalVelocity : fallbackDirectionalVelocity;
+      if (dragDirection !== 0 && Math.abs(dragDelta) >= MIN_SWIPE_THRESHOLD && Number.isFinite(resolvedDirectionalVelocity)) {
         const velocityDirection = Math.sign(resolvedDirectionalVelocity);
         if (velocityDirection !== 0 && velocityDirection !== dragDirection) {
           // Ignore touch reversals that would otherwise flip the snap decision.
@@ -2773,20 +2969,39 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       }
       const currentOffset = activeSnapPointOffset ?? 0;
       const dragTargetOffset = scrollEdges.clamp(currentOffset + dragDelta, 0, popupHeight);
-      const velocityOffset = Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? scrollEdges.clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
+      const velocityOffset = Number.isFinite(resolvedDirectionalVelocity) && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD ? scrollEdges.clamp(resolvedDirectionalVelocity, -MAX_SNAP_VELOCITY, MAX_SNAP_VELOCITY) * SNAP_VELOCITY_MULTIPLIER : 0;
       const targetOffset = snapToSequentialPoints ? dragTargetOffset : scrollEdges.clamp(dragTargetOffset + velocityOffset, 0, popupHeight);
       const snapPointEventDetails = useScrollLock.createChangeEventDetails(useScrollLock.swipe, event);
       const closeFromSnapPoints = () => {
         pendingSwipeCloseSnapPointRef.current = activeSnapPoint;
-        setActiveSnapPoint(null, snapPointEventDetails);
+        setActiveSnapPoint?.(null, snapPointEventDetails);
         startSwipeRelease(swipeDirection);
         return true;
       };
       if (snapToSequentialPoints) {
         const orderedSnapPoints = [...resolvedSnapPoints].sort((first, second) => first.offset - second.offset);
-        const orderedOffsets = orderedSnapPoints.map(point => point.offset);
-        const currentIndex = closestSnapPointIndex(orderedOffsets, currentOffset);
-        let targetSnapPoint = orderedSnapPoints[closestSnapPointIndex(orderedOffsets, targetOffset)];
+        if (orderedSnapPoints.length === 0) {
+          clearSwipeRelease();
+          return false;
+        }
+        let currentIndex = 0;
+        let closestDistance = Math.abs(currentOffset - orderedSnapPoints[0].offset);
+        for (let index = 1; index < orderedSnapPoints.length; index += 1) {
+          const distance = Math.abs(currentOffset - orderedSnapPoints[index].offset);
+          if (distance < closestDistance) {
+            closestDistance = distance;
+            currentIndex = index;
+          }
+        }
+        let targetSnapPoint = orderedSnapPoints[0];
+        closestDistance = Math.abs(targetOffset - targetSnapPoint.offset);
+        for (const snapPoint of orderedSnapPoints) {
+          const distance = Math.abs(targetOffset - snapPoint.offset);
+          if (distance < closestDistance) {
+            closestDistance = distance;
+            targetSnapPoint = snapPoint;
+          }
+        }
         const velocityDirection = Math.sign(resolvedDirectionalVelocity);
         const shouldAdvance = dragDirection !== 0 && velocityDirection !== 0 && velocityDirection === dragDirection && Math.abs(resolvedDirectionalVelocity) >= SNAP_VELOCITY_THRESHOLD;
         let effectiveTargetOffset = targetOffset;
@@ -2803,24 +3018,34 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
             return closeFromSnapPoints();
           }
         }
-        const closeDistance = Math.abs(effectiveTargetOffset - popupHeight);
+        const closeOffset = popupHeight;
+        const closeDistance = Math.abs(effectiveTargetOffset - closeOffset);
         const snapDistance = Math.abs(effectiveTargetOffset - targetSnapPoint.offset);
         if (closeDistance < snapDistance) {
           return closeFromSnapPoints();
         }
-        setActiveSnapPoint(targetSnapPoint.value, snapPointEventDetails);
+        setActiveSnapPoint?.(targetSnapPoint.value, snapPointEventDetails);
         clearSwipeRelease();
         return false;
       }
       if (resolvedDirectionalVelocity >= FAST_SWIPE_VELOCITY && dragDelta > 0) {
         return closeFromSnapPoints();
       }
-      const closestSnapPoint = resolvedSnapPoints[closestSnapPointIndex(resolvedSnapPoints.map(point => point.offset), targetOffset)];
-      const closeDistance = Math.abs(targetOffset - popupHeight);
-      if (closeDistance < Math.abs(targetOffset - closestSnapPoint.offset)) {
+      let closestSnapPoint = resolvedSnapPoints[0];
+      let closestDistance = Math.abs(targetOffset - closestSnapPoint.offset);
+      for (const snapPoint of resolvedSnapPoints) {
+        const distance = Math.abs(targetOffset - snapPoint.offset);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestSnapPoint = snapPoint;
+        }
+      }
+      const closeOffset = popupHeight;
+      const closeDistance = Math.abs(targetOffset - closeOffset);
+      if (closeDistance < closestDistance) {
         return closeFromSnapPoints();
       }
-      setActiveSnapPoint(closestSnapPoint.value, snapPointEventDetails);
+      setActiveSnapPoint?.(closestSnapPoint.value, snapPointEventDetails);
       clearSwipeRelease();
       return false;
     },
@@ -2839,7 +3064,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       if (dismissEventDetails.isCanceled) {
         const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
         if (pendingSnapPoint !== undefined) {
-          setActiveSnapPoint(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event));
+          setActiveSnapPoint?.(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, event));
         }
         pendingSwipeCloseSnapPointRef.current = undefined;
         resetSwipeRef.current?.();
@@ -2861,7 +3086,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
             // Parent rejected: revert animation and restore snap point.
             const pendingSnapPoint = pendingSwipeCloseSnapPointRef.current;
             if (pendingSnapPoint !== undefined) {
-              setActiveSnapPoint(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, savedEvent));
+              setActiveSnapPoint?.(pendingSnapPoint, useScrollLock.createChangeEventDetails(useScrollLock.swipe, savedEvent));
             }
             pendingSwipeCloseSnapPointRef.current = undefined;
             clearSwipeRelease();
@@ -2891,18 +3116,42 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     }
     const resolvedRootElement = rootElement;
     const doc = useScrollLock.ownerDocument(resolvedRootElement);
-    function processTouchMove(event, touchState, touch) {
+    const win = floatingUi_utils.getWindow(doc);
+    function handleNativeTouchMove(event) {
+      // The virtual keyboard provider observes the move to tell a tap apart from a drag.
+      // It must run even when the swipe gesture below claims the event with
+      // `stopPropagation()`, which would otherwise prevent React's delegated handlers
+      // (and the provider) from ever seeing the move.
+      virtualKeyboard?.onTouchMove(event);
+      if (ignoreTouchSwipeRef.current) {
+        return;
+      }
+      const touchState = touchScrollStateRef.current;
+      const touch = event.touches[0];
+      if (!touch || !touchState) {
+        return;
+      }
       const drawerAxisDelta = isVerticalScrollAxis ? touch.clientY - touchState.lastY : touch.clientX - touchState.lastX;
 
+      // Preserve native range interaction by never locking touchmove for range inputs.
+      if (isEventOnRangeInput(event, win)) {
+        touchState.allowSwipe = false;
+        updateTouchScrollPosition(touchState, touch);
+        return;
+      }
+
       // Avoid blocking pinch zoom or text selection adjustments on iOS Safari.
       if (event.touches.length === 2) {
+        updateTouchScrollPosition(touchState, touch);
         return;
       }
       const allowTouchMove = shouldIgnoreSwipeForTextSelection(doc, resolvedRootElement);
       if (allowTouchMove || !open || !mounted || nestedDrawerOpen) {
+        updateTouchScrollPosition(touchState, touch);
         return;
       }
-      if (shouldYieldTouchMove(touchState, event, touch, isVerticalScrollAxis)) {
+      if (preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis)) {
+        updateTouchScrollPosition(touchState, touch);
         return;
       }
       const scrollTarget = touchState.scrollTarget;
@@ -2914,21 +3163,27 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         // move through React re-rasterizes the popup content on every frame.
         event.stopPropagation();
         moveSwipeNative(event, resolvedRootElement);
+        updateTouchScrollPosition(touchState, touch);
         return;
       }
-      if (!hasScrollableContentOnAxis(scrollTarget, scrollAxis)) {
+      const hasScrollableContent = hasScrollableContentOnAxis(scrollTarget, scrollAxis);
+      if (!hasScrollableContent) {
         // If the scroll container doesn't overflow on the drawer axis, prevent the window from
         // scrolling instead.
         if (event.cancelable) {
           event.preventDefault();
         }
         event.stopPropagation();
+        updateTouchScrollPosition(touchState, touch);
         return;
       }
-      if (drawerAxisDelta !== 0) {
-        const canSwipeFromScrollEdge = canSwipeFromScrollEdgeOnMove(scrollTarget, scrollAxis, swipeDirection, drawerAxisDelta);
+      const delta = drawerAxisDelta;
+      if (delta !== 0) {
+        const canSwipeFromScrollEdge = canSwipeFromScrollEdgeOnMove(scrollTarget, scrollAxis, swipeDirection, delta);
         if (!touchState.allowSwipe) {
-          if (event.cancelable && canSwipeFromScrollEdge) {
+          if (!event.cancelable) {
+            touchState.allowSwipe = false;
+          } else if (canSwipeFromScrollEdge) {
             touchState.allowSwipe = true;
             event.preventDefault();
           } else {
@@ -2942,22 +3197,6 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         event.stopPropagation();
         moveSwipeNative(event, resolvedRootElement);
       }
-    }
-    function handleNativeTouchMove(event) {
-      // The virtual keyboard provider observes the move to tell a tap apart from a drag.
-      // It must run even when the swipe gesture below claims the event with
-      // `stopPropagation()`, which would otherwise prevent React's delegated handlers
-      // (and the provider) from ever seeing the move.
-      virtualKeyboard?.onTouchMove(event);
-      if (ignoreTouchSwipeRef.current) {
-        return;
-      }
-      const touchState = touchScrollStateRef.current;
-      const touch = event.touches[0];
-      if (!touch || !touchState) {
-        return;
-      }
-      processTouchMove(event, touchState, touch);
       updateTouchScrollPosition(touchState, touch);
     }
     return useScrollLock.addEventListener(doc, 'touchmove', handleNativeTouchMove, {
@@ -2965,13 +3204,18 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       capture: true
     });
   }, [mounted, nestedDrawerOpen, open, popupElementState, isVerticalScrollAxis, scrollAxis, swipeDirection, moveSwipeNative, viewportElement, virtualKeyboard]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (!snapPointRange || swipe.swiping) {
       return;
     }
-    applySwipeProgress(!open || nested ? 0 : snapPointProgress ?? 0, true, false);
+    const resolvedProgress = !open || nested ? 0 : snapPointProgress ?? 0;
+    applySwipeProgress({
+      resolvedProgress,
+      shouldTrackProgress: true,
+      notifyParent: false
+    });
   }, [applySwipeProgress, frontmostHeight, nested, notifyParentSwipeProgressChange, open, snapPointProgress, snapPointRange, swipe.swiping, store, visualStateStore]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (!notifyParentSwipeProgressChange) {
       return undefined;
     }
@@ -2982,19 +3226,13 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
       notifyParentSwipeProgressChange(0);
     };
   }, [notifyParentSwipeProgressChange, open]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  React__namespace.useEffect(() => {
     if (open) {
-      // Skip `resetSwipe` while `Drawer.SwipeArea` is driving the open: it zeroes the popup's
-      // `--swipe-movement-*` (via `syncDragStyles(false)`), flashing it fully open for a frame.
-      // `clearSwipeRelease` doesn't touch those vars, so always run it to clear any leftover
-      // release state from a prior dismiss (e.g. when the popup is kept mounted).
-      if (!swipeAreaActiveRef.current) {
-        resetSwipe();
-      }
+      resetSwipe();
       clearSwipeRelease();
     }
-  }, [clearSwipeRelease, open, resetSwipe, swipeAreaActiveRef]);
-  useScrollLock.useIsoLayoutEffect(() => {
+  }, [clearSwipeRelease, open, resetSwipe]);
+  React__namespace.useEffect(() => {
     const backdropElement = backdropRef.current;
     return () => {
       visualStateStore?.set({
@@ -3019,19 +3257,12 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
     swipeStrength: swipeRelease ?? null,
     setSwipeDismissed
   }), [setSwipeDismissed, swipe.getDragStyles, swipe.swiping, swipeRelease]);
-  function resetTouchSwipeState(ignoreSwipe) {
-    ignoreTouchSwipeRef.current = ignoreSwipe;
-    touchScrollStateRef.current = null;
-  }
   function resetTouchTrackingState() {
-    resetTouchSwipeState(false);
+    ignoreTouchSwipeRef.current = false;
+    touchScrollStateRef.current = null;
     lastPointerTypeRef.current = '';
     ignoreNextTouchStartFromPenRef.current = false;
   }
-  function handlePointerEnd(event) {
-    lastPointerTypeRef.current = '';
-    return event.pointerType !== 'touch';
-  }
   return /*#__PURE__*/jsxRuntime.jsx(DialogViewport, {
     ref: forwardedRef,
     className: className,
@@ -3044,7 +3275,8 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         if (!open || !mounted || nestedDrawerOpen) {
           return;
         }
-        const elementAtPoint = getElementAtPoint(event.currentTarget.getRootNode(), event.clientX, event.clientY);
+        const doc = useScrollLock.ownerDocument(event.currentTarget);
+        const elementAtPoint = getElementAtPoint(doc, event.clientX, event.clientY);
         if (isSwipeIgnoredTarget(elementAtPoint) || isDrawerContentTarget(elementAtPoint)) {
           return;
         }
@@ -3060,24 +3292,34 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
         swipePointerProps.onPointerMove?.(event);
       },
       onPointerUp(event) {
-        if (handlePointerEnd(event)) {
-          swipePointerProps.onPointerUp?.(event);
+        if (lastPointerTypeRef.current === event.pointerType) {
+          lastPointerTypeRef.current = '';
+        }
+        if (event.pointerType === 'touch') {
+          return;
         }
+        swipePointerProps.onPointerUp?.(event);
       },
       onPointerCancel(event) {
-        if (handlePointerEnd(event)) {
-          swipePointerProps.onPointerCancel?.(event);
+        if (lastPointerTypeRef.current === event.pointerType) {
+          lastPointerTypeRef.current = '';
+        }
+        if (event.pointerType === 'touch') {
+          return;
         }
+        swipePointerProps.onPointerCancel?.(event);
       },
       onTouchStart(event) {
         const startedFromPenPointerDown = lastPointerTypeRef.current === 'pen' && ignoreNextTouchStartFromPenRef.current;
         if (startedFromPenPointerDown) {
           ignoreNextTouchStartFromPenRef.current = false;
-          resetTouchSwipeState(false);
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
           return;
         }
         if (!open || !mounted || nestedDrawerOpen) {
-          resetTouchSwipeState(false);
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
           return;
         }
         const touch = event.touches[0];
@@ -3085,25 +3327,32 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
           return;
         }
         if (isReactTouchEventOnRangeInput(event)) {
-          resetTouchSwipeState(false);
+          ignoreTouchSwipeRef.current = false;
+          touchScrollStateRef.current = null;
           return;
         }
-        const rootElement = event.currentTarget;
-        const elementAtPoint = getElementAtPoint(rootElement.getRootNode(), touch.clientX, touch.clientY);
+        const doc = useScrollLock.ownerDocument(event.currentTarget);
+        const elementAtPoint = getElementAtPoint(doc, touch.clientX, touch.clientY);
+        const rootElement = viewportElement ?? popupElementState;
         const eventTarget = useScrollLock.getTarget(event.nativeEvent);
-        const target = useScrollLock.isElement(eventTarget) ? eventTarget : rootElement;
-        if (!useScrollLock.contains(rootElement, target)) {
-          resetTouchSwipeState(true);
+        const target = floatingUi_utils.isElement(eventTarget) ? eventTarget : null;
+        if (rootElement && target && !useScrollLock.contains(rootElement, target)) {
+          ignoreTouchSwipeRef.current = true;
+          touchScrollStateRef.current = null;
           return;
         }
         virtualKeyboard?.onTouchStart(event);
-        if (isSwipeIgnoredTarget(elementAtPoint)) {
-          resetTouchSwipeState(true);
+        ignoreTouchSwipeRef.current = isSwipeIgnoredTarget(elementAtPoint);
+        if (ignoreTouchSwipeRef.current) {
+          touchScrollStateRef.current = null;
           return;
         }
-        ignoreTouchSwipeRef.current = false;
-        const scrollTarget = scrollable.findScrollableTouchTarget(target, rootElement, scrollAxis);
-        const hasCrossAxisScrollableContent = scrollable.findScrollableTouchTarget(target, rootElement, crossScrollAxis) != null;
+        let scrollTarget = null;
+        let hasCrossAxisScrollableContent = false;
+        if (rootElement && target) {
+          scrollTarget = findScrollableTouchTarget(target, rootElement, scrollAxis);
+          hasCrossAxisScrollableContent = findScrollableTouchTarget(target, rootElement, crossScrollAxis) != null;
+        }
         let allowSwipe = null;
         if (scrollTarget) {
           const canSwipeFromEdge = isAtSwipeStartEdge(scrollTarget, scrollAxis, swipeDirection);
@@ -3117,8 +3366,7 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
           scrollTarget,
           hasCrossAxisScrollableContent,
           allowSwipe,
-          preserveNativeCrossAxisScroll: false,
-          drawerAxisAttributed: false
+          preserveNativeCrossAxisScroll: false
         };
         swipeTouchProps.onTouchStart?.(event);
       },
@@ -3143,8 +3391,24 @@ const DrawerViewport = /*#__PURE__*/React__namespace.forwardRef(function DrawerV
   });
 });
 if (process.env.NODE_ENV !== "production") DrawerViewport.displayName = "DrawerViewport";
+function setSwipeDismissedElements(popupElement, backdropElement, dismissed) {
+  if (dismissed) {
+    popupElement?.setAttribute(DrawerPopupDataAttributes.swipeDismiss, '');
+    backdropElement?.setAttribute(DrawerPopupDataAttributes.swipeDismiss, '');
+    return;
+  }
+  popupElement?.removeAttribute(DrawerPopupDataAttributes.swipeDismiss);
+  backdropElement?.removeAttribute(DrawerPopupDataAttributes.swipeDismiss);
+}
 function setBackdropSwipingAttribute(backdropElement, swiping) {
-  backdropElement?.toggleAttribute(DrawerPopupDataAttributes.swiping, swiping);
+  if (!backdropElement) {
+    return;
+  }
+  if (swiping) {
+    backdropElement.setAttribute(DrawerPopupDataAttributes.swiping, '');
+    return;
+  }
+  backdropElement.removeAttribute(DrawerPopupDataAttributes.swiping);
 }
 function isSwipeIgnoredTarget(target) {
   return Boolean(target?.closest(useScrollLock.BASE_UI_SWIPE_IGNORE_SELECTOR));
@@ -3152,26 +3416,28 @@ function isSwipeIgnoredTarget(target) {
 function isDrawerContentTarget(target) {
   return Boolean(target?.closest(DRAWER_CONTENT_SELECTOR));
 }
-function getBaseSwipeSize(element, direction) {
-  return direction === 'left' || direction === 'right' ? element.offsetWidth : element.offsetHeight;
-}
 function getBaseSwipeThreshold(element, direction) {
-  return Math.max(getBaseSwipeSize(element, direction) * 0.5, MIN_SWIPE_THRESHOLD);
+  const size = direction === 'left' || direction === 'right' ? element.offsetWidth : element.offsetHeight;
+  return Math.max(size * 0.5, MIN_SWIPE_THRESHOLD);
 }
 function isRangeInput(target, win) {
   return target instanceof win.HTMLInputElement && target.type === 'range';
 }
 function isTextSelectionControl(target) {
+  if (!floatingUi_utils.isElement(target)) {
+    return false;
+  }
   return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA';
 }
 function hasExpandedSelectionWithinTarget(selection, target) {
-  const anchorElement = useScrollLock.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
-  const focusElement = useScrollLock.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
+  const anchorElement = floatingUi_utils.isElement(selection.anchorNode) ? selection.anchorNode : selection.anchorNode?.parentElement;
+  const focusElement = floatingUi_utils.isElement(selection.focusNode) ? selection.focusNode : selection.focusNode?.parentElement;
   return selection.containsNode(target, true) || useScrollLock.contains(target, anchorElement) || useScrollLock.contains(target, focusElement);
 }
 function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
   const activeEl = useScrollLock.activeElement(doc);
-  if (activeEl && useScrollLock.contains(rootElement, activeEl) && isTextSelectionControl(activeEl)) {
+  const activeElementWithinRoot = Boolean(activeEl && useScrollLock.contains(rootElement, activeEl));
+  if (activeElementWithinRoot && isTextSelectionControl(activeEl)) {
     const {
       selectionStart,
       selectionEnd
@@ -3187,60 +3453,38 @@ function shouldIgnoreSwipeForTextSelection(doc, rootElement) {
   return hasExpandedSelectionWithinTarget(selection, rootElement);
 }
 function isEventOnRangeInput(event, win) {
-  return event.composedPath().some(pathTarget => isRangeInput(pathTarget, win));
+  const composedPath = event.composedPath();
+  if (composedPath) {
+    return composedPath.some(pathTarget => isRangeInput(pathTarget, win));
+  }
+  return isRangeInput(useScrollLock.getTarget(event), win);
 }
 function isReactTouchEventOnRangeInput(event) {
-  return isEventOnRangeInput(event.nativeEvent, useScrollLock.getWindow(event.currentTarget));
+  return isEventOnRangeInput(event.nativeEvent, floatingUi_utils.getWindow(event.currentTarget));
 }
 function updateTouchScrollPosition(touchState, touch) {
   touchState.lastX = touch.clientX;
   touchState.lastY = touch.clientY;
 }
-
-/**
- * Arbitrates a touchmove between the drawer swipe and a native cross-axis scroll.
- * Returns `true` when the move must be left alone — either because the cross axis already won the
- * gesture, or because neither axis has passed the slop yet and the gesture cannot be attributed.
- */
-function shouldYieldTouchMove(touchState, event, touch, isVerticalScrollAxis) {
+function preserveNativeCrossAxisScrollOnMove(touchState, touch, isVerticalScrollAxis) {
   if (touchState.preserveNativeCrossAxisScroll) {
     return true;
   }
-
-  // Attribution happens once per gesture. Re-arbitrating after the drawer axis has won would let
-  // the pre-attribution branches below fire mid-drag (the slop is measured from the touch origin,
-  // which is never re-baselined), freezing the popup and dropping `preventDefault()`.
-  if (touchState.drawerAxisAttributed || touchState.allowSwipe === true || !touchState.hasCrossAxisScrollableContent) {
+  if (touchState.allowSwipe === true || !touchState.hasCrossAxisScrollableContent) {
     return false;
   }
-
-  // A non-cancelable touchmove means the browser has already committed the gesture to a native
-  // scroll; claiming it for the swipe would drag the popup alongside the scrolling content.
-  if (!event.cancelable) {
-    touchState.preserveNativeCrossAxisScroll = true;
-    return true;
-  }
   const drawerAxisGestureDelta = isVerticalScrollAxis ? touch.clientY - touchState.startY : touch.clientX - touchState.startX;
   const crossAxisGestureDelta = isVerticalScrollAxis ? touch.clientX - touchState.startX : touch.clientY - touchState.startY;
   const absDrawerAxisGestureDelta = Math.abs(drawerAxisGestureDelta);
   const absCrossAxisGestureDelta = Math.abs(crossAxisGestureDelta);
-  if (absCrossAxisGestureDelta >= AXIS_LOCK_SLOP && absCrossAxisGestureDelta > absDrawerAxisGestureDelta + AXIS_LOCK_BIAS) {
-    touchState.preserveNativeCrossAxisScroll = true;
-    return true;
-  }
-  if (absDrawerAxisGestureDelta >= AXIS_LOCK_SLOP) {
-    touchState.drawerAxisAttributed = true;
+  if (absCrossAxisGestureDelta < 6 || absCrossAxisGestureDelta <= absDrawerAxisGestureDelta + 2) {
     return false;
   }
-
-  // Neither axis has traveled past the slop yet, so the gesture cannot be attributed. Leave the
-  // event alone: on iOS, `preventDefault()` on the first cancelable touchmove cancels native
-  // scrolling for the entire gesture, which would lock a cross-axis scroll that only passes the
-  // slop on a later move.
+  touchState.preserveNativeCrossAxisScroll = true;
   return true;
 }
 function hasScrollableContentOnAxis(scrollTarget, axis) {
-  return getScrollMetrics(scrollTarget, axis).max > 0;
+  return axis === 'vertical' ? scrollTarget.scrollHeight > scrollTarget.clientHeight : scrollTarget.scrollWidth > scrollTarget.clientWidth;
 }
 function getScrollMetrics(scrollTarget, axis) {
   if (axis === 'vertical') {
@@ -3257,23 +3501,48 @@ function getScrollMetrics(scrollTarget, axis) {
   };
 }
 function isAtSwipeStartEdge(scrollTarget, axis, direction) {
-  const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
   const {
     offset,
     max
   } = getScrollMetrics(scrollTarget, axis);
+  const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+  if (dismissFromStartEdge === null) {
+    return false;
+  }
   return dismissFromStartEdge ? offset <= 0 : offset >= max;
 }
 function canSwipeFromScrollEdgeOnMove(scrollTarget, axis, direction, delta) {
+  const {
+    offset,
+    max
+  } = getScrollMetrics(scrollTarget, axis);
   const dismissFromStartEdge = shouldDismissFromStartEdge(direction, axis);
+  if (dismissFromStartEdge === null) {
+    return false;
+  }
   const movingTowardDismiss = dismissFromStartEdge ? delta > 0 : delta < 0;
   if (!movingTowardDismiss) {
     return false;
   }
-  return isAtSwipeStartEdge(scrollTarget, axis, direction);
+  return dismissFromStartEdge ? offset <= 0 : offset >= max;
 }
 function shouldDismissFromStartEdge(direction, axis) {
-  return axis === 'vertical' ? direction === 'down' : direction === 'right';
+  if (axis === 'vertical') {
+    if (direction === 'down') {
+      return true;
+    }
+    if (direction === 'up') {
+      return false;
+    }
+    return null;
+  }
+  if (direction === 'right') {
+    return true;
+  }
+  if (direction === 'left') {
+    return false;
+  }
+  return null;
 }
 
 const ScrollAreaRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
@@ -3286,6 +3555,20 @@ function useScrollAreaRootContext() {
   return context;
 }
 
+let ScrollAreaRootCssVars = /*#__PURE__*/function (ScrollAreaRootCssVars) {
+  /**
+   * The scroll area's corner height.
+   * @type {number}
+   */
+  ScrollAreaRootCssVars["scrollAreaCornerHeight"] = "--scroll-area-corner-height";
+  /**
+   * The scroll area's corner width.
+   * @type {number}
+   */
+  ScrollAreaRootCssVars["scrollAreaCornerWidth"] = "--scroll-area-corner-width";
+  return ScrollAreaRootCssVars;
+}({});
+
 const SCROLL_TIMEOUT = 500;
 const MIN_THUMB_SIZE = 16;
 
@@ -3294,28 +3577,108 @@ function getOffset(element, prop, axis) {
     return 0;
   }
   const styles = getComputedStyle(element);
-  const key = `${prop}${axis === 'x' ? 'Inline' : 'Block'}`;
-  const start = parseFloat(styles[`${key}Start`]);
+  const propAxis = axis === 'x' ? 'Inline' : 'Block';
 
   // Safari misreports `marginInlineEnd` in RTL.
   // We have to assume the start/end values are symmetrical, which is likely.
   if (axis === 'x' && prop === 'margin') {
-    return start * 2;
+    return parseFloat(styles[`${prop}InlineStart`]) * 2;
   }
-  return start + parseFloat(styles[`${key}End`]);
+  return parseFloat(styles[`${prop}${propAxis}Start`]) + parseFloat(styles[`${prop}${propAxis}End`]);
 }
 
-// Data-attribute strings inlined so `ScrollAreaRootDataAttributes` tree-shakes out.
-const attr = name => value => value ? {
-  [name]: ''
-} : null;
+let ScrollAreaScrollbarDataAttributes = /*#__PURE__*/function (ScrollAreaScrollbarDataAttributes) {
+  /**
+   * Indicates the orientation of the scrollbar.
+   * @type {'horizontal' | 'vertical'}
+   */
+  ScrollAreaScrollbarDataAttributes["orientation"] = "data-orientation";
+  /**
+   * Present when the pointer is over the scroll area.
+   */
+  ScrollAreaScrollbarDataAttributes["hovering"] = "data-hovering";
+  /**
+   * Present when the user scrolls inside the scroll area.
+   */
+  ScrollAreaScrollbarDataAttributes["scrolling"] = "data-scrolling";
+  /**
+   * Present when the scroll area content is wider than the viewport.
+   */
+  ScrollAreaScrollbarDataAttributes["hasOverflowX"] = "data-has-overflow-x";
+  /**
+   * Present when the scroll area content is taller than the viewport.
+   */
+  ScrollAreaScrollbarDataAttributes["hasOverflowY"] = "data-has-overflow-y";
+  /**
+   * Present when there is overflow on the horizontal start side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowXStart"] = "data-overflow-x-start";
+  /**
+   * Present when there is overflow on the horizontal end side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowXEnd"] = "data-overflow-x-end";
+  /**
+   * Present when there is overflow on the vertical start side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowYStart"] = "data-overflow-y-start";
+  /**
+   * Present when there is overflow on the vertical end side.
+   */
+  ScrollAreaScrollbarDataAttributes["overflowYEnd"] = "data-overflow-y-end";
+  return ScrollAreaScrollbarDataAttributes;
+}({});
+
+let ScrollAreaRootDataAttributes = /*#__PURE__*/function (ScrollAreaRootDataAttributes) {
+  /**
+   * Present when the user scrolls inside the scroll area.
+   */
+  ScrollAreaRootDataAttributes["scrolling"] = "data-scrolling";
+  /**
+   * Present when the scroll area content is wider than the viewport.
+   */
+  ScrollAreaRootDataAttributes["hasOverflowX"] = "data-has-overflow-x";
+  /**
+   * Present when the scroll area content is taller than the viewport.
+   */
+  ScrollAreaRootDataAttributes["hasOverflowY"] = "data-has-overflow-y";
+  /**
+   * Present when there is overflow on the horizontal start side.
+   */
+  ScrollAreaRootDataAttributes["overflowXStart"] = "data-overflow-x-start";
+  /**
+   * Present when there is overflow on the horizontal end side.
+   */
+  ScrollAreaRootDataAttributes["overflowXEnd"] = "data-overflow-x-end";
+  /**
+   * Present when there is overflow on the vertical start side.
+   */
+  ScrollAreaRootDataAttributes["overflowYStart"] = "data-overflow-y-start";
+  /**
+   * Present when there is overflow on the vertical end side.
+   */
+  ScrollAreaRootDataAttributes["overflowYEnd"] = "data-overflow-y-end";
+  return ScrollAreaRootDataAttributes;
+}({});
+
 const scrollAreaStateAttributesMapping = {
-  hasOverflowX: attr('data-has-overflow-x'),
-  hasOverflowY: attr('data-has-overflow-y'),
-  overflowXStart: attr('data-overflow-x-start'),
-  overflowXEnd: attr('data-overflow-x-end'),
-  overflowYStart: attr('data-overflow-y-start'),
-  overflowYEnd: attr('data-overflow-y-end'),
+  hasOverflowX: value => value ? {
+    [ScrollAreaRootDataAttributes.hasOverflowX]: ''
+  } : null,
+  hasOverflowY: value => value ? {
+    [ScrollAreaRootDataAttributes.hasOverflowY]: ''
+  } : null,
+  overflowXStart: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowXStart]: ''
+  } : null,
+  overflowXEnd: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowXEnd]: ''
+  } : null,
+  overflowYStart: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowYStart]: ''
+  } : null,
+  overflowYEnd: value => value ? {
+    [ScrollAreaRootDataAttributes.overflowYEnd]: ''
+  } : null,
   cornerHidden: () => null
 };
 
@@ -3381,145 +3744,99 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
   const thumbYRef = React__namespace.useRef(null);
   const thumbXRef = React__namespace.useRef(null);
   const cornerRef = React__namespace.useRef(null);
-  const activePointerIdRef = React__namespace.useRef(null);
+  const thumbDraggingRef = React__namespace.useRef(false);
   const startYRef = React__namespace.useRef(0);
   const startXRef = React__namespace.useRef(0);
   const startScrollTopRef = React__namespace.useRef(0);
   const startScrollLeftRef = React__namespace.useRef(0);
   const currentOrientationRef = React__namespace.useRef('vertical');
   const scrollPositionRef = React__namespace.useRef(DEFAULT_COORDS);
-  const savedSnapTypeRef = React__namespace.useRef(null);
-  function startScrolling(vertical) {
-    const setScrolling = vertical ? setScrollingY : setScrollingX;
-    const timeout = vertical ? scrollYTimeout : scrollXTimeout;
-    setScrolling(true);
-    timeout.start(SCROLL_TIMEOUT, () => {
-      setScrolling(false);
-    });
-  }
   const handleScroll = useScrollLock.useStableCallback(scrollPosition => {
     const offsetX = scrollPosition.x - scrollPositionRef.current.x;
     const offsetY = scrollPosition.y - scrollPositionRef.current.y;
     scrollPositionRef.current = scrollPosition;
     if (offsetY !== 0) {
-      startScrolling(true);
+      setScrollingY(true);
+      scrollYTimeout.start(SCROLL_TIMEOUT, () => {
+        setScrollingY(false);
+      });
     }
     if (offsetX !== 0) {
-      startScrolling(false);
-    }
-  });
-
-  // CSS scroll snap forces every programmatic scroll to land on a snap
-  // point, making thumb dragging jump between snap points. Native
-  // scrollbars suppress snapping while dragging, so disable it until the
-  // pointer is released; restoring the value re-snaps the viewport. The
-  // save is guarded so a second pointer during an active drag can't
-  // clobber the saved value with `none`.
-  const disableViewportSnap = useScrollLock.useStableCallback(() => {
-    const viewportEl = viewportRef.current;
-    if (viewportEl && savedSnapTypeRef.current === null) {
-      savedSnapTypeRef.current = viewportEl.style.scrollSnapType;
-      viewportEl.style.scrollSnapType = 'none';
+      setScrollingX(true);
+      scrollXTimeout.start(SCROLL_TIMEOUT, () => {
+        setScrollingX(false);
+      });
     }
   });
   const handlePointerDown = useScrollLock.useStableCallback(event => {
     if (event.button !== 0) {
       return;
     }
-    if (activePointerIdRef.current !== null) {
-      const activeThumb = currentOrientationRef.current === 'vertical' ? thumbYRef.current : thumbXRef.current;
-      // A live drag holds capture for the active pointer — ignore other pointers.
-      // No capture means the release went missing entirely (silent capture drop
-      // with an id that never reappears, e.g. a lost touch contact), so let the
-      // new pointer take over the latch instead of leaving dragging dead.
-      if (activeThumb?.hasPointerCapture(activePointerIdRef.current)) {
-        return;
-      }
-    }
-    activePointerIdRef.current = event.pointerId;
+    thumbDraggingRef.current = true;
     startYRef.current = event.clientY;
     startXRef.current = event.clientX;
-    // Literal instead of `ScrollAreaScrollbarDataAttributes.orientation`: referencing an
-    // enum member retains its whole object in the bundle, so the strings are inlined and
-    // the enums kept for docs only.
-    currentOrientationRef.current = event.currentTarget.getAttribute('data-orientation');
-    const viewportEl = viewportRef.current;
-    if (viewportEl) {
-      startScrollTopRef.current = viewportEl.scrollTop;
-      startScrollLeftRef.current = viewportEl.scrollLeft;
-      disableViewportSnap();
-    }
-    const thumb = currentOrientationRef.current === 'vertical' ? thumbYRef.current : thumbXRef.current;
-    thumb?.setPointerCapture(event.pointerId);
-  });
-  const handlePointerUp = useScrollLock.useStableCallback(event => {
-    if (event.pointerId !== activePointerIdRef.current) {
-      return;
+    currentOrientationRef.current = event.currentTarget.getAttribute(ScrollAreaScrollbarDataAttributes.orientation);
+    if (viewportRef.current) {
+      startScrollTopRef.current = viewportRef.current.scrollTop;
+      startScrollLeftRef.current = viewportRef.current.scrollLeft;
     }
-    activePointerIdRef.current = null;
-    // Clear the drag's scrolling state immediately rather than waiting for the
-    // `SCROLL_TIMEOUT` timer armed by the last drag move, so every release path
-    // (real, `pointercancel`, or the missed-release fallback) behaves the same.
-    (currentOrientationRef.current === 'vertical' ? setScrollingY : setScrollingX)(false);
-    if (savedSnapTypeRef.current !== null) {
-      if (viewportRef.current) {
-        viewportRef.current.style.scrollSnapType = savedSnapTypeRef.current;
-      }
-      savedSnapTypeRef.current = null;
+    if (thumbYRef.current && currentOrientationRef.current === 'vertical') {
+      thumbYRef.current.setPointerCapture(event.pointerId);
     }
-    const thumb = currentOrientationRef.current === 'vertical' ? thumbYRef.current : thumbXRef.current;
-    // `pointercancel` releases capture implicitly, so guard against releasing a
-    // capture we no longer hold (which would throw).
-    if (thumb?.hasPointerCapture(event.pointerId)) {
-      thumb.releasePointerCapture(event.pointerId);
+    if (thumbXRef.current && currentOrientationRef.current === 'horizontal') {
+      thumbXRef.current.setPointerCapture(event.pointerId);
     }
   });
   const handlePointerMove = useScrollLock.useStableCallback(event => {
-    if (event.pointerId !== activePointerIdRef.current) {
-      return;
-    }
-
-    // The release can go missing entirely (e.g. the browser drops pointer
-    // capture while the scrollbar is hidden mid-drag), leaving the drag
-    // latched so a buttonless hover over the thumb scrolls the viewport.
-    // Treat a move without the primary button held (`buttons` bit 1 unset)
-    // as the missed release.
-    if (event.buttons % 2 === 0) {
-      handlePointerUp(event);
+    if (!thumbDraggingRef.current) {
       return;
     }
-    const viewportEl = viewportRef.current;
-    if (!viewportEl) {
-      return;
+    const deltaY = event.clientY - startYRef.current;
+    const deltaX = event.clientX - startXRef.current;
+    if (viewportRef.current) {
+      const scrollableContentHeight = viewportRef.current.scrollHeight;
+      const viewportHeight = viewportRef.current.clientHeight;
+      const scrollableContentWidth = viewportRef.current.scrollWidth;
+      const viewportWidth = viewportRef.current.clientWidth;
+      if (thumbYRef.current && scrollbarYRef.current && currentOrientationRef.current === 'vertical') {
+        const scrollbarYOffset = getOffset(scrollbarYRef.current, 'padding', 'y');
+        const thumbYOffset = getOffset(thumbYRef.current, 'margin', 'y');
+        const thumbHeight = thumbYRef.current.offsetHeight;
+        const maxThumbOffsetY = scrollbarYRef.current.offsetHeight - thumbHeight - scrollbarYOffset - thumbYOffset;
+        const scrollRatioY = deltaY / maxThumbOffsetY;
+        viewportRef.current.scrollTop = startScrollTopRef.current + scrollRatioY * (scrollableContentHeight - viewportHeight);
+        event.preventDefault();
+        setScrollingY(true);
+        scrollYTimeout.start(SCROLL_TIMEOUT, () => {
+          setScrollingY(false);
+        });
+      }
+      if (thumbXRef.current && scrollbarXRef.current && currentOrientationRef.current === 'horizontal') {
+        const scrollbarXOffset = getOffset(scrollbarXRef.current, 'padding', 'x');
+        const thumbXOffset = getOffset(thumbXRef.current, 'margin', 'x');
+        const thumbWidth = thumbXRef.current.offsetWidth;
+        const maxThumbOffsetX = scrollbarXRef.current.offsetWidth - thumbWidth - scrollbarXOffset - thumbXOffset;
+        const scrollRatioX = deltaX / maxThumbOffsetX;
+        viewportRef.current.scrollLeft = startScrollLeftRef.current + scrollRatioX * (scrollableContentWidth - viewportWidth);
+        event.preventDefault();
+        setScrollingX(true);
+        scrollXTimeout.start(SCROLL_TIMEOUT, () => {
+          setScrollingX(false);
+        });
+      }
     }
-    const vertical = currentOrientationRef.current === 'vertical';
-    const thumbEl = vertical ? thumbYRef.current : thumbXRef.current;
-    const scrollbarEl = vertical ? scrollbarYRef.current : scrollbarXRef.current;
-    if (!thumbEl || !scrollbarEl) {
-      return;
+  });
+  const handlePointerUp = useScrollLock.useStableCallback(event => {
+    thumbDraggingRef.current = false;
+
+    // `pointercancel` releases capture implicitly, so guard against releasing a
+    // capture we no longer hold (which would throw).
+    if (thumbYRef.current && currentOrientationRef.current === 'vertical' && thumbYRef.current.hasPointerCapture(event.pointerId)) {
+      thumbYRef.current.releasePointerCapture(event.pointerId);
     }
-    const axis = vertical ? 'y' : 'x';
-    const scrollbarOffset = getOffset(scrollbarEl, 'padding', axis);
-    const thumbOffset = getOffset(thumbEl, 'margin', axis);
-    const thumbSizePx = vertical ? thumbEl.offsetHeight : thumbEl.offsetWidth;
-    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.
-    const delta = vertical ? event.clientY - startYRef.current : event.clientX - startXRef.current;
-    const scrollRatio = maxThumbOffset <= 0 ? 0 : delta / maxThumbOffset;
-    const scrollableSize = vertical ? viewportEl.scrollHeight : viewportEl.scrollWidth;
-    const viewportSize = vertical ? viewportEl.clientHeight : viewportEl.clientWidth;
-    const startScroll = vertical ? startScrollTopRef.current : startScrollLeftRef.current;
-    const nextScroll = startScroll + scrollRatio * (scrollableSize - viewportSize);
-    if (vertical) {
-      viewportEl.scrollTop = nextScroll;
-    } else {
-      viewportEl.scrollLeft = nextScroll;
+    if (thumbXRef.current && currentOrientationRef.current === 'horizontal' && thumbXRef.current.hasPointerCapture(event.pointerId)) {
+      thumbXRef.current.releasePointerCapture(event.pointerId);
     }
-    event.preventDefault();
-    startScrolling(vertical);
   });
   function handleTouchModalityChange(event) {
     setTouchModality(event.pointerType === 'touch');
@@ -3551,8 +3868,8 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
     },
     style: {
       position: 'relative',
-      ['--scroll-area-corner-height']: `${cornerSize.height}px`,
-      ['--scroll-area-corner-width']: `${cornerSize.width}px`
+      [ScrollAreaRootCssVars.scrollAreaCornerHeight]: `${cornerSize.height}px`,
+      [ScrollAreaRootCssVars.scrollAreaCornerWidth]: `${cornerSize.width}px`
     }
   };
   const element = useRenderElement.useRenderElement('div', componentProps, {
@@ -3566,7 +3883,6 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
     handlePointerMove,
     handlePointerUp,
     handleScroll,
-    disableViewportSnap,
     cornerSize,
     setCornerSize,
     thumbSize,
@@ -3576,10 +3892,13 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
     touchModality,
     cornerRef,
     scrollingX,
+    setScrollingX,
     scrollingY,
+    setScrollingY,
     hovering,
     setHovering,
     viewportRef,
+    rootRef,
     scrollbarYRef,
     scrollbarXRef,
     thumbYRef,
@@ -3596,7 +3915,7 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
       yStart,
       yEnd
     }
-  }), [handlePointerDown, handlePointerMove, handlePointerUp, handleScroll, disableViewportSnap, cornerSize, thumbSize, hasMeasuredScrollbar, touchModality, scrollingX, scrollingY, hovering, rootId, hiddenState, overflowEdges, state, xStart, xEnd, yStart, yEnd]);
+  }), [handlePointerDown, handlePointerMove, handlePointerUp, handleScroll, cornerSize, thumbSize, hasMeasuredScrollbar, touchModality, scrollingX, setScrollingX, scrollingY, setScrollingY, hovering, setHovering, rootId, hiddenState, overflowEdges, state, xStart, xEnd, yStart, yEnd]);
   return /*#__PURE__*/jsxRuntime.jsxs(ScrollAreaRootContext.Provider, {
     value: contextValue,
     children: [!disableStyleElements && scrollEdges.styleDisableScrollbar.getElement(nonce), element]
@@ -3604,17 +3923,20 @@ const ScrollAreaRoot = /*#__PURE__*/React__namespace.forwardRef(function ScrollA
 });
 if (process.env.NODE_ENV !== "production") ScrollAreaRoot.displayName = "ScrollAreaRoot";
 function normalizeOverflowEdgeThreshold(threshold) {
-  const thresholds = typeof threshold === 'number' ? {
-    xStart: threshold,
-    xEnd: threshold,
-    yStart: threshold,
-    yEnd: threshold
-  } : threshold;
+  if (typeof threshold === 'number') {
+    const value = Math.max(0, threshold);
+    return {
+      xStart: value,
+      xEnd: value,
+      yStart: value,
+      yEnd: value
+    };
+  }
   return {
-    xStart: Math.max(0, thresholds?.xStart || 0),
-    xEnd: Math.max(0, thresholds?.xEnd || 0),
-    yStart: Math.max(0, thresholds?.yStart || 0),
-    yEnd: Math.max(0, thresholds?.yEnd || 0)
+    xStart: Math.max(0, threshold?.xStart || 0),
+    xEnd: Math.max(0, threshold?.xEnd || 0),
+    yStart: Math.max(0, threshold?.yStart || 0),
+    yEnd: Math.max(0, threshold?.yEnd || 0)
   };
 }
 
@@ -3628,10 +3950,30 @@ function useScrollAreaViewportContext() {
   return context;
 }
 
-const OVERFLOW_EDGE_VARS = ['--scroll-area-overflow-x-start', '--scroll-area-overflow-x-end', '--scroll-area-overflow-y-start', '--scroll-area-overflow-y-end'];
+let ScrollAreaViewportCssVars = /*#__PURE__*/function (ScrollAreaViewportCssVars) {
+  /**
+   * The distance from the horizontal start edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowXStart"] = "--scroll-area-overflow-x-start";
+  /**
+   * The distance from the horizontal end edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowXEnd"] = "--scroll-area-overflow-x-end";
+  /**
+   * The distance from the vertical start edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowYStart"] = "--scroll-area-overflow-y-start";
+  /**
+   * The distance from the vertical end edge in pixels.
+   * @type {number}
+   */
+  ScrollAreaViewportCssVars["scrollAreaOverflowYEnd"] = "--scroll-area-overflow-y-end";
+  return ScrollAreaViewportCssVars;
+}({});
 
-// Module-level flag to ensure we only register the CSS properties once,
-// regardless of how many Scroll Area components are mounted.
 let scrollAreaOverflowVarsRegistered = false;
 
 /**
@@ -3650,7 +3992,7 @@ function removeCSSVariableInheritance() {
     return;
   }
   if (typeof CSS !== 'undefined' && 'registerProperty' in CSS) {
-    OVERFLOW_EDGE_VARS.forEach(name => {
+    [ScrollAreaViewportCssVars.scrollAreaOverflowXStart, ScrollAreaViewportCssVars.scrollAreaOverflowXEnd, ScrollAreaViewportCssVars.scrollAreaOverflowYStart, ScrollAreaViewportCssVars.scrollAreaOverflowYEnd].forEach(name => {
       try {
         CSS.registerProperty({
           name,
@@ -3694,11 +4036,12 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
     hiddenState,
     setHasMeasuredScrollbar,
     handleScroll,
-    touchModality,
     setHovering,
     setOverflowEdges,
+    overflowEdges,
     overflowEdgeThreshold,
-    viewportState
+    scrollingX,
+    scrollingY
   } = useScrollAreaRootContext();
   const direction = useScrollLock.useDirection();
   const programmaticScrollRef = React__namespace.useRef(true);
@@ -3743,12 +4086,18 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
     let scrollLeftFromStart = 0;
     let scrollLeftFromEnd = 0;
     if (!scrollbarXHidden) {
-      // `normalizeScrollOffset` clamps internally.
-      scrollLeftFromStart = scrollEdges.normalizeScrollOffset(direction === 'rtl' ? -scrollLeft : scrollLeft, maxScrollLeft);
+      let rawScrollLeftFromStart = 0;
+      if (direction === 'rtl') {
+        rawScrollLeftFromStart = scrollEdges.clamp(-scrollLeft, 0, maxScrollLeft);
+      } else {
+        rawScrollLeftFromStart = scrollEdges.clamp(scrollLeft, 0, maxScrollLeft);
+      }
+      scrollLeftFromStart = scrollEdges.normalizeScrollOffset(rawScrollLeftFromStart, maxScrollLeft);
       scrollLeftFromEnd = maxScrollLeft - scrollLeftFromStart;
     }
-    const scrollTopFromStart = scrollbarYHidden ? 0 : scrollEdges.normalizeScrollOffset(scrollTop, maxScrollTop);
-    const scrollTopFromEnd = scrollbarYHidden ? 0 : maxScrollTop - scrollTopFromStart;
+    const rawScrollTopFromStart = !scrollbarYHidden ? scrollEdges.clamp(scrollTop, 0, maxScrollTop) : 0;
+    const scrollTopFromStart = !scrollbarYHidden ? scrollEdges.normalizeScrollOffset(rawScrollTopFromStart, maxScrollTop) : 0;
+    const scrollTopFromEnd = !scrollbarYHidden ? maxScrollTop - scrollTopFromStart : 0;
     const nextWidth = scrollbarXHidden ? 0 : viewportWidth;
     const nextHeight = scrollbarYHidden ? 0 : viewportHeight;
     let nextCornerWidth = 0;
@@ -3773,53 +4122,76 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
     const maxNextHeight = scrollbarYEl ? Math.min(scrollbarYEl.offsetHeight - cornerHeightOffset, idealNextHeight) : idealNextHeight;
     const clampedNextWidth = Math.max(MIN_THUMB_SIZE, maxNextWidth * ratioX);
     const clampedNextHeight = Math.max(MIN_THUMB_SIZE, maxNextHeight * ratioY);
-    setThumbSize(prevSize => pickState(prevSize, {
-      width: clampedNextWidth,
-      height: clampedNextHeight
-    }));
+    setThumbSize(prevSize => {
+      if (prevSize.height === clampedNextHeight && prevSize.width === clampedNextWidth) {
+        return prevSize;
+      }
+      return {
+        width: clampedNextWidth,
+        height: clampedNextHeight
+      };
+    });
 
     // Handle Y (vertical) scroll
     if (scrollbarYEl && thumbYEl) {
       const maxThumbOffsetY = scrollbarYEl.offsetHeight - clampedNextHeight - scrollbarYOffset - thumbYOffset;
-      const thumbOffsetY = applyOverscrollThumb(thumbYEl, '--scroll-area-thumb-height', scrollTop, maxScrollTop, scrollableContentHeight, clampedNextHeight, maxThumbOffsetY);
+      const scrollRangeY = scrollableContentHeight - viewportHeight;
+      const scrollRatioY = scrollRangeY === 0 ? 0 : scrollTop / scrollRangeY;
+
+      // In Safari, don't allow it to go negative or too far as `scrollTop` considers the rubber
+      // band effect.
+      const thumbOffsetY = Math.min(maxThumbOffsetY, Math.max(0, scrollRatioY * maxThumbOffsetY));
       thumbYEl.style.transform = `translate3d(0,${thumbOffsetY}px,0)`;
     }
 
     // Handle X (horizontal) scroll
     if (scrollbarXEl && thumbXEl) {
       const maxThumbOffsetX = scrollbarXEl.offsetWidth - clampedNextWidth - scrollbarXOffset - thumbXOffset;
-      // RTL scrolls from 0 down to `-maxScrollLeft`; measure from the inline start edge so the
-      // overscroll math is direction-agnostic, then flip the resulting offset back below.
-      const scrollFromStart = direction === 'rtl' ? -scrollLeft : scrollLeft;
-      const offsetX = applyOverscrollThumb(thumbXEl, '--scroll-area-thumb-width', scrollFromStart, maxScrollLeft, scrollableContentWidth, clampedNextWidth, maxThumbOffsetX);
-      thumbXEl.style.transform = `translate3d(${direction === 'rtl' ? -offsetX : offsetX}px,0,0)`;
-    }
-    const overflowMetricsPx = [scrollLeftFromStart, scrollLeftFromEnd, scrollTopFromStart, scrollTopFromEnd];
-    OVERFLOW_EDGE_VARS.forEach((cssVar, index) => {
-      viewportEl.style.setProperty(cssVar, `${overflowMetricsPx[index]}px`);
-    });
+      const scrollRangeX = scrollableContentWidth - viewportWidth;
+      const scrollRatioX = scrollRangeX === 0 ? 0 : scrollLeft / scrollRangeX;
+
+      // In Safari, don't allow it to go negative or too far as `scrollLeft` considers the rubber
+      // band effect.
+      const thumbOffsetX = direction === 'rtl' ? scrollEdges.clamp(scrollRatioX * maxThumbOffsetX, -maxThumbOffsetX, 0) : scrollEdges.clamp(scrollRatioX * maxThumbOffsetX, 0, maxThumbOffsetX);
+      thumbXEl.style.transform = `translate3d(${thumbOffsetX}px,0,0)`;
+    }
+    const overflowMetricsPx = [[ScrollAreaViewportCssVars.scrollAreaOverflowXStart, scrollLeftFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowXEnd, scrollLeftFromEnd], [ScrollAreaViewportCssVars.scrollAreaOverflowYStart, scrollTopFromStart], [ScrollAreaViewportCssVars.scrollAreaOverflowYEnd, scrollTopFromEnd]];
+    for (const [cssVar, value] of overflowMetricsPx) {
+      viewportEl.style.setProperty(cssVar, `${value}px`);
+    }
     if (cornerEl) {
-      // Bail when the size is unchanged (like `setThumbSize` above); otherwise a
-      // fresh object literal on every scroll frame rebuilds the root context and
-      // re-renders every scroll-area part.
-      // `nextCornerWidth`/`nextCornerHeight` stay 0 when either scrollbar is hidden.
-      setCornerSize(prevSize => pickState(prevSize, {
-        width: nextCornerWidth,
-        height: nextCornerHeight
-      }));
-    }
-    setHiddenState(prevState => pickState(prevState, nextHiddenState));
+      if (scrollbarXHidden || scrollbarYHidden) {
+        setCornerSize({
+          width: 0,
+          height: 0
+        });
+      } else if (!scrollbarXHidden && !scrollbarYHidden) {
+        setCornerSize({
+          width: nextCornerWidth,
+          height: nextCornerHeight
+        });
+      }
+    }
+    setHiddenState(prevState => mergeHiddenState(prevState, nextHiddenState));
     const nextOverflowEdges = {
       xStart: !scrollbarXHidden && scrollLeftFromStart > overflowEdgeThreshold.xStart,
       xEnd: !scrollbarXHidden && scrollLeftFromEnd > overflowEdgeThreshold.xEnd,
       yStart: !scrollbarYHidden && scrollTopFromStart > overflowEdgeThreshold.yStart,
       yEnd: !scrollbarYHidden && scrollTopFromEnd > overflowEdgeThreshold.yEnd
     };
-    setOverflowEdges(prev => pickState(prev, nextOverflowEdges));
+    setOverflowEdges(prev => {
+      if (prev.xStart === nextOverflowEdges.xStart && prev.xEnd === nextOverflowEdges.xEnd && prev.yStart === nextOverflowEdges.yStart && prev.yEnd === nextOverflowEdges.yEnd) {
+        return prev;
+      }
+      return nextOverflowEdges;
+    });
   });
   useScrollLock.useIsoLayoutEffect(() => {
+    if (!viewportRef.current) {
+      return;
+    }
     removeCSSVariableInheritance();
-  }, []);
+  }, [viewportRef]);
   useScrollLock.useIsoLayoutEffect(() => {
     // Wait for scrollbar and thumb refs after hidden-state toggles, refresh math on direction
     // flips, and re-evaluate overflow edges when the threshold changes.
@@ -3862,10 +4234,6 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
       if (animations.length === 0) {
         return;
       }
-
-      // `allSettled` never rejects, but `computeThumbPosition` can still run against a
-      // torn-down tree once the animations resolve. Swallow instead of leaking an unhandled
-      // rejection; `void` alone would only silence the floating-promise lint.
       Promise.allSettled(animations.map(animation => animation.finished)).then(computeThumbPosition).catch(() => {});
     });
     return () => {
@@ -3893,13 +4261,7 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
         return;
       }
       computeThumbPosition();
-
-      // WebKit consumes a touch that catches an in-flight momentum scroll or
-      // rubber-band bounce without dispatching any DOM events for the whole
-      // gesture (not even `touchstart`), so scrolls cannot be attributed to
-      // the user through events. Treat every scroll in touch modality as
-      // user-driven instead.
-      if (touchModality || !programmaticScrollRef.current) {
+      if (!programmaticScrollRef.current) {
         handleScroll({
           x: viewportRef.current.scrollLeft,
           y: viewportRef.current.scrollTop
@@ -3917,10 +4279,21 @@ const ScrollAreaViewport = /*#__PURE__*/React__namespace.forwardRef(function Scr
       });
     },
     onWheel: handleUserInteraction,
+    onTouchMove: handleUserInteraction,
     onPointerMove: handleUserInteraction,
     onPointerEnter: handleUserInteraction,
     onKeyDown: handleUserInteraction
   };
+  const viewportState = React__namespace.useMemo(() => ({
+    scrolling: scrollingX || scrollingY,
+    hasOverflowX: !hiddenState.x,
+    hasOverflowY: !hiddenState.y,
+    overflowXStart: overflowEdges.xStart,
+    overflowXEnd: overflowEdges.xEnd,
+    overflowYStart: overflowEdges.yStart,
+    overflowYEnd: overflowEdges.yEnd,
+    cornerHidden: hiddenState.corner
+  }), [scrollingX, scrollingY, hiddenState.x, hiddenState.y, hiddenState.corner, overflowEdges]);
   const element = useRenderElement.useRenderElement('div', componentProps, {
     ref: [forwardedRef, viewportRef],
     state: viewportState,
@@ -3945,40 +4318,16 @@ function getHiddenState(viewport) {
     corner: y || x
   };
 }
-
-/**
- * Returns `prev` when `next` is shallow-equal to it so setState bails out and
- * scroll-frame updates don't rebuild the root context.
- */
-function pickState(prev, next) {
-  for (const key in next) {
-    if (prev[key] !== next[key]) {
-      return next;
-    }
+function mergeHiddenState(prevState, nextState) {
+  if (prevState.y === nextState.y && prevState.x === nextState.x && prevState.corner === nextState.corner) {
+    return prevState;
   }
-  return prev;
-}
-
-/**
- * Sizes the thumb and returns its axis offset. On overscroll (Safari rubber-band only) it shrinks
- * against the pinned edge, damped by `content / (content + overscroll)` to match native feedback;
- * the size flows through the thumb-size variable so the resting `var(...)` still applies.
- */
-function applyOverscrollThumb(thumbEl, sizeVar, scrollFromStart, maxScroll, content, size, maxThumbOffset) {
-  const clamped = scrollEdges.clamp(scrollFromStart, 0, maxScroll);
-  const overscroll = scrollFromStart - clamped;
-  const nextSize = Math.max(MIN_THUMB_SIZE, size * content / (content + Math.abs(overscroll)));
-
-  // Passing an empty string removes the override, restoring the resting `var(...)` size.
-  thumbEl.style.setProperty(sizeVar, overscroll ? `${nextSize}px` : '');
-
-  // Slide proportionally; at the end edge push down by the shrink so the thumb stays pinned to
-  // it, while a start overscroll pins to offset 0.
-  const offset = maxScroll ? clamped / maxScroll * maxThumbOffset : 0;
-  return offset + (overscroll > 0 ? size - nextSize : 0);
+  return nextState;
 }
 
 exports.DialogPortal = DialogPortal;
+exports.DialogRoot = DialogRoot;
+exports.DialogStore = DialogStore;
 exports.DialogTrigger = DialogTrigger;
 exports.DialogViewport = DialogViewport;
 exports.DrawerBackdrop = DrawerBackdrop;
@@ -3993,12 +4342,11 @@ exports.DrawerRoot = DrawerRoot;
 exports.DrawerTrigger = DrawerTrigger;
 exports.DrawerViewport = DrawerViewport;
 exports.DrawerVirtualKeyboardContext = DrawerVirtualKeyboardContext;
-exports.NullStore = NullStore;
 exports.ScrollAreaRoot = ScrollAreaRoot;
+exports.ScrollAreaRootCssVars = ScrollAreaRootCssVars;
 exports.ScrollAreaViewport = ScrollAreaViewport;
 exports.createInitialPopupStoreState = createInitialPopupStoreState;
-exports.createNullDialogStore = createNullDialogStore;
-exports.dialogStateAttributesMapping = dialogStateAttributesMapping;
+exports.findScrollableTouchTarget = findScrollableTouchTarget;
 exports.getDisplacement = getDisplacement;
 exports.getElementAtPoint = getElementAtPoint;
 exports.getElementTransform = getElementTransform;
@@ -4009,8 +4357,6 @@ exports.useDialogPortalContext = useDialogPortalContext;
 exports.useDialogRootContext = useDialogRootContext;
 exports.useDrawerProviderContext = useDrawerProviderContext;
 exports.useDrawerRootContext = useDrawerRootContext;
-exports.usePopupHandleStore = usePopupHandleStore;
-exports.useRenderDialogRoot = useRenderDialogRoot;
 exports.useScrollAreaRootContext = useScrollAreaRootContext;
 exports.useScrollAreaViewportContext = useScrollAreaViewportContext;
 exports.useSwipeDismiss = useSwipeDismiss;