@jobber/components 9.5.3 → 9.6.0

package/dist/useScrollLock-cjs.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var React = require('react');
-var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var useRenderElement = require('./useRenderElement-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var ReactDOM = require('react-dom');
@@ -104,14 +103,6 @@ function serializeToDevModeString(input) {
 const noop = () => {};
 const useIsoLayoutEffect = typeof document !== 'undefined' ? React__namespace.useLayoutEffect : noop;
 
-function useOnFirstRender(fn) {
-  const ref = React__namespace.useRef(true);
-  if (ref.current) {
-    ref.current = false;
-    fn();
-  }
-}
-
 /**
  * A clone of the React namespace for reading APIs that may be missing in older
  * supported React versions. Bundlers can rewrite direct `React.someNewApi`
@@ -210,87 +201,6 @@ const visuallyHiddenInput = {
   position: 'absolute'
 };
 
-/**
- * The NoOptionalParams type is a utility type that checks if a function has optional or default parameters.
- * If the function has optional or default parameters, it returns a string literal type with an error message.
- * Otherwise, it returns the original function type.
- *
- * This is used to enforce that the combiner function passed to createSelector does not have optional or default parameters,
- * as memoization relies on the Function.length property, which does not account for optional or default parameters.
- */
-
-/**
- * Creates a selector function that can be used to derive values from the store's state.
- *
- * The combiner function can have up to three additional parameters, but it **cannot have optional or default parameters**.
- *
- * This function accepts up to six functions and combines them into a single selector function.
- * The resulting selector will take the state from the combined selectors and any additional parameters required by the combiner.
- *
- * The return type of the resulting selector is determined by the return type of the combiner function.
- *
- * @example
- * const selector = createSelector(
- *  (state) => state.disabled
- * );
- *
- * @example
- * const selector = createSelector(
- *   (state) => state.disabled,
- *   (state) => state.open,
- *   (disabled, open) => ({ disabled, open })
- * );
- */
-/* eslint-disable id-denylist */
-const createSelector = (a, b, c, d, e, f, ...other) => {
-  if (other.length > 0) {
-    throw new Error(process.env.NODE_ENV !== "production" ? 'Unsupported number of selectors' : useRenderElement.formatErrorMessage(1));
-  }
-  let selector;
-  if (a && b && c && d && e && f) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      const vd = d(state, a1, a2, a3);
-      const ve = e(state, a1, a2, a3);
-      return f(va, vb, vc, vd, ve, a1, a2, a3);
-    };
-  } else if (a && b && c && d && e) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      const vd = d(state, a1, a2, a3);
-      return e(va, vb, vc, vd, a1, a2, a3);
-    };
-  } else if (a && b && c && d) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      const vc = c(state, a1, a2, a3);
-      return d(va, vb, vc, a1, a2, a3);
-    };
-  } else if (a && b && c) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      const vb = b(state, a1, a2, a3);
-      return c(va, vb, a1, a2, a3);
-    };
-  } else if (a && b) {
-    selector = (state, a1, a2, a3) => {
-      const va = a(state, a1, a2, a3);
-      return b(va, a1, a2, a3);
-    };
-  } else if (a) {
-    selector = a;
-  } else {
-    throw /* minify-error-disabled */new Error('Missing arguments');
-  }
-  return selector;
-};
-/* eslint-enable id-denylist */
-
 var shim = {exports: {}};
 
 var useSyncExternalStoreShim_production = {};
@@ -698,6 +608,41 @@ function getInstance() {
 function register(hook) {
   hooks.push(hook);
 }
+
+/**
+ * Wraps a component function to enable performance optimizations for internal hooks.
+ *
+ * **Performance Optimization:**
+ * Components wrapped with `fastComponent` have access to a shared "instance" context that enables
+ * specialized hook implementations to batch operations and reduce overhead. The wrapper creates a
+ * stable instance object that persists across renders, sets it as the current context, calls
+ * registered hooks before and after rendering, then clears the context. The primary benefit is
+ * with `useStore`, where multiple store subscriptions within the same component are collapsed into
+ * a single `useSyncExternalStore` subscription per store, significantly reducing re-render overhead.
+ * This optimization is only active on React 19+; on earlier versions `useStore` falls back to a
+ * separate subscription per call.
+ *
+ * **Requirements:**
+ * - The component function should follow standard React component patterns
+ * - `useStore` calls must keep a stable order and count across renders, as batched hooks are
+ *   matched by call index
+ * - Do not rely on the instance context outside of specialized hooks
+ *
+ * @param fn - The component function to wrap
+ * @returns A wrapped component with the same signature as the input function
+ *
+ * @example
+ * ```tsx
+ * // Wrapping a component to enable optimized useStore batching
+ * export const TooltipRoot = fastComponent(function TooltipRoot(props) {
+ *   // These useStore calls share a single subscription
+ *   const open = useStore(store, (state) => state.open);
+ *   const disabled = useStore(store, (state) => state.disabled);
+ *   const value = useStore(store, (state) => state.value);
+ *   // ...
+ * });
+ * ```
+ */
 function fastComponent(fn) {
   const FastComponent = (props, forwardedRef) => {
     const instance = useRenderElement.useRefWithInit(createInstance).current;
@@ -720,6 +665,31 @@ function fastComponent(fn) {
   FastComponent.displayName = fn.displayName || fn.name;
   return FastComponent;
 }
+
+/**
+ * Wraps a component function with ref forwarding to enable performance optimizations for internal hooks.
+ *
+ * This is a convenience wrapper that combines `fastComponent` with `React.forwardRef`, enabling
+ * both performance optimizations and proper ref forwarding. See `fastComponent` for details on
+ * the performance benefits.
+ *
+ * @param fn - The component function that accepts props and a forwarded ref
+ * @returns A wrapped component with ref forwarding enabled
+ *
+ * @example
+ * ```tsx
+ * // Wrapping a component with ref forwarding and optimized hooks
+ * export const TooltipTrigger = fastComponentRef(function TooltipTrigger(
+ *   props,
+ *   forwardedRef
+ * ) {
+ *   const store = useContext(TooltipContext);
+ *   const open = useStore(store, (state) => state.open);
+ *   // ... component logic with ref
+ *   return <button ref={forwardedRef} {...props} />;
+ * });
+ * ```
+ */
 function fastComponentRef(fn) {
   return /*#__PURE__*/React__namespace.forwardRef(fastComponent(fn));
 }
@@ -1135,6 +1105,170 @@ class ReactStore extends Store {
   }
 }
 
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== 'inline' && display !== 'contents';
+}
+function isTableElement(element) {
+  return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+  try {
+    if (element.matches(':popover-open')) {
+      return true;
+    }
+  } catch (_e) {
+    // no-op
+  }
+  try {
+    return element.matches(':modal');
+  } catch (_e) {
+    return false;
+  }
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+const containRe = /paint|layout|strict|content/;
+const isNotNone = value => !!value && value !== 'none';
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (isWebKitValue == null) {
+    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
+  }
+  return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+  return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return (node.ownerDocument || node).body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  } else {
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
 /**
  * Combines multiple cleanup functions into a single cleanup function.
  */
@@ -1164,15 +1298,13 @@ function addEventListener(target, type, listener, options) {
   };
 }
 
-const EMPTY$2 = [];
-
 /**
  * A React.useEffect equivalent that runs once, when the component is mounted.
  */
 function useOnMount(fn) {
   // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- no need to put `fn` in the dependency array
   /* eslint-disable react-hooks/exhaustive-deps */
-  React__namespace.useEffect(fn, EMPTY$2);
+  React__namespace.useEffect(fn, useRenderElement.EMPTY_ARRAY);
   /* eslint-enable react-hooks/exhaustive-deps */
 }
 
@@ -1236,7 +1368,7 @@ class Scheduler {
     this.callbacksCount -= 1;
   }
 }
-const scheduler = new Scheduler();
+let scheduler = new Scheduler();
 class AnimationFrame {
   static create() {
     return new AnimationFrame();
@@ -1483,7 +1615,7 @@ function contains(parent, child) {
   }
 
   // Then fall back to traversing out of shadow roots when needed.
-  if (rootNode && floatingUi_utils.isShadowRoot(rootNode)) {
+  if (rootNode && isShadowRoot(rootNode)) {
     let next = child;
     while (next) {
       if (parent === next) {
@@ -1505,7 +1637,7 @@ function getTarget(event) {
 }
 
 function isTargetInsideEnabledTrigger(target, triggerElements) {
-  if (!floatingUi_utils.isElement(target)) {
+  if (!isElement(target)) {
     return false;
   }
   const targetElement = target;
@@ -1535,7 +1667,7 @@ function isRootElement(element) {
   return element.matches('html,body');
 }
 function isTypeableElement(element) {
-  return floatingUi_utils.isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
 }
 function isInteractiveElement(element) {
   return element?.closest(`button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`) != null;
@@ -1676,6 +1808,138 @@ const FocusGuard = /*#__PURE__*/React__namespace.forwardRef(function FocusGuard(
 });
 if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
 
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+  const firstChar = placement[0];
+  return firstChar === 't' || firstChar === 'b' ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
+}
+const lrPlacement = ['left', 'right'];
+const rlPlacement = ['right', 'left'];
+const tbPlacement = ['top', 'bottom'];
+const btPlacement = ['bottom', 'top'];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case 'left':
+    case 'right':
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  const side = getSide(placement);
+  return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+  var _padding$top, _padding$right, _padding$bottom, _padding$left;
+  return {
+    top: (_padding$top = padding.top) != null ? _padding$top : 0,
+    right: (_padding$right = padding.right) != null ? _padding$right : 0,
+    bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
+    left: (_padding$left = padding.left) != null ? _padding$left : 0
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
 function isDifferentGridRow(index, cols, prevRow) {
   return Math.floor(index / cols) !== prevRow;
 }
@@ -1811,7 +2075,7 @@ function getGridNavigatedIndex(list, {
       const colInRow = prevIndex % verticalCols;
       const rowStep = direction === 'up' ? -verticalCols : verticalCols;
       const lastRowStart = maxIndex - maxIndex % verticalCols;
-      const rowCount = floatingUi_utils.floor(maxIndex / verticalCols) + 1;
+      const rowCount = floor(maxIndex / verticalCols) + 1;
       for (let rowStart = prevIndex - colInRow + rowStep, i = 0; i < rowCount; i += 1, rowStart += rowStep) {
         if (rowStart < 0 || rowStart > maxIndex) {
           if (!loopFocus) {
@@ -1876,7 +2140,7 @@ function getGridNavigatedIndex(list, {
 
   // Remains on the same row/column.
   if (orientation === 'both') {
-    const prevRow = floatingUi_utils.floor(prevIndex / cols);
+    const prevRow = floor(prevIndex / cols);
     if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
       if (stop) {
         stopEvent(event);
@@ -1942,7 +2206,7 @@ function getGridNavigatedIndex(list, {
         nextIndex = prevIndex;
       }
     }
-    const lastRow = floatingUi_utils.floor(maxIndex / cols) === prevRow;
+    const lastRow = floor(maxIndex / cols) === prevRow;
     if (isIndexOutOfListBounds(list, nextIndex)) {
       if (loopFocus && lastRow) {
         nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(list, {
@@ -1971,12 +2235,19 @@ function isListIndexDisabled(list, index, disabledIndices) {
   if (!isElementVisible(element)) {
     return true;
   }
+
+  // A natively disabled element can never receive focus, so it must always be
+  // skipped, even when `disabledIndices` marks it as enabled. Only
+  // `aria-disabled` items can be focusable-while-disabled.
+  if (element.matches(':disabled')) {
+    return true;
+  }
   return !disabledIndices && (element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true');
 }
 function isHiddenByStyles(styles) {
   return styles.visibility === 'hidden' || styles.visibility === 'collapse';
 }
-function isElementVisible(element, styles = element ? floatingUi_utils.getComputedStyle(element) : null) {
+function isElementVisible(element, styles = element ? getComputedStyle(element) : null) {
   if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
     return false;
   }
@@ -1996,11 +2267,11 @@ function getParentElement(element) {
     return element.parentElement;
   }
   const rootNode = element.getRootNode();
-  return floatingUi_utils.isShadowRoot(rootNode) ? rootNode.host : null;
+  return isShadowRoot(rootNode) ? rootNode.host : null;
 }
 function getDetailsSummary(details) {
   for (const child of Array.from(details.children)) {
-    if (floatingUi_utils.getNodeName(child) === 'summary') {
+    if (getNodeName(child) === 'summary') {
       return child;
     }
   }
@@ -2011,8 +2282,8 @@ function isWithinOpenDetailsSummary(element, details) {
   return !!summary && (element === summary || contains(summary, element));
 }
 function isFocusableCandidate(element) {
-  const nodeName = element ? floatingUi_utils.getNodeName(element) : '';
-  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && floatingUi_utils.getNodeName(element.parentElement) === 'details' && getDetailsSummary(element.parentElement) === element) && (nodeName !== 'details' || getDetailsSummary(element) == null) && (nodeName !== 'input' || element.type !== 'hidden');
+  const nodeName = element ? getNodeName(element) : '';
+  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && getNodeName(element.parentElement) === 'details' && getDetailsSummary(element.parentElement) === element) && (nodeName !== 'details' || getDetailsSummary(element) == null) && (nodeName !== 'input' || element.type !== 'hidden');
 }
 function isFocusableElement(element) {
   if (!isFocusableCandidate(element) || !element.isConnected || element.matches(':disabled')) {
@@ -2020,18 +2291,18 @@ function isFocusableElement(element) {
   }
   for (let current = element; current; current = getParentElement(current)) {
     const isAncestor = current !== element;
-    const isSlot = floatingUi_utils.getNodeName(current) === 'slot';
+    const isSlot = getNodeName(current) === 'slot';
     if (current.hasAttribute('inert')) {
       return false;
     }
-    if (isAncestor && floatingUi_utils.getNodeName(current) === 'details' && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
+    if (isAncestor && getNodeName(current) === 'details' && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
       return false;
     }
   }
   return true;
 }
 function isVisibleInTabbableTree(element, isAncestor) {
-  const styles = floatingUi_utils.getComputedStyle(element);
+  const styles = getComputedStyle(element);
   if (!isAncestor) {
     return isElementVisible(element, styles);
   }
@@ -2040,15 +2311,15 @@ function isVisibleInTabbableTree(element, isAncestor) {
 function getTabIndex(element) {
   const tabIndex = element.tabIndex;
   if (tabIndex < 0) {
-    const nodeName = floatingUi_utils.getNodeName(element);
-    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || floatingUi_utils.isHTMLElement(element) && element.isContentEditable) {
+    const nodeName = getNodeName(element);
+    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || isHTMLElement(element) && element.isContentEditable) {
       return 0;
     }
   }
   return tabIndex;
 }
 function getNamedRadioInput(element) {
-  if (floatingUi_utils.getNodeName(element) !== 'input') {
+  if (getNodeName(element) !== 'input') {
     return null;
   }
   const input = element;
@@ -2072,7 +2343,7 @@ function isTabbableRadio(element, candidates) {
   }) === input;
 }
 function getComposedChildren(container) {
-  if (floatingUi_utils.isHTMLElement(container) && floatingUi_utils.getNodeName(container) === 'slot') {
+  if (isHTMLElement(container) && getNodeName(container) === 'slot') {
     const assignedElements = container.assignedElements({
       flatten: true
     });
@@ -2080,7 +2351,7 @@ function getComposedChildren(container) {
       return assignedElements;
     }
   }
-  if (floatingUi_utils.isHTMLElement(container) && container.shadowRoot) {
+  if (isHTMLElement(container) && container.shadowRoot) {
     return Array.from(container.shadowRoot.children);
   }
   return Array.from(container.children);
@@ -2095,7 +2366,7 @@ function appendCandidates(container, list) {
 }
 function appendMatchingElements(container, selector, list) {
   getComposedChildren(container).forEach(child => {
-    if (floatingUi_utils.isHTMLElement(child) && child.matches(selector)) {
+    if (isHTMLElement(child) && child.matches(selector)) {
       list.push(child);
     }
     appendMatchingElements(child, selector, list);
@@ -2252,7 +2523,7 @@ function unwrapHost(node) {
   if (!node) {
     return null;
   }
-  return floatingUi_utils.isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
+  return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
 }
 const correctElements = (parent, targets) => targets.map(target => {
   if (parent.contains(target)) {
@@ -2282,7 +2553,7 @@ const collectOutsideElements = (root, keepElements, stopElements) => {
       return;
     }
     Array.from(parent.children).forEach(node => {
-      if (floatingUi_utils.getNodeName(node) === 'script') {
+      if (getNodeName(node) === 'script') {
         return;
       }
       if (keepElements.has(node)) {
@@ -2501,12 +2772,7 @@ function useFloatingPortalNode(props = {}) {
       }
       return;
     }
-
-    // React 17 does not use React.useId().
-    if (uniqueId == null) {
-      return;
-    }
-    const resolvedContainer = (containerProp && (floatingUi_utils.isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+    const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
     if (resolvedContainer == null) {
       if (containerRef.current) {
         containerRef.current = null;
@@ -2520,7 +2786,7 @@ function useFloatingPortalNode(props = {}) {
       setPortalNode(null);
       setContainerElement(resolvedContainer);
     }
-  }, [containerProp, parentPortalNode, uniqueId]);
+  }, [containerProp, parentPortalNode]);
   const portalElement = useRenderElement.useRenderElement('div', componentProps, {
     ref: [ref, setPortalNodeRef],
     props: [{
@@ -2533,8 +2799,11 @@ function useFloatingPortalNode(props = {}) {
   // Another call inside `FloatingPortal`/`FloatingPortalLite` then injects the children into `portalElement`.
   const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ReactDOM__namespace.createPortal(portalElement, containerElement) : null;
   return {
-    portalNode,
-    portalSubtree
+    node: portalNode,
+    // `id` and `render` props can override or remove the generated ID. Use the exact
+    // rendered value so `aria-owns` never points at an ID absent from the DOM.
+    nodeId: /*#__PURE__*/React__namespace.isValidElement(portalElement) ? portalElement.props.id : undefined,
+    subtree: portalSubtree
   };
 }
 
@@ -2554,12 +2823,12 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
     style,
     children,
     container,
-    renderGuards,
     ...elementProps
   } = componentProps;
   const {
-    portalNode,
-    portalSubtree
+    node: portalNode,
+    nodeId: portalNodeId,
+    subtree: portalSubtree
   } = useFloatingPortalNode({
     container,
     ref: forwardedRef,
@@ -2574,7 +2843,7 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
   const focusInsideDisabledRef = React__namespace.useRef(false);
   const modal = focusManagerState?.modal;
   const open = focusManagerState?.open;
-  const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+  const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
 
   // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx
   React__namespace.useEffect(() => {
@@ -2636,7 +2905,7 @@ const FloatingPortal = /*#__PURE__*/React__namespace.forwardRef(function Floatin
           }
         }
       }), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx("span", {
-        "aria-owns": portalNode.id,
+        "aria-owns": portalNodeId,
         style: ownerVisuallyHidden
       }), portalNode && /*#__PURE__*/ReactDOM__namespace.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsxRuntime.jsx(FocusGuard, {
         "data-type": "outside",
@@ -2793,7 +3062,7 @@ function resolveRef(maybeRef) {
 }
 
 function getEventType(event, lastInteractionType) {
-  const win = floatingUi_utils.getWindow(getTarget(event));
+  const win = getWindow(getTarget(event));
   if (event instanceof win.KeyboardEvent) {
     return 'keyboard';
   }
@@ -2823,7 +3092,7 @@ function clearDisconnectedPreviouslyFocusedElements() {
 }
 function addPreviouslyFocusedElement(element) {
   clearDisconnectedPreviouslyFocusedElements();
-  if (element && floatingUi_utils.getNodeName(element) !== 'body') {
+  if (element && getNodeName(element) !== 'body') {
     previouslyFocusedElements.push(new WeakRef(element));
     if (previouslyFocusedElements.length > LIST_LIMIT) {
       previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
@@ -2900,11 +3169,10 @@ function FloatingFocusManager(props) {
   } = store.context;
   const getNodeId = useStableCallback(() => dataRef.current.floatingContext?.nodeId);
   const ignoreInitialFocus = initialFocus === false;
-  // If the reference is a combobox and is typeable (e.g. input/textarea),
-  // there are different focus semantics. The guards should not be rendered, but
-  // aria-hidden should be applied to all nodes still. Further, the visually
-  // hidden dismiss button should only appear at the end of the list, not the
-  // start.
+  // A typeable combobox reference (e.g. input/textarea) with `initialFocus={false}`
+  // has different focus semantics: focus is not trapped inside the floating element,
+  // so in the modal case the guards are not rendered, but `aria-hidden` is still
+  // applied to the outside nodes.
   const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
   const initialFocusRef = useValueAsRef(initialFocus);
   const returnFocusRef = useValueAsRef(returnFocus);
@@ -3018,25 +3286,25 @@ function FloatingFocusManager(props) {
         const triggers = store.context.triggerElements;
         const insideElements = getResolvedInsideElements();
         const isRelatedFocusGuard = relatedTarget?.hasAttribute(createAttribute('focus-guard')) && [beforeGuardRef.current, afterGuardRef.current, portalContext?.beforeInsideRef.current, portalContext?.afterInsideRef.current, portalContext?.beforeOutsideRef.current, portalContext?.afterOutsideRef.current, resolveRef(previousFocusableElement), resolveRef(nextFocusableElement)].includes(relatedTarget);
-        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || contains(element, relatedTarget)) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
+        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || insideElements.some(element => element === relatedTarget || contains(element, relatedTarget)) || triggers.hasMatchingElement(trigger => contains(trigger, relatedTarget)) || isRelatedFocusGuard || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
         if (currentTarget === domReference && floatingFocusElement) {
           handleTabIndex(floatingFocusElement);
         }
 
-        // Restore focus to the previous tabbable element index to prevent
+        // Restore focus to the previously focused tabbable element to prevent
         // focus from being lost outside the floating tree.
         if (restoreFocus && currentTarget !== domReference && !isElementVisible(target) && activeElement(doc) === doc.body) {
           // Let `FloatingPortal` effect knows that focus is still inside the
           // floating tree.
-          if (floatingUi_utils.isHTMLElement(floatingFocusElement)) {
+          if (isHTMLElement(floatingFocusElement)) {
             floatingFocusElement.focus();
             // If explicitly requested to restore focus to the popup container, do not search
             // for the next/previous tabbable element.
             if (restoreFocus === 'popup') {
-              // If the element is removed on pointerdown, focus tries to move it,
-              // but since it's removed at the same time, focus gets lost as it
-              // happens after the .focus() call above.
-              // In this case, focus needs to be moved asynchronously.
+              // If the focused element is removed on pointerdown, the browser
+              // tries to move focus to it right after the `.focus()` call above,
+              // but because it's removed in the same tick, focus is lost instead.
+              // Re-focusing asynchronously (next frame) wins that race.
               restoreFocusFrame.request(() => {
                 floatingFocusElement.focus();
               });
@@ -3046,7 +3314,7 @@ function FloatingFocusManager(props) {
           const tabbableContent = getTabbableContent();
           const prevTabbable = lastFocusedTabbableRef.current;
           const nodeToFocus = (prevTabbable && tabbableContent.includes(prevTabbable) ? prevTabbable : null) || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (floatingUi_utils.isHTMLElement(nodeToFocus)) {
+          if (isHTMLElement(nodeToFocus)) {
             nodeToFocus.focus();
           }
         }
@@ -3082,7 +3350,7 @@ function FloatingFocusManager(props) {
         dataRef.current.insideReactTree = false;
       });
     }
-    const domReferenceElement = floatingUi_utils.isHTMLElement(domReference) ? domReference : null;
+    const domReferenceElement = isHTMLElement(domReference) ? domReference : null;
     if (!floating && !domReferenceElement) {
       return undefined;
     }
@@ -3115,9 +3383,11 @@ function FloatingFocusManager(props) {
 
   // Focus the initial element when the floating element opens.
   useIsoLayoutEffect(() => {
-    if (!open || disabled || !floatingUi_utils.isHTMLElement(floatingFocusElement)) {
+    if (!open || disabled || !isHTMLElement(floatingFocusElement)) {
       return;
     }
+    closeTypeRef.current = '';
+    lastInteractionTypeRef.current = '';
     const doc = ownerDocument(floatingFocusElement);
     const previouslyFocusedElement = activeElement(doc);
 
@@ -3149,7 +3419,9 @@ function FloatingFocusManager(props) {
       }
       elToFocus = elToFocus || getDefaultFocusElement();
       const hadFocusInside = contains(floatingFocusElement, activeElement(doc));
-      enqueueFocus(elToFocus, {
+
+      // enqueueFocus returns a rAF-cancel function; we intentionally don't cancel this focus.
+      void enqueueFocus(elToFocus, {
         preventScroll: elToFocus === floatingFocusElement,
         shouldFocus() {
           // This focus is queued on the next animation frame. If the floating element has closed
@@ -3176,13 +3448,11 @@ function FloatingFocusManager(props) {
     }
     const doc = ownerDocument(floatingFocusElement);
     const elementFocusedBeforeOpen = activeElement(doc);
-    // Only nullish interaction types represent programmatic opens. The empty
-    // string default is intentionally not treated as programmatic.
+    // Only an explicit `null` interaction type represents a programmatic open.
+    // `undefined` is normalized to `''` by the prop default, so it never reaches
+    // here as nullish and is intentionally not treated as programmatic.
     const preferPreviousFocus = openInteractionTypeRef.current == null;
     addPreviouslyFocusedElement(elementFocusedBeforeOpen);
-
-    // Dismissing via outside press should always ignore `returnFocus` to
-    // prevent unwanted scrolling.
     function onOpenChangeLocal(details) {
       if (!details.open) {
         closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
@@ -3198,6 +3468,11 @@ function FloatingFocusManager(props) {
       } else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) {
         preventReturnFocusRef.current = false;
       } else {
+        // On outside press, only return focus to the reference when the browser supports the
+        // `focus({ preventScroll })` option; without it, restoring focus scrolls the page.
+        // Chrome on Android and Samsung Internet still don't support `preventScroll`
+        // (https://issues.chromium.org/issues/41453122), so the runtime check keeps return
+        // focus disabled there to avoid the scroll jump.
         let isPreventScrollSupported = false;
         ownerDocument(floatingFocusElement).createElement('div').focus({
           get preventScroll() {
@@ -3213,9 +3488,9 @@ function FloatingFocusManager(props) {
       }
     }
     events.on('openchange', onOpenChangeLocal);
-    function getReturnElement() {
+    function getReturnElement(closeType) {
       const returnFocusValueOrFn = returnFocusRef.current;
-      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
+      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeType) : returnFocusValueOrFn;
 
       // `null` should fallback to default behavior in case of an empty ref.
       if (resolvedReturnFocusValue === undefined || resolvedReturnFocusValue === false) {
@@ -3225,7 +3500,7 @@ function FloatingFocusManager(props) {
         resolvedReturnFocusValue = true;
       }
       const referenceReturnElement = domReference?.isConnected ? domReference : null;
-      const previousReturnElement = elementFocusedBeforeOpen?.isConnected && floatingUi_utils.getNodeName(elementFocusedBeforeOpen) !== 'body' ? elementFocusedBeforeOpen : null;
+      const previousReturnElement = elementFocusedBeforeOpen?.isConnected && getNodeName(elementFocusedBeforeOpen) !== 'body' ? elementFocusedBeforeOpen : null;
       let defaultReturnElement = preferPreviousFocus ? previousReturnElement || referenceReturnElement : referenceReturnElement || previousReturnElement;
       if (!defaultReturnElement) {
         defaultReturnElement = getPreviouslyFocusedElement() || null;
@@ -3243,19 +3518,25 @@ function FloatingFocusManager(props) {
 
       // eslint-disable-next-line react-hooks/exhaustive-deps
       const returnFocusValueOrFn = returnFocusRef.current;
-      const returnElement = getReturnElement();
+      const closeType = closeTypeRef.current;
+      const returnElement = getReturnElement(closeType);
       queueMicrotask(() => {
-        // This is `returnElement`, if it's tabbable, or its first tabbable child.
+        // `returnElement` if it is tabbable, otherwise its first tabbable child,
+        // otherwise `returnElement` itself (which may not be tabbable at all).
         const tabbableReturnElement = getFirstTabbableElement(returnElement);
         const hasExplicitReturnFocus = typeof returnFocusValueOrFn !== 'boolean';
-        if (returnFocusValueOrFn && !preventReturnFocusRef.current && floatingUi_utils.isHTMLElement(tabbableReturnElement) && (
+        if (returnFocusValueOrFn && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (
         // If the focus moved somewhere else after mount, avoid returning focus
         // since it likely entered a different element which should be
         // respected: https://github.com/floating-ui/floating-ui/issues/2607
         !hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {
-          tabbableReturnElement.focus({
+          const focusOptions = {
             preventScroll: true
-          });
+          };
+          if (closeType === 'keyboard') {
+            focusOptions.focusVisible = true;
+          }
+          tabbableReturnElement.focus(focusOptions);
         }
         preventReturnFocusRef.current = false;
       });
@@ -3270,7 +3551,7 @@ function FloatingFocusManager(props) {
       return;
     }
     const activeEl = activeElement(ownerDocument(floating));
-    if (!floatingUi_utils.isHTMLElement(activeEl) || !isTypeableElement(activeEl)) {
+    if (!isHTMLElement(activeEl) || !isTypeableElement(activeEl)) {
       return;
     }
     if (contains(floating, activeEl)) {
@@ -3278,8 +3559,8 @@ function FloatingFocusManager(props) {
     }
   }, [open, floating]);
 
-  // Synchronize the `context` & `modal` value to the FloatingPortal context.
-  // It will decide whether or not it needs to render its own guards.
+  // Synchronize the focus manager state (modal, closeOnFocusOut, open, etc.) to the
+  // FloatingPortal context, which uses it to decide whether to render its own guards.
   useIsoLayoutEffect(() => {
     if (disabled || !portalContext) {
       return undefined;
@@ -3314,7 +3595,8 @@ function FloatingFocusManager(props) {
       onFocus: event => {
         if (modal) {
           const els = getTabbableContent();
-          enqueueFocus(els[els.length - 1]);
+          // enqueueFocus returns a rAF-cancel function we don't need here.
+          void enqueueFocus(els[els.length - 1]);
         } else if (portalContext?.portalNode) {
           preventReturnFocusRef.current = false;
           if (isOutsideEvent(event, portalContext.portalNode)) {
@@ -3330,7 +3612,8 @@ function FloatingFocusManager(props) {
       ref: mergedAfterGuardRef,
       onFocus: event => {
         if (modal) {
-          enqueueFocus(getTabbableContent()[0]);
+          // enqueueFocus returns a rAF-cancel function we don't need here.
+          void enqueueFocus(getTabbableContent()[0]);
         } else if (portalContext?.portalNode) {
           if (closeOnFocusOut) {
             preventReturnFocusRef.current = true;
@@ -3402,7 +3685,11 @@ function useClick(context, props = {}) {
     }
     return {
       onPointerDown(event) {
-        pointerTypeRef.current = event.pointerType;
+        // Screen reader activations (Android TalkBack, desktop screen readers) report a
+        // mouse-like `pointerType`, but `ignoreMouse` must not drop them: hover logic cannot
+        // open for a virtual press since there is no real pointer movement to wait for.
+        // Virtual `touch` presses (iOS VoiceOver) keep their type so `touchOpenDelay` applies.
+        pointerTypeRef.current = isMouseLikePointerType(event.pointerType, true) && isVirtualPointerEvent(event.nativeEvent) ? 'virtual' : event.pointerType;
       },
       onMouseDown(event) {
         const pointerType = pointerTypeRef.current;
@@ -3582,7 +3869,7 @@ function useDismiss(context, props = {}) {
   });
   React__namespace.useEffect(() => {
     if (!open || !enabled) {
-      return undefined;
+      return clearInsideReactTree;
     }
     dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
     dataRef.current.__outsidePressBubbles = outsidePressBubbles;
@@ -3651,18 +3938,18 @@ function useDismiss(context, props = {}) {
       }
       const target = getTarget(event);
       const inertSelector = `[${createAttribute('inert')}]`;
-      const targetRoot = floatingUi_utils.isElement(target) ? target.getRootNode() : null;
-      const markers = Array.from((floatingUi_utils.isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
+      const targetRoot = isElement(target) ? target.getRootNode() : null;
+      const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select('floatingElement'))).querySelectorAll(inertSelector));
       const triggers = store.context.triggerElements;
 
       // If another trigger is clicked, don't close the floating element.
       if (target && (triggers.hasElement(target) || triggers.hasMatchingElement(trigger => contains(trigger, target)))) {
         return;
       }
-      let targetRootAncestor = floatingUi_utils.isElement(target) ? target : null;
-      while (targetRootAncestor && !floatingUi_utils.isLastTraversableNode(targetRootAncestor)) {
-        const nextParent = floatingUi_utils.getParentNode(targetRootAncestor);
-        if (floatingUi_utils.isLastTraversableNode(nextParent) || !floatingUi_utils.isElement(nextParent)) {
+      let targetRootAncestor = isElement(target) ? target : null;
+      while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+        const nextParent = getParentNode(targetRootAncestor);
+        if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
           break;
         }
         targetRootAncestor = nextParent;
@@ -3670,7 +3957,7 @@ function useDismiss(context, props = {}) {
 
       // Check if the click occurred on a third-party element injected after the
       // floating element rendered.
-      if (markers.length && floatingUi_utils.isElement(target) && !isRootElement(target) &&
+      if (markers.length && isElement(target) && !isRootElement(target) &&
       // Clicked on a direct ancestor (e.g. FloatingOverlay).
       !contains(target, store.select('floatingElement')) &&
       // If the target root element contains none of the markers, then the
@@ -3681,9 +3968,9 @@ function useDismiss(context, props = {}) {
 
       // Check if the click occurred on the scrollbar
       // Skip for touch events: scrollbars don't receive touch events on most platforms
-      if (floatingUi_utils.isHTMLElement(target) && !('touches' in event)) {
-        const lastTraversableNode = floatingUi_utils.isLastTraversableNode(target);
-        const style = floatingUi_utils.getComputedStyle(target);
+      if (isHTMLElement(target) && !('touches' in event)) {
+        const lastTraversableNode = isLastTraversableNode(target);
+        const style = getComputedStyle(target);
         const scrollRe = /auto|scroll/;
         const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
         const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
@@ -3860,9 +4147,9 @@ function useDismiss(context, props = {}) {
       preventedPressSuppressionTimeout.clear();
       resetPressStartState();
       suppressNextOutsideClickRef.current = false;
+      clearInsideReactTree();
     };
   }, [dataRef, floatingElement, escapeKey$1, outsidePressEnabled, outsidePress$1, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout]);
-  React__namespace.useEffect(clearInsideReactTree, [outsidePress$1, clearInsideReactTree]);
   const reference = React__namespace.useMemo(() => ({
     onKeyDown: closeOnEscapeKeyDown,
     onPointerDown: closeOnReferencePress,
@@ -3896,12 +4183,12 @@ function useDismiss(context, props = {}) {
 }
 
 const selectors = {
-  open: createSelector(state => state.open),
-  transitionStatus: createSelector(state => state.transitionStatus),
-  domReferenceElement: createSelector(state => state.domReferenceElement),
-  referenceElement: createSelector(state => state.positionReference ?? state.referenceElement),
-  floatingElement: createSelector(state => state.floatingElement),
-  floatingId: createSelector(state => state.floatingId)
+  open: state => state.open,
+  transitionStatus: state => state.transitionStatus,
+  domReferenceElement: state => state.domReferenceElement,
+  referenceElement: state => state.positionReference ?? state.referenceElement,
+  floatingElement: state => state.floatingElement,
+  floatingId: state => state.floatingId
 };
 class FloatingRootStore extends ReactStore {
   constructor(options) {
@@ -4012,7 +4299,7 @@ function useSyncedFloatingRootContext(options) {
       referenceElement,
       floatingElement
     };
-    if (floatingUi_utils.isElement(referenceElement)) {
+    if (isElement(referenceElement)) {
       valuesToSync.domReferenceElement = referenceElement;
     }
     if (store.state.positionReference === store.state.referenceElement) {
@@ -4090,44 +4377,14 @@ function useTransitionStatus(open, enableIdleState = false, deferEndingState = f
   };
 }
 
-let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {
-  /**
-   * Present when the component is animating in.
-   */
-  TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
-  /**
-   * Present when the component is animating out.
-   */
-  TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
-  return TransitionStatusDataAttributes;
-}({});
-const STARTING_HOOK = {
-  [TransitionStatusDataAttributes.startingStyle]: ''
-};
-const ENDING_HOOK = {
-  [TransitionStatusDataAttributes.endingStyle]: ''
-};
-const transitionStatusMapping = {
-  transitionStatus(value) {
-    if (value === 'starting') {
-      return STARTING_HOOK;
-    }
-    if (value === 'ending') {
-      return ENDING_HOOK;
-    }
-    return null;
-  }
-};
-
 /**
  * Executes a function once all animations have finished on the provided element.
+ * If an animation is canceled, waits for any replacement animations before executing.
  * @param elementOrRef - The element to watch for animations.
  * @param waitForStartingStyleRemoved - Whether to wait for [data-starting-style] to be removed before checking for animations.
- * @param treatAbortedAsFinished - Whether to treat aborted animations as finished. If `false`, and there are aborted animations,
- *   the function will check again if any new animations have started and wait for them to finish.
  * @returns A function that takes a callback to execute once all animations have finished, and an optional AbortSignal to abort the callback
  */
-function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, treatAbortedAsFinished = true) {
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false) {
   const frame = useAnimationFrame();
   return useStableCallback((fnToExecute,
   /**
@@ -4156,23 +4413,22 @@ function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false
         if (!signal?.aborted) {
           done();
         }
-      }).catch(() => {
-        if (treatAbortedAsFinished) {
-          if (!signal?.aborted) {
-            done();
-          }
+      }, () => {
+        if (signal?.aborted) {
           return;
         }
         const currentAnimations = resolvedElement.getAnimations();
-        if (!signal?.aborted && currentAnimations.length > 0 && currentAnimations.some(animation => animation.pending || animation.playState !== 'finished')) {
+        if (currentAnimations.some(animation => animation.pending || animation.playState !== 'finished')) {
           // Sometimes animations can be aborted because a property they depend on changes while the animation plays.
           // In such cases, we need to re-check if any new animations have started.
           exec();
+          return;
         }
+        done();
       });
     }
     if (waitForStartingStyleRemoved) {
-      const startingStyleAttribute = TransitionStatusDataAttributes.startingStyle;
+      const startingStyleAttribute = 'data-starting-style';
 
       // If `[data-starting-style]` isn't present, fall back to waiting one more frame
       // to give "open" animations a chance to be registered.
@@ -4212,7 +4468,7 @@ function useOpenChangeComplete(parameters) {
     onComplete: onCompleteParam
   } = parameters;
   const onComplete = useStableCallback(onCompleteParam);
-  const runOnceAnimationsFinish = useAnimationsFinished(ref, open, false);
+  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
   React__namespace.useEffect(() => {
     if (!enabled) {
       return undefined;
@@ -4238,14 +4494,26 @@ const FOCUSABLE_POPUP_PROPS = {
 function createDefaultInitialFocus(popupRef) {
   return interactionType => interactionType === 'touch' ? popupRef.current : true;
 }
-function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement = false) {
+
+/**
+ * The subset of a popup handle that a Root needs to bind its store to. Both the real handle classes
+ * and any test double satisfy it.
+ */
+
+/**
+ * Creates and owns a popup store on behalf of a Root part. The store is created exactly once, with
+ * controlled props and root state synced separately after creation. Sets up the synced floating
+ * root context and returns the store.
+ *
+ * @param createStore Factory that builds the store. Called exactly once, receiving the floating id
+ * and whether the popup is nested inside another floating element, both resolved on the first render.
+ * @param treatPopupAsFloatingElement Whether the popup element is passed to Floating UI as the
+ * floating element instead of the default positioner.
+ */
+function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
   const floatingId = useId();
   const nested = useFloatingParentNodeId() != null;
-  const internalStoreRef = React__namespace.useRef(null);
-  if (externalStore === undefined && internalStoreRef.current === null) {
-    internalStoreRef.current = createStore(floatingId, nested);
-  }
-  const store = externalStore ?? internalStoreRef.current;
+  const store = useRenderElement.useRefWithInit(() => createStore(floatingId, nested)).current;
   useSyncedFloatingRootContext({
     popupStore: store,
     treatPopupAsFloatingElement,
@@ -4254,10 +4522,27 @@ function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement =
     nested,
     onOpenChange: store.setOpen
   });
-  return {
-    store,
-    internalStore: internalStoreRef.current
-  };
+  return store;
+}
+
+/**
+ * Attaches a Root's store to a handle for this component's committed lifetime. Popup Roots render
+ * it before their interactions and user children so its layout effect runs before descendant layout
+ * effects. This lets descendants call the handle during the Root's initial commit without attaching
+ * during render, which would leak suspended or abandoned stores. Store subscribers are notified by
+ * `attachStore` in this ordinary layout phase, where React permits synchronous updates.
+ *
+ * Popup Roots must render this component only when a handle is present so handle-less Roots avoid
+ * mounting an extra fiber and layout effect.
+ */
+function PopupHandleAttachment({
+  handle,
+  store
+}) {
+  useIsoLayoutEffect(() => {
+    return handle.attachStore(store);
+  }, [handle, store]);
+  return null;
 }
 
 /**
@@ -4322,19 +4607,6 @@ function attachPreventUnmountOnClose(eventDetails) {
   };
   return () => preventUnmountOnClose;
 }
-function useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerId) {
-  useOnFirstRender(() => {
-    if (openProp === undefined && store.state.open === false && defaultOpen) {
-      // Avoid notifying detached trigger subscribers while the Root is rendering.
-      store.state = {
-        ...store.state,
-        open: true,
-        activeTriggerId: defaultTriggerId,
-        preventUnmountingOnClose: false
-      };
-    }
-  });
-}
 
 /**
  * Sets up trigger data forwarding to the store.
@@ -4347,11 +4619,11 @@ function useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerId) {
 function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
   const isMountedByThisTrigger = store.useState('isMountedByTrigger', triggerId);
   const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
-  const registerTrigger = useStableCallback(element => {
-    baseRegisterTrigger(element);
-    if (!element) {
-      return;
-    }
+
+  // Applies trigger-owned state (active-trigger ownership and payload) when the trigger registers.
+  // Stable so payload/`stateUpdates` changes do not change the ref identity (which would needlessly
+  // churn registration); it reads the latest closure values when invoked.
+  const applyTriggerData = useStableCallback(element => {
     const open = store.select('open');
     const activeTriggerId = store.select('activeTriggerId');
     if (activeTriggerId === triggerId) {
@@ -4372,6 +4644,18 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
       });
     }
   });
+
+  // Intentionally NOT stable. Its identity is derived from `baseRegisterTrigger`, which is keyed on
+  // `[store, id]`, so when a handle-backed trigger's store pointer swaps the merged ref re-fires —
+  // unregistering from the previous store and registering into the new one. This lets a detached
+  // trigger follow its handle's currently-attached store across attach/detach/remount. (A stable
+  // callback would keep its identity and never re-fire on a store swap.)
+  const registerTrigger = React__namespace.useCallback(element => {
+    baseRegisterTrigger(element);
+    if (element) {
+      applyTriggerData(element);
+    }
+  }, [baseRegisterTrigger, applyTriggerData]);
   useIsoLayoutEffect(() => {
     if (isMountedByThisTrigger) {
       store.update({
@@ -4391,12 +4675,17 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
  *
  * When a popup opens without an explicit trigger id and exactly one trigger is registered, that
  * trigger is claimed as the active trigger. When the active trigger id is still registered but its
- * element changed, the active element is refreshed. When the active trigger unregisters, the
- * default path preserves existing ownership so non-closing popup families do not silently claim a
- * different trigger while staying open.
+ * element changed, the active element is refreshed. When the active trigger id is missing from the
+ * registry but the same element is still registered under a different id (e.g. the rendered trigger
+ * carries its own DOM `id` that differs from Base UI's internal trigger id), the active id is
+ * reassociated to the registered id instead of being treated as lost. When the active trigger
+ * unregisters, the default path preserves existing ownership so non-closing popup families do not
+ * silently claim a different trigger while staying open.
  *
- * If `closeOnActiveTriggerUnmount` is enabled, unregistering the active trigger requests a close
- * after a microtask so a same-tick replacement trigger with the same id can register first.
+ * If `closeOnActiveTriggerUnmount` is enabled, unregistering a previously resolved active trigger
+ * requests a close after a microtask so a same-tick replacement trigger with the same id can
+ * register first. An active trigger id that has not matched a registered trigger yet is treated as
+ * pending and does not request a close.
  *
  * This should be called on the Root part.
  *
@@ -4407,10 +4696,22 @@ function useImplicitActiveTrigger(store, options = {}) {
   const {
     closeOnActiveTriggerUnmount = false
   } = options;
+  // Distinguishes a trigger that unmounted from a new active trigger that has not hydrated yet.
+  const resolvedActiveTriggerIdRef = React__namespace.useRef(null);
   const open = store.useState('open');
   const reactiveTriggerCount = store.useState('triggerCount');
+  // Subscribe to the active trigger id so the reconciliation below reruns when ownership moves to
+  // another trigger while the popup stays open (e.g. a focus/hover handoff between triggers).
+  const activeTriggerId = store.useState('activeTriggerId');
+  // Subscribe to the active trigger element so the reconciliation reruns when a pending active
+  // trigger registers in a commit where the trigger count nets out unchanged (registration
+  // forwards the element to the store when the registering trigger matches the active id).
+  // Without this, the id would never be marked resolved and a later genuine unmount would be
+  // misclassified as pending, disabling `closeOnActiveTriggerUnmount`.
+  const reactiveActiveTriggerElement = store.useState('activeTriggerElement');
   useIsoLayoutEffect(() => {
     if (!open) {
+      resolvedActiveTriggerIdRef.current = null;
       if (store.state.triggerCount !== 0) {
         store.set('triggerCount', 0);
       }
@@ -4421,22 +4722,42 @@ function useImplicitActiveTrigger(store, options = {}) {
     if (store.state.triggerCount !== triggerCount) {
       stateUpdates.triggerCount = triggerCount;
     }
-    const activeTriggerId = store.select('activeTriggerId');
+    const currentActiveTriggerId = store.select('activeTriggerId');
     let lostActiveTriggerId = null;
-    if (activeTriggerId) {
-      const activeTriggerElement = store.context.triggerElements.getById(activeTriggerId);
+    if (currentActiveTriggerId) {
+      const activeTriggerElement = store.context.triggerElements.getById(currentActiveTriggerId);
       if (!activeTriggerElement) {
-        lostActiveTriggerId = activeTriggerId;
-      } else if (activeTriggerElement !== store.state.activeTriggerElement) {
-        stateUpdates.activeTriggerElement = activeTriggerElement;
+        for (const [triggerId, triggerElement] of store.context.triggerElements.entries()) {
+          if (triggerElement === store.state.activeTriggerElement) {
+            stateUpdates.activeTriggerId = triggerId;
+            stateUpdates.activeTriggerElement = triggerElement;
+            resolvedActiveTriggerIdRef.current = triggerId;
+            break;
+          }
+        }
+        if (stateUpdates.activeTriggerId === undefined) {
+          if (resolvedActiveTriggerIdRef.current === currentActiveTriggerId) {
+            lostActiveTriggerId = currentActiveTriggerId;
+          } else {
+            resolvedActiveTriggerIdRef.current = null;
+          }
+        }
+      } else {
+        resolvedActiveTriggerIdRef.current = currentActiveTriggerId;
+        if (activeTriggerElement !== store.state.activeTriggerElement) {
+          stateUpdates.activeTriggerElement = activeTriggerElement;
+        }
       }
+    } else {
+      resolvedActiveTriggerIdRef.current = null;
     }
-    if (!lostActiveTriggerId && !activeTriggerId && triggerCount === 1) {
+    if (!lostActiveTriggerId && !currentActiveTriggerId && triggerCount === 1) {
       const iteratorResult = store.context.triggerElements.entries().next();
       if (!iteratorResult.done) {
         const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
         stateUpdates.activeTriggerId = implicitTriggerId;
         stateUpdates.activeTriggerElement = implicitTriggerElement;
+        resolvedActiveTriggerIdRef.current = implicitTriggerId;
       }
     }
     if (stateUpdates.triggerCount !== undefined || stateUpdates.activeTriggerId !== undefined || stateUpdates.activeTriggerElement !== undefined) {
@@ -4461,7 +4782,7 @@ function useImplicitActiveTrigger(store, options = {}) {
         });
       }
     }
-  }, [open, store, reactiveTriggerCount, closeOnActiveTriggerUnmount]);
+  }, [open, store, reactiveTriggerCount, activeTriggerId, reactiveActiveTriggerElement, closeOnActiveTriggerUnmount]);
 }
 
 /**
@@ -4539,13 +4860,33 @@ function usePopupRootSync(store, open) {
   }, [store]);
 }
 
+/**
+ * Development-only reverse index of element to registered id, keyed by the owning map.
+ *
+ * Registration would otherwise have to scan every entry to detect an element claimed by two ids,
+ * making the mount of many triggers sharing one handle quadratic. Kept module-scoped, lazily
+ * initialized, and read only from `process.env.NODE_ENV` guards so production builds drop it along
+ * with the checks.
+ */
+let devElementIdsByMap;
+function getDevElementIds(map) {
+  devElementIdsByMap ??= new WeakMap();
+  let elementIds = devElementIdsByMap.get(map);
+  if (!elementIds) {
+    elementIds = new WeakMap();
+    devElementIdsByMap.set(map, elementIds);
+  }
+  return elementIds;
+}
+
 /**
  * Data structure to keep track of popup trigger elements by their IDs.
- * Uses both a set of Elements and a map of IDs to Elements for efficient lookups.
+ *
+ * Element lookups iterate the id map rather than maintaining a parallel Set. Registration is O(1),
+ * while `hasElement` and `hasMatchingElement` are linear in the number of triggers.
  */
 class PopupTriggerMap {
   constructor() {
-    this.elementsSet = new Set();
     this.idMap = new Map();
   }
 
@@ -4555,49 +4896,56 @@ class PopupTriggerMap {
    * Note: The provided element is assumed to not be registered under multiple IDs.
    */
   add(id, element) {
-    const existingElement = this.idMap.get(id);
-    if (existingElement === element) {
-      return;
-    }
-    if (existingElement !== undefined) {
-      // We assume that the same element won't be registered under multiple ids.
-      // This is safe considering how useTriggerRegistration is implemented.
-      this.elementsSet.delete(existingElement);
-    }
-    this.elementsSet.add(element);
-    this.idMap.set(id, element);
     if (process.env.NODE_ENV !== 'production') {
-      if (this.elementsSet.size !== this.idMap.size) {
+      const elementIds = getDevElementIds(this);
+      const existingId = elementIds.get(element);
+      if (existingId !== undefined && existingId !== id) {
         // TODO: fix mui/no-guarded-throw
         // eslint-disable-next-line mui/no-guarded-throw
         throw new Error('Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.');
       }
+
+      // Reusing an id for a different element evicts the previous one, so it must lose its claim
+      // on the id or a later registration under a different id would be reported as a duplicate.
+      const previousElement = this.idMap.get(id);
+      if (previousElement !== undefined && previousElement !== element) {
+        elementIds.delete(previousElement);
+      }
+      elementIds.set(element, id);
     }
+    this.idMap.set(id, element);
   }
 
   /**
    * Removes the trigger element with the given ID.
    */
   delete(id) {
-    const element = this.idMap.get(id);
-    if (element) {
-      this.elementsSet.delete(element);
-      this.idMap.delete(id);
+    if (process.env.NODE_ENV !== 'production') {
+      const element = this.idMap.get(id);
+      if (element !== undefined) {
+        devElementIdsByMap?.get(this)?.delete(element);
+      }
     }
+    this.idMap.delete(id);
   }
 
   /**
    * Whether the given element is registered as a trigger.
    */
   hasElement(element) {
-    return this.elementsSet.has(element);
+    for (const registered of this.idMap.values()) {
+      if (registered === element) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /**
    * Whether there is a registered trigger element matching the given predicate.
    */
   hasMatchingElement(predicate) {
-    for (const element of this.elementsSet) {
+    for (const element of this.idMap.values()) {
       if (predicate(element)) {
         return true;
       }
@@ -4623,7 +4971,7 @@ class PopupTriggerMap {
    * Returns an iterable of all registered trigger elements.
    */
   elements() {
-    return this.elementsSet.values();
+    return this.idMap.values();
   }
 
   /**
@@ -4683,14 +5031,11 @@ function useValueChanged(value, onChange) {
   const valueRef = React__namespace.useRef(value);
   const onChangeCallback = useStableCallback(onChange);
   useIsoLayoutEffect(() => {
-    if (valueRef.current === value) {
-      return;
+    if (valueRef.current !== value) {
+      onChangeCallback(valueRef.current);
     }
-    onChangeCallback(valueRef.current);
-  }, [value, onChangeCallback]);
-  useIsoLayoutEffect(() => {
     valueRef.current = value;
-  }, [value]);
+  }, [value, onChangeCallback]);
 }
 
 function useOpenMethodTriggerProps(open, setOpenMethod) {
@@ -4733,9 +5078,6 @@ function useOpenInteractionType(open) {
   }), [openMethod, triggerProps]);
 }
 
-/**
- * @internal
- */
 const DirectionContext = /*#__PURE__*/React__namespace.createContext(undefined);
 if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
 function useDirection() {
@@ -4794,6 +5136,30 @@ function useFocusableWhenDisabled(parameters) {
   };
 }
 
+/**
+ * Dispatches a constructed click on the target so it carries the source event's
+ * modifier state, which `click()` always reports as unpressed. Like `click()`,
+ * the untrusted click still runs native activation behavior (form submission,
+ * link navigation).
+ * `detail` defaults to 0 (the native convention for keyboard-generated clicks);
+ * pass `detail: 1` when the click represents a mouse gesture so consumers keying
+ * off `detail === 0` don't classify it as a keyboard activation.
+ */
+function dispatchClickWithModifiers(target, sourceEvent, {
+  detail = 0
+} = {}) {
+  target.dispatchEvent(new (getWindow(target).PointerEvent)('click', {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    detail,
+    shiftKey: sourceEvent.shiftKey,
+    ctrlKey: sourceEvent.ctrlKey,
+    altKey: sourceEvent.altKey,
+    metaKey: sourceEvent.metaKey
+  }));
+}
+
 function useButton(parameters = {}) {
   const {
     disabled = false,
@@ -4894,24 +5260,34 @@ function useButton(parameters = {}) {
             return;
           }
           event.preventDefault();
-          if (isLink || isNativeButton && isButton) {
-            currentTarget.click();
-            event.preventBaseUIHandler();
-          } else if (shouldClick) {
-            externalOnClick?.(event);
+
+          // Only a native-mode item that isn't a real <button> is excluded.
+          if (!isNativeButton || isButton) {
             event.preventBaseUIHandler();
+            dispatchClickWithModifiers(currentTarget, event);
           }
           return;
         }
 
         // Keyboard accessibility for native and non-native elements.
-        if (shouldClick) {
-          if (!isNativeButton && (isSpaceKey || isEnterKey)) {
+        if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
+          // Space activates links on keyup (`role="button"` semantics, matching the
+          // composite path); prevent the page scroll Space would otherwise trigger.
+          // Enter is left to the browser's native link activation.
+          if (isCurrentTarget && isLink && isSpaceKey) {
             event.preventDefault();
           }
-          if (!isNativeButton && isEnterKey) {
-            externalOnClick?.(event);
-          }
+          return;
+        }
+
+        // Match native buttons: preventing the keydown's default cancels activation.
+        if (event.defaultPrevented) {
+          return;
+        }
+        event.preventDefault();
+        if (isEnterKey) {
+          event.preventBaseUIHandler();
+          dispatchClickWithModifiers(currentTarget, event);
         }
       },
       onKeyUp(event) {
@@ -4931,9 +5307,14 @@ function useButton(parameters = {}) {
           return;
         }
 
-        // Keyboard accessibility for non interactive elements
-        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && event.key === ' ') {
-          externalOnClick?.(event);
+        // Keyboard accessibility for non interactive elements.
+        // Match native buttons: preventing the keyup's default cancels Space activation.
+        // Limitation: unlike a native <button>, a prevented *keydown* cannot cancel the
+        // activation — no state is kept between keydown and keyup, so we can't tell
+        // whether the keydown was prevented or even happened on this element.
+        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === ' ') {
+          event.preventBaseUIHandler();
+          dispatchClickWithModifiers(event.currentTarget, event);
         }
       },
       onPointerDown(event) {
@@ -4959,12 +5340,41 @@ function useButton(parameters = {}) {
   };
 }
 function isButtonElement(elem) {
-  return floatingUi_utils.isHTMLElement(elem) && elem.tagName === 'BUTTON';
+  return isHTMLElement(elem) && elem.tagName === 'BUTTON';
 }
 function isValidLinkElement(elem) {
-  return Boolean(elem?.tagName === 'A' && elem?.href);
+  return isHTMLElement(elem) && elem.tagName === 'A' && Boolean(elem.href);
 }
 
+let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {
+  /**
+   * Present when the component begins animating in.
+   */
+  TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
+  /**
+   * Present when the component is animating out.
+   */
+  TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
+  return TransitionStatusDataAttributes;
+}({});
+const STARTING_HOOK = {
+  'data-starting-style': ''
+};
+const ENDING_HOOK = {
+  'data-ending-style': ''
+};
+const transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === 'starting') {
+      return STARTING_HOOK;
+    }
+    if (value === 'ending') {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};
+
 let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
   /**
    * Present when the popup is open.
@@ -4975,7 +5385,7 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
    */
   CommonPopupDataAttributes["closed"] = "data-closed";
   /**
-   * Present when the popup is animating in.
+   * Present when the popup begins animating in.
    */
   CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
   /**
@@ -4998,32 +5408,24 @@ let CommonPopupDataAttributes = function (CommonPopupDataAttributes) {
   CommonPopupDataAttributes["align"] = "data-align";
   return CommonPopupDataAttributes;
 }({});
-let CommonTriggerDataAttributes = /*#__PURE__*/function (CommonTriggerDataAttributes) {
-  /**
-   * Present when the popup is open.
-   */
-  CommonTriggerDataAttributes["popupOpen"] = "data-popup-open";
-  /**
-   * Present when a pressable trigger is pressed.
-   */
-  CommonTriggerDataAttributes["pressed"] = "data-pressed";
-  return CommonTriggerDataAttributes;
-}({});
+
+// Literal keys (instead of enum member references) keep the docs-only enums above
+// tree-shakeable: a runtime reference would retain the whole enum IIFE in every bundle.
 const TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: ''
+  'data-popup-open': ''
 };
 const PRESSABLE_TRIGGER_HOOK = {
-  [CommonTriggerDataAttributes.popupOpen]: '',
-  [CommonTriggerDataAttributes.pressed]: ''
+  'data-popup-open': '',
+  'data-pressed': ''
 };
 const POPUP_OPEN_HOOK = {
-  [CommonPopupDataAttributes.open]: ''
+  'data-open': ''
 };
 const POPUP_CLOSED_HOOK = {
-  [CommonPopupDataAttributes.closed]: ''
+  'data-closed': ''
 };
 const ANCHOR_HIDDEN_HOOK = {
-  [CommonPopupDataAttributes.anchorHidden]: ''
+  'data-anchor-hidden': ''
 };
 const triggerOpenStateMapping = {
   open(value) {
@@ -5055,6 +5457,10 @@ const popupStateMapping = {
     return null;
   }
 };
+const popupTransitionStateMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
 
 function inertValue(value) {
   if (useRenderElement.isReactVersionAtLeast(19)) {
@@ -5096,12 +5502,21 @@ if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "Inter
 let originalHtmlStyles = {};
 let originalBodyStyles = {};
 let originalHtmlScrollBehavior = '';
+
+// The viewport's overflow comes from <html> when it establishes its own scroll container, and
+// propagates from <body> otherwise. An `overflow` style on the other element doesn't lock the page.
+function getViewportScroller(html, body) {
+  return isOverflowElement(html) ? html : body;
+}
+function isPageScrollLocked(win, html, body) {
+  return /hidden|clip/.test(win.getComputedStyle(getViewportScroller(html, body)).overflowY);
+}
 function hasInsetScrollbars(referenceElement) {
   if (typeof document === 'undefined') {
     return false;
   }
   const doc = ownerDocument(referenceElement);
-  const win = floatingUi_utils.getWindow(doc);
+  const win = getWindow(doc);
   return win.innerWidth - doc.documentElement.clientWidth > 0;
 }
 function supportsStableScrollbarGutter(referenceElement) {
@@ -5112,7 +5527,7 @@ function supportsStableScrollbarGutter(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const scrollContainer = floatingUi_utils.isOverflowElement(html) ? html : body;
+  const scrollContainer = getViewportScroller(html, body);
   const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
   const originalHtmlStyleGutter = html.style.scrollbarGutter;
   html.style.scrollbarGutter = 'stable';
@@ -5133,7 +5548,7 @@ function preventScrollOverlayScrollbars(referenceElement) {
   // won't have any effect.
   // But if <body> has an `overflow` style (like `overflow-x: hidden`), we need to lock it
   // instead, as sticky elements shift otherwise.
-  const elementToLock = floatingUi_utils.isOverflowElement(html) ? html : body;
+  const elementToLock = getViewportScroller(html, body);
   const originalElementToLockStyles = {
     overflowY: elementToLock.style.overflowY,
     overflowX: elementToLock.style.overflowX
@@ -5150,7 +5565,7 @@ function preventScrollInsetScrollbars(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const win = floatingUi_utils.getWindow(html);
+  const win = getWindow(html);
   let scrollTop = 0;
   let scrollLeft = 0;
   let updateGutterOnly = false;
@@ -5198,7 +5613,7 @@ function preventScrollInsetScrollbars(referenceElement) {
     // with whitespace. Warn if <body> has margins?
     const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
     const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
-    const elementToLock = floatingUi_utils.isOverflowElement(html) ? html : body;
+    const elementToLock = getViewportScroller(html, body);
     updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
 
     /*
@@ -5228,7 +5643,9 @@ function preventScrollInsetScrollbars(referenceElement) {
       height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',
       width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',
       boxSizing: 'border-box',
-      overflow: 'hidden',
+      // Assign the longhands that `cleanup` restores, so nothing is left behind.
+      overflowY: 'hidden',
+      overflowX: 'hidden',
       scrollBehavior: 'unset'
     });
     body.scrollTop = scrollTop;
@@ -5293,11 +5710,30 @@ class ScrollLocker {
     }
     const doc = ownerDocument(referenceElement);
     const html = doc.documentElement;
-    const htmlOverflowY = floatingUi_utils.getWindow(html).getComputedStyle(html).overflowY;
+    const body = doc.body;
+    const win = getWindow(html);
+
+    // The page is already locked, either by the site author or by a non-Base UI overlay that
+    // hasn't cleaned up yet. Leave it alone and wait for the lock to clear before taking over,
+    // otherwise we'd snapshot the locked state and restore it after our own lock is released.
+    if (isPageScrollLocked(win, html, body)) {
+      const observer = new win.MutationObserver(() => {
+        if (isPageScrollLocked(win, html, body)) {
+          return;
+        }
+        observer.disconnect();
+        this.restore = null;
+        this.lock(referenceElement);
+      });
 
-    // If the site author already hid overflow on <html>, respect it and bail out.
-    if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {
-      this.restore = useRenderElement.NOOP;
+      // Watch every attribute: locks are applied through inline styles, classes, or attributes
+      // paired with a stylesheet (`data-scroll-locked` in react-remove-scroll, for example).
+      const options = {
+        attributes: true
+      };
+      observer.observe(html, options);
+      observer.observe(body, options);
+      this.restore = () => observer.disconnect();
       return;
     }
     const hasOverlayScrollbars = ios || !hasInsetScrollbars(referenceElement);
@@ -5332,6 +5768,7 @@ exports.ARROW_DOWN = ARROW_DOWN;
 exports.ARROW_LEFT = ARROW_LEFT;
 exports.ARROW_RIGHT = ARROW_RIGHT;
 exports.ARROW_UP = ARROW_UP;
+exports.AnimationFrame = AnimationFrame;
 exports.BASE_UI_SWIPE_IGNORE_SELECTOR = BASE_UI_SWIPE_IGNORE_SELECTOR;
 exports.CLICK_TRIGGER_IDENTIFIER = CLICK_TRIGGER_IDENTIFIER;
 exports.CommonPopupDataAttributes = CommonPopupDataAttributes;
@@ -5348,6 +5785,7 @@ exports.FocusGuard = FocusGuard;
 exports.InternalBackdrop = InternalBackdrop;
 exports.PATIENT_CLICK_THRESHOLD = PATIENT_CLICK_THRESHOLD;
 exports.POPUP_COLLISION_AVOIDANCE = POPUP_COLLISION_AVOIDANCE;
+exports.PopupHandleAttachment = PopupHandleAttachment;
 exports.PopupTriggerMap = PopupTriggerMap;
 exports.ReactStore = ReactStore;
 exports.SafeReact = SafeReact;
@@ -5361,33 +5799,57 @@ exports.android = android;
 exports.attachPreventUnmountOnClose = attachPreventUnmountOnClose;
 exports.cancelOpen = cancelOpen;
 exports.chipRemovePress = chipRemovePress;
+exports.clamp = clamp;
 exports.clearPress = clearPress;
 exports.closePress = closePress;
 exports.closeWatcher = closeWatcher;
 exports.contains = contains;
 exports.createAttribute = createAttribute;
 exports.createChangeEventDetails = createChangeEventDetails;
+exports.createCoords = createCoords;
 exports.createDefaultInitialFocus = createDefaultInitialFocus;
 exports.createGenericEventDetails = createGenericEventDetails;
-exports.createSelector = createSelector;
 exports.decrementPress = decrementPress;
+exports.dispatchClickWithModifiers = dispatchClickWithModifiers;
 exports.enqueueFocus = enqueueFocus;
 exports.error = error;
 exports.escapeKey = escapeKey;
+exports.evaluate = evaluate;
 exports.fastComponent = fastComponent;
 exports.fastComponentRef = fastComponentRef;
 exports.findNonDisabledListIndex = findNonDisabledListIndex;
+exports.floor = floor;
 exports.focusOut = focusOut;
 exports.gecko = gecko;
+exports.getAlignment = getAlignment;
+exports.getAlignmentAxis = getAlignmentAxis;
+exports.getAlignmentSides = getAlignmentSides;
+exports.getAxisLength = getAxisLength;
+exports.getComputedStyle = getComputedStyle;
+exports.getContainingBlock = getContainingBlock;
+exports.getDocumentElement = getDocumentElement;
+exports.getExpandedPlacements = getExpandedPlacements;
 exports.getFloatingFocusElement = getFloatingFocusElement;
+exports.getFrameElement = getFrameElement;
 exports.getGridNavigatedIndex = getGridNavigatedIndex;
 exports.getMaxListIndex = getMaxListIndex;
 exports.getMinListIndex = getMinListIndex;
 exports.getNextTabbable = getNextTabbable;
 exports.getNodeChildren = getNodeChildren;
+exports.getNodeName = getNodeName;
+exports.getNodeScroll = getNodeScroll;
+exports.getOppositeAxis = getOppositeAxis;
+exports.getOppositeAxisPlacements = getOppositeAxisPlacements;
+exports.getOppositePlacement = getOppositePlacement;
+exports.getOverflowAncestors = getOverflowAncestors;
+exports.getPaddingObject = getPaddingObject;
+exports.getParentNode = getParentNode;
+exports.getSide = getSide;
+exports.getSideAxis = getSideAxis;
 exports.getTabbableAfterElement = getTabbableAfterElement;
 exports.getTabbableBeforeElement = getTabbableBeforeElement;
 exports.getTarget = getTarget;
+exports.getWindow = getWindow;
 exports.imperativeAction = imperativeAction;
 exports.incrementPress = incrementPress;
 exports.inertValue = inertValue;
@@ -5397,32 +5859,46 @@ exports.inputClear = inputClear;
 exports.inputPaste = inputPaste;
 exports.inputPress = inputPress;
 exports.ios = ios;
+exports.isContainingBlock = isContainingBlock;
+exports.isElement = isElement;
 exports.isElementVisible = isElementVisible;
+exports.isHTMLElement = isHTMLElement;
 exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
 exports.isInteractiveElement = isInteractiveElement;
+exports.isLastTraversableNode = isLastTraversableNode;
 exports.isListIndexDisabled = isListIndexDisabled;
 exports.isMouseLikePointerType = isMouseLikePointerType;
 exports.isOutsideEvent = isOutsideEvent;
+exports.isOverflowElement = isOverflowElement;
+exports.isTableElement = isTableElement;
 exports.isTargetInsideEnabledTrigger = isTargetInsideEnabledTrigger;
+exports.isTopLayer = isTopLayer;
 exports.isTypeableCombobox = isTypeableCombobox;
 exports.isTypeableElement = isTypeableElement;
 exports.isVirtualClick = isVirtualClick;
 exports.isVirtualPointerEvent = isVirtualPointerEvent;
+exports.isWebKit = isWebKit;
 exports.itemPress = itemPress;
 exports.jsdom = jsdom;
 exports.keyboard = keyboard;
 exports.listNavigation = listNavigation;
 exports.mac = mac;
 exports.matchesFocusVisible = matchesFocusVisible;
+exports.max = max;
 exports.mergeCleanups = mergeCleanups;
+exports.min = min;
 exports.none = none;
 exports.outsidePress = outsidePress;
 exports.ownerDocument = ownerDocument;
 exports.pointer = pointer;
 exports.popupStateMapping = popupStateMapping;
+exports.popupTransitionStateMapping = popupTransitionStateMapping;
 exports.pressableTriggerOpenStateMapping = pressableTriggerOpenStateMapping;
+exports.rectToClientRect = rectToClientRect;
+exports.round = round;
 exports.scrub = scrub;
 exports.setPopupOpenState = setPopupOpenState;
+exports.shimExports = shimExports;
 exports.siblingOpen = siblingOpen;
 exports.stopEvent = stopEvent;
 exports.swipe = swipe;
@@ -5445,17 +5921,15 @@ exports.useFloatingParentNodeId = useFloatingParentNodeId;
 exports.useFloatingTree = useFloatingTree;
 exports.useId = useId;
 exports.useImplicitActiveTrigger = useImplicitActiveTrigger;
-exports.useInitialOpenSync = useInitialOpenSync;
 exports.useIsoLayoutEffect = useIsoLayoutEffect;
-exports.useOnFirstRender = useOnFirstRender;
 exports.useOnMount = useOnMount;
 exports.useOpenChangeComplete = useOpenChangeComplete;
 exports.useOpenInteractionType = useOpenInteractionType;
 exports.useOpenMethodTriggerProps = useOpenMethodTriggerProps;
 exports.useOpenStateTransitions = useOpenStateTransitions;
 exports.usePopupInteractionProps = usePopupInteractionProps;
+exports.usePopupRootStore = usePopupRootStore;
 exports.usePopupRootSync = usePopupRootSync;
-exports.usePopupStore = usePopupStore;
 exports.useScrollLock = useScrollLock;
 exports.useStableCallback = useStableCallback;
 exports.useStore = useStore;
@@ -5468,6 +5942,7 @@ exports.useValueAsRef = useValueAsRef;
 exports.useValueChanged = useValueChanged;
 exports.visuallyHidden = visuallyHidden;
 exports.visuallyHiddenInput = visuallyHiddenInput;
+exports.voiceOver = voiceOver;
 exports.webkit = webkit;
 exports.wheel = wheel;
 exports.windowResize = windowResize;