diff --git a/packages/@adobe/spectrum-css-temp/components/popover/index.css b/packages/@adobe/spectrum-css-temp/components/popover/index.css
index 744aef962ed..c4d786a8b45 100644
--- a/packages/@adobe/spectrum-css-temp/components/popover/index.css
+++ b/packages/@adobe/spectrum-css-temp/components/popover/index.css
@@ -51,6 +51,14 @@ governing permissions and limitations under the License.
   overflow: hidden;
 }
 
+/* Prevent clicks during exit animation (e.g. Picker selecting wrong item).
+   pointer-events is not inherited, so we must disable it on the popover and all descendants. */
+.spectrum-Popover.is-exiting,
+.spectrum-Popover.is-exiting * {
+  pointer-events: none;
+  touch-action: none;
+}
+
 .is-open {
   composes: spectrum-overlay--open;
 }
diff --git a/packages/@react-aria/calendar/src/useRangeCalendar.ts b/packages/@react-aria/calendar/src/useRangeCalendar.ts
index 78bff4f50af..2f09ab5bb2f 100644
--- a/packages/@react-aria/calendar/src/useRangeCalendar.ts
+++ b/packages/@react-aria/calendar/src/useRangeCalendar.ts
@@ -22,7 +22,8 @@ import {useRef} from 'react';
  * A range calendar displays one or more date grids and allows users to select a contiguous range of dates.
  */
 export function useRangeCalendar<T extends DateValue>(props: AriaRangeCalendarProps<T>, state: RangeCalendarState, ref: RefObject<FocusableElement | null>): CalendarAria {
-  let res = useCalendarBase(props, state);
+  let {interactOutsideBehavior = 'select', ...otherProps} = props;
+  let res = useCalendarBase(otherProps, state);
 
   // We need to ignore virtual pointer events from VoiceOver due to these bugs.
   // https://bugs.webkit.org/show_bug.cgi?id=222627
@@ -36,7 +37,13 @@ export function useRangeCalendar<T extends DateValue>(props: AriaRangeCalendarPr
     isVirtualClick.current = e.width === 0 && e.height === 0;
   });
 
-  // Stop range selection when pressing or releasing a pointer outside the calendar body,
+  const interactOutsideBehaviorMapping = {
+    clear: () => state.clearSelection(),
+    reset: () => state.setAnchorDate(null),
+    select: () => state.selectFocusedDate()
+  };
+
+  // Execute method corresponding to `interactOutsideBehavior` when pressing or releasing a pointer outside the calendar body,
   // except when pressing the next or previous buttons to switch months.
   let endDragging = (e: PointerEvent) => {
     if (isVirtualClick.current) {
@@ -55,19 +62,21 @@ export function useRangeCalendar<T extends DateValue>(props: AriaRangeCalendarPr
       isFocusWithin(ref.current) &&
       (!nodeContains(ref.current, target) || !target.closest('button, [role="button"]'))
     ) {
-      state.selectFocusedDate();
+      interactOutsideBehaviorMapping[interactOutsideBehavior]();
     }
   };
 
   useEvent(windowRef, 'pointerup', endDragging);
 
-  // Also stop range selection on blur, e.g. tabbing away from the calendar.
+  // Also execute method corresponding to `interactOutsideBehavior` on blur,
+  // e.g. tabbing away from the calendar.
   res.calendarProps.onBlur = e => {
     if (!ref.current) {
       return;
     }
+
     if ((!e.relatedTarget || !nodeContains(ref.current, e.relatedTarget)) && state.anchorDate) {
-      state.selectFocusedDate();
+      interactOutsideBehaviorMapping[interactOutsideBehavior]();
     }
   };
 
diff --git a/packages/@react-aria/interactions/src/useHover.ts b/packages/@react-aria/interactions/src/useHover.ts
index 5a1d94c4eee..639f598e7a8 100644
--- a/packages/@react-aria/interactions/src/useHover.ts
+++ b/packages/@react-aria/interactions/src/useHover.ts
@@ -45,7 +45,7 @@ function setGlobalIgnoreEmulatedMouseEvents() {
   // the distant future because a user previously touched the element.
   setTimeout(() => {
     globalIgnoreEmulatedMouseEvents = false;
-  }, 50);
+  }, 500);
 }
 
 function handleGlobalPointerEvent(e: PointerEvent) {
diff --git a/packages/@react-aria/interactions/test/useHover.test.js b/packages/@react-aria/interactions/test/useHover.test.js
index 144610513ca..c3e21425122 100644
--- a/packages/@react-aria/interactions/test/useHover.test.js
+++ b/packages/@react-aria/interactions/test/useHover.test.js
@@ -191,7 +191,7 @@ describe('useHover', function () {
       fireEvent(el, pointerEvent('pointerout', {pointerType: 'touch'}));
       fireEvent(el, pointerEvent('pointerup', {pointerType: 'touch'}));
 
-      act(() => {jest.advanceTimersByTime(100);});
+      act(() => {jest.advanceTimersByTime(600);});
 
       // Safari on iOS has a bug that fires a pointer event with pointerType="mouse" on focus.
       // See https://bugs.webkit.org/show_bug.cgi?id=214609.
@@ -321,7 +321,7 @@ describe('useHover', function () {
       let el = res.getByTestId('test');
       fireEvent(el, pointerEvent('pointerover', {pointerType: 'mouse'}));
       expect(el).toHaveAttribute('data-hovered', 'true');
-      
+
       let button = res.getByRole('button');
       act(() => button.click());
       expect(button).not.toBeInTheDocument();
@@ -444,7 +444,7 @@ describe('useHover', function () {
       fireEvent.mouseLeave(el);
       fireEvent.touchEnd(el);
 
-      act(() => {jest.advanceTimersByTime(100);});
+      act(() => {jest.advanceTimersByTime(600);});
 
       // Safari on iOS has a bug that fires a mouse event on focus.
       // See https://bugs.webkit.org/show_bug.cgi?id=214609.
diff --git a/packages/@react-aria/overlays/src/ariaHideOutside.ts b/packages/@react-aria/overlays/src/ariaHideOutside.ts
index ad0bdeaee33..a9644e3d1e1 100644
--- a/packages/@react-aria/overlays/src/ariaHideOutside.ts
+++ b/packages/@react-aria/overlays/src/ariaHideOutside.ts
@@ -15,6 +15,10 @@ import {shadowDOM} from '@react-stately/flags';
 
 const supportsInert = typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;
 
+function isAlwaysVisibleNode(node: HTMLElement | SVGElement): boolean {
+  return node.dataset.liveAnnouncer === 'true' || node.dataset.reactAriaTopLayer !== undefined;
+}
+
 interface AriaHideOutsideOptions {
   root?: Element,
   shouldUseInert?: boolean
@@ -175,7 +179,7 @@ export function ariaHideOutside(targets: Element[], options?: AriaHideOutsideOpt
         for (let node of change.addedNodes) {
           if (
             (node instanceof HTMLElement || node instanceof SVGElement) &&
-            (node.dataset.liveAnnouncer === 'true' || node.dataset.reactAriaTopLayer === 'true')
+            isAlwaysVisibleNode(node)
           ) {
             visibleNodes.add(node);
           } else if (node instanceof Element) {
@@ -218,7 +222,7 @@ export function ariaHideOutside(targets: Element[], options?: AriaHideOutsideOpt
             for (let node of change.addedNodes) {
               if (
                 (node instanceof HTMLElement || node instanceof SVGElement) &&
-                (node.dataset.liveAnnouncer === 'true' || node.dataset.reactAriaTopLayer === 'true')
+                isAlwaysVisibleNode(node)
               ) {
                 visibleNodes.add(node);
               } else if (node instanceof Element) {
diff --git a/packages/@react-aria/overlays/test/ariaHideOutside.test.js b/packages/@react-aria/overlays/test/ariaHideOutside.test.js
index a0c8bd2d198..ee386f9efff 100644
--- a/packages/@react-aria/overlays/test/ariaHideOutside.test.js
+++ b/packages/@react-aria/overlays/test/ariaHideOutside.test.js
@@ -239,6 +239,35 @@ describe('ariaHideOutside', function () {
     expect(getAllByRole('checkbox')).toHaveLength(1);
   });
 
+  it('should recognize dynamically added top layer element with data-react-aria-top-layer="" (attribute presence)', async function () {
+    let Test = props => (
+      <>
+        <button>Button</button>
+        {props.show && (
+          <>
+            <div role="status" data-react-aria-top-layer="">Top layer (empty attr)</div>
+            <input type="checkbox" />
+          </>
+        )}
+      </>
+    );
+
+    let {getByRole, getAllByRole, rerender} = render(<Test />);
+
+    let button = getByRole('button');
+    let revert = ariaHideOutside([button]);
+
+    rerender(<Test show />);
+
+    // MutationObserver is async
+    await Promise.resolve();
+    expect(getByRole('status')).not.toHaveAttribute('aria-hidden');
+    expect(getByRole('checkbox', {hidden: true})).toHaveAttribute('aria-hidden', 'true');
+
+    revert();
+    expect(getAllByRole('checkbox')).toHaveLength(1);
+  });
+
   it('should handle when a new element is added inside a target element', async function () {
     let Test = props => (
       <>
diff --git a/packages/@react-aria/select/src/HiddenSelect.tsx b/packages/@react-aria/select/src/HiddenSelect.tsx
index 07efe254bc5..b2656bc22cf 100644
--- a/packages/@react-aria/select/src/HiddenSelect.tsx
+++ b/packages/@react-aria/select/src/HiddenSelect.tsx
@@ -157,7 +157,7 @@ export function HiddenSelect<T, M extends SelectionMode = 'single'>(props: Hidde
         <label>
           {label}
           <select {...selectProps} ref={selectRef}>
-            <option />
+            <option value="" label={'\u00A0'}>{'\u00A0'}</option>
             {[...state.collection.getKeys()].map(key => {
               let item = state.collection.getItem(key);
               if (item && item.type === 'item') {
diff --git a/packages/@react-aria/select/test/HiddenSelect.test.tsx b/packages/@react-aria/select/test/HiddenSelect.test.tsx
index 995adb081f3..8508f7d5246 100644
--- a/packages/@react-aria/select/test/HiddenSelect.test.tsx
+++ b/packages/@react-aria/select/test/HiddenSelect.test.tsx
@@ -84,6 +84,36 @@ describe('<HiddenSelect />', () => {
     expect(onSelectionChange).toBeCalledWith('5');
   });
 
+  it('should include a non-empty placeholder option for native select markup', () => {
+    render(
+      <HiddenSelectExample
+        label="select"
+        items={makeItems(5)} />
+    );
+
+    let select = screen.getByLabelText('select');
+    let firstOption = select.querySelector('option')!;
+
+    expect(firstOption).toHaveAttribute('value', '');
+    expect(firstOption).toHaveAttribute('label', '\u00A0');
+  });
+
+  it('should submit an empty string when no value is selected', () => {
+    let formRef = React.createRef<HTMLFormElement>();
+    render(
+      <form ref={formRef}>
+        <HiddenSelectExample
+          hiddenProps={{
+            name: 'select'
+          }}
+          items={makeItems(5)} />
+      </form>
+    );
+
+    let formData = new FormData(formRef.current!);
+    expect(formData.get('select')).toEqual('');
+  });
+
   it('should always add a data attribute data-a11y-ignore="aria-hidden-focus"', () => {
     render(
       <HiddenSelectExample items={makeItems(5)} />
diff --git a/packages/@react-aria/test-utils/src/select.ts b/packages/@react-aria/test-utils/src/select.ts
index f4b3b8ac432..66da8c85262 100644
--- a/packages/@react-aria/test-utils/src/select.ts
+++ b/packages/@react-aria/test-utils/src/select.ts
@@ -25,7 +25,12 @@ interface SelectTriggerOptionOpts extends SelectOpenOpts {
   /**
    * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
    */
-  option: number | string | HTMLElement
+  option: number | string | HTMLElement,
+  /**
+   * Whether or not the select closes on selection. Depends on select implementation and configuration.
+   * @default true
+   */
+  closesOnSelect?: boolean
 }
 
 export class SelectTester {
@@ -165,6 +170,7 @@ export class SelectTester {
   async selectOption(opts: SelectTriggerOptionOpts): Promise<void> {
     let {
       option,
+      closesOnSelect,
       interactionType = this._interactionType
     } = opts || {};
     let trigger = this.trigger;
@@ -186,6 +192,8 @@ export class SelectTester {
       }
 
       let isMultiSelect = listbox.getAttribute('aria-multiselectable') === 'true';
+      let isSingleSelect = !isMultiSelect;
+      closesOnSelect = closesOnSelect ?? isSingleSelect;
 
       if (interactionType === 'keyboard') {
         if (option?.getAttribute('aria-disabled') === 'true') {
@@ -206,7 +214,7 @@ export class SelectTester {
         }
       }
 
-      if (!isMultiSelect && option?.getAttribute('href') == null) {
+      if (closesOnSelect && option?.getAttribute('href') == null) {
         await waitFor(() => {
           if (document.activeElement !== this._trigger) {
             throw new Error(`Expected the document.activeElement after selecting an option to be the select component trigger but got ${document.activeElement}`);
diff --git a/packages/@react-aria/utils/src/animation.ts b/packages/@react-aria/utils/src/animation.ts
index c613b451163..39b1a89daa3 100644
--- a/packages/@react-aria/utils/src/animation.ts
+++ b/packages/@react-aria/utils/src/animation.ts
@@ -87,13 +87,13 @@ function useAnimation(ref: RefObject<HTMLElement | null>, isActive: boolean, onE
       }
 
       let canceled = false;
-      Promise.all(animations.map(a => a.finished)).then(() => {
+      Promise.allSettled(animations.map(a => a.finished)).then(() => {
         if (!canceled) {
           flushSync(() => {
             onEnd();
           });
         }
-      }).catch(() => {});
+      });
 
       return () => {
         canceled = true;
diff --git a/packages/@react-spectrum/calendar/test/RangeCalendar.test.js b/packages/@react-spectrum/calendar/test/RangeCalendar.test.js
index befe4384ef0..62025906c96 100644
--- a/packages/@react-spectrum/calendar/test/RangeCalendar.test.js
+++ b/packages/@react-spectrum/calendar/test/RangeCalendar.test.js
@@ -209,10 +209,10 @@ describe('RangeCalendar', () => {
       const {getAllByRole} = render(
         <RangeCalendar visibleMonths={3} defaultValue={{start: new CalendarDate(2020, 2, 3), end: new CalendarDate(2020, 2, 10)}} selectionAlignment={alignment} />
       );
-  
+
       let grids = getAllByRole('grid');
       expect(grids).toHaveLength(3);
-  
+
       expect(grids[0]).toHaveAttribute('aria-label', expected[0]);
       expect(grids[1]).toHaveAttribute('aria-label', expected[1]);
       expect(grids[2]).toHaveAttribute('aria-label', expected[2]);
@@ -1543,4 +1543,212 @@ describe('RangeCalendar', () => {
       expect(announce).toHaveBeenCalledWith('March 5 BC');
     });
   });
+
+  describe('pointer events', () => {
+    beforeAll(() => {
+      jest.setSystemTime(new Date('2025-11-01'));
+    });
+
+    it('should select the last hovered date when interactOutsideBehavior is "select"', async () => {
+      const onChange = jest.fn();
+
+      let {getByText, getAllByText} = render(
+        <RangeCalendar
+          defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+          onChange={onChange}
+          interactOutsideBehavior="select" />
+      );
+
+      await user.click(getByText('25'));
+      await user.hover(getByText('20'));
+
+      await user.click(getAllByText('November 2025')[0]);
+
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2025, 11, 20), end: new CalendarDate(2025, 11, 25)});
+    });
+
+    it('should clear the selection when interactOutsideBehavior is "clear"', async () => {
+      const onChange = jest.fn();
+      let {getByText, getAllByText, getByRole} = render(
+        <RangeCalendar
+          defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+          onChange={onChange}
+          interactOutsideBehavior="clear" />
+      );
+
+      let startCell = getByRole('gridcell', {name: '25'});
+      let endCell = getByRole('gridcell', {name: '20'});
+
+      await user.click(getByText('25'));
+      await user.hover(getByText('20'));
+      expect(startCell).toHaveAttribute('aria-selected', 'true');
+
+      await user.click(getAllByText('November 2025')[0]);
+
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith(null);
+      expect(startCell).not.toHaveAttribute('aria-selected');
+      expect(endCell).not.toHaveAttribute('aria-selected');
+    });
+
+    it('should clear the selection when interactOutsideBehavior is "clear" no default selected range', async () => {
+      const onChange = jest.fn();
+      let {getByText, getByRole} = render(
+        <RangeCalendar
+          onChange={onChange}
+          interactOutsideBehavior="clear" />
+      );
+
+      let startCell = getByRole('gridcell', {name: '25'});
+      let endCell = getByRole('gridcell', {name: '20'});
+
+      await user.click(getByText('25'));
+      await user.hover(getByText('20'));
+      expect(startCell).toHaveAttribute('aria-selected', 'true');
+
+      await user.click(document.body);
+
+      expect(onChange).toHaveBeenCalledTimes(0);
+      expect(startCell).not.toHaveAttribute('aria-selected');
+      expect(endCell).not.toHaveAttribute('aria-selected');
+    });
+
+    it('should reset to the initial range when interactOutsideBehavior is "reset"', async () => {
+      const onChange = jest.fn();
+      let {getByText, getAllByText, getByRole} = render(
+        <RangeCalendar
+          defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+          onChange={onChange}
+          interactOutsideBehavior="reset" />
+      );
+
+      let originalStartCell = getByRole('gridcell', {name: '13'});
+      let originalEndCell = getByRole('gridcell', {name: '15'});
+      let newStartCell = getByRole('gridcell', {name: '25'});
+
+      expect(originalStartCell).toHaveAttribute('aria-selected', 'true');
+      expect(originalEndCell).toHaveAttribute('aria-selected', 'true');
+      expect(newStartCell).not.toHaveAttribute('aria-selected');
+
+      await user.click(getByText('25'));
+      await user.hover(getByText('20'));
+      expect(newStartCell).toHaveAttribute('aria-selected', 'true');
+      expect(originalStartCell).not.toHaveAttribute('aria-selected');
+      expect(originalEndCell).not.toHaveAttribute('aria-selected');
+
+      await user.click(getAllByText('November 2025')[0]);
+
+      expect(onChange).toHaveBeenCalledTimes(0);
+      expect(newStartCell).not.toHaveAttribute('aria-selected');
+      expect(originalStartCell).toHaveAttribute('aria-selected', 'true');
+      expect(originalEndCell).toHaveAttribute('aria-selected', 'true');
+    });
+
+    it('should reset to the initial range when interactOutsideBehavior is "reset" (controlled value)', async () => {
+      const onChange = jest.fn();
+      let {getByText, getAllByText, getByRole} = render(
+        <RangeCalendar
+          value={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+          onChange={onChange}
+          interactOutsideBehavior="reset" />
+      );
+
+      let originalStartCell = getByRole('gridcell', {name: '13'});
+      let originalEndCell = getByRole('gridcell', {name: '15'});
+      let newStartCell = getByRole('gridcell', {name: '25'});
+
+      await user.click(getByText('25'));
+      await user.hover(getByText('20'));
+      expect(newStartCell).toHaveAttribute('aria-selected', 'true');
+      expect(originalStartCell).not.toHaveAttribute('aria-selected');
+      expect(originalEndCell).not.toHaveAttribute('aria-selected');
+
+      await user.click(getAllByText('November 2025')[0]);
+
+      expect(onChange).toHaveBeenCalledTimes(0);
+      expect(newStartCell).not.toHaveAttribute('aria-selected');
+      expect(originalStartCell).toHaveAttribute('aria-selected', 'true');
+      expect(originalEndCell).toHaveAttribute('aria-selected', 'true');
+    });
+
+    describe('blur (e.g. tabbing away)', () => {
+      it('should select the hovered range when interactOutsideBehavior is "select" and calendar blurs', async () => {
+        const onChange = jest.fn();
+        let {getByText, getByRole} = render(
+          <RangeCalendar
+            defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+            onChange={onChange}
+            interactOutsideBehavior="select" />
+        );
+
+        let startCell = getByRole('gridcell', {name: '13'});
+        let endCell = getByRole('gridcell', {name: '15'});
+
+        let newStartCell = getByRole('gridcell', {name: '25'});
+        let newEndCell = getByRole('gridcell', {name: '20'});
+
+        await user.click(getByText('25'));
+        await user.hover(getByText('20'));
+
+        await user.tab();
+
+        expect(onChange).toHaveBeenCalledTimes(1);
+        expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2025, 11, 20), end: new CalendarDate(2025, 11, 25)});
+        expect(startCell).not.toHaveAttribute('aria-selected', 'true');
+        expect(endCell).not.toHaveAttribute('aria-selected', 'true');
+        expect(newStartCell).toHaveAttribute('aria-selected', 'true');
+        expect(newEndCell).toHaveAttribute('aria-selected', 'true');
+      });
+
+      it('should clear the selection when interactOutsideBehavior is "clear" and calendar blurs', async () => {
+        const onChange = jest.fn();
+        let {getByText, getByRole} = render(
+          <RangeCalendar
+            defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+            onChange={onChange}
+            interactOutsideBehavior="clear" />
+        );
+
+        let startCell = getByRole('gridcell', {name: '13'});
+        let endCell = getByRole('gridcell', {name: '15'});
+        let newStartCell = getByRole('gridcell', {name: '25'});
+        let newEndCell = getByRole('gridcell', {name: '20'});
+
+        await user.click(getByText('25'));
+        await user.hover(getByText('20'));
+        await user.tab();
+
+        expect(onChange).toHaveBeenCalledTimes(1);
+        expect(onChange).toHaveBeenCalledWith(null);
+        expect(startCell).not.toHaveAttribute('aria-selected', 'true');
+        expect(endCell).not.toHaveAttribute('aria-selected', 'true');
+        expect(newStartCell).not.toHaveAttribute('aria-selected', 'true');
+        expect(newEndCell).not.toHaveAttribute('aria-selected', 'true');
+      });
+
+      it('should reset to the initial range when interactOutsideBehavior is "reset" and calendar blurs', async () => {
+        const onChange = jest.fn();
+        let {getByText, getByRole} = render(
+          <RangeCalendar
+            defaultValue={{start: new CalendarDate(2025, 11, 13), end: new CalendarDate(2025, 11, 15)}}
+            onChange={onChange}
+            interactOutsideBehavior="reset" />
+        );
+
+        let originalStartCell = getByRole('gridcell', {name: '13'});
+        let originalEndCell = getByRole('gridcell', {name: '15'});
+        let newStartCell = getByRole('gridcell', {name: '25'});
+
+        await user.click(getByText('25'));
+        await user.hover(getByText('20'));
+        await user.tab();
+
+        expect(onChange).toHaveBeenCalledTimes(0);
+        expect(originalStartCell).toHaveAttribute('aria-selected', 'true');
+        expect(originalEndCell).toHaveAttribute('aria-selected', 'true');
+        expect(newStartCell).not.toHaveAttribute('aria-selected');
+      });
+    });
+  });
 });
diff --git a/packages/@react-spectrum/overlays/src/Popover.tsx b/packages/@react-spectrum/overlays/src/Popover.tsx
index de4b7064334..707540596d6 100644
--- a/packages/@react-spectrum/overlays/src/Popover.tsx
+++ b/packages/@react-spectrum/overlays/src/Popover.tsx
@@ -138,7 +138,8 @@ const PopoverWrapper = forwardRef((props: PopoverWrapperProps, ref: ForwardedRef
             {
               'spectrum-Popover--withTip': !hideArrow,
               'is-open': isOpen,
-              [`is-open--${placement}`]: isOpen
+              [`is-open--${placement}`]: isOpen,
+              'is-exiting': !state.isOpen
             },
             classNames(
               overrideStyles,
diff --git a/packages/@react-stately/calendar/src/types.ts b/packages/@react-stately/calendar/src/types.ts
index ec7b26470c6..839c2528882 100644
--- a/packages/@react-stately/calendar/src/types.ts
+++ b/packages/@react-stately/calendar/src/types.ts
@@ -122,5 +122,7 @@ export interface RangeCalendarState<T extends DateValue = DateValue> extends Cal
   /** Whether the user is currently dragging over the calendar. */
   readonly isDragging: boolean,
   /** Sets whether the user is dragging over the calendar. */
-  setDragging(isDragging: boolean): void
+  setDragging(isDragging: boolean): void,
+  /** Clears the current selection. */
+  clearSelection(): void
 }
diff --git a/packages/@react-stately/calendar/src/useRangeCalendarState.ts b/packages/@react-stately/calendar/src/useRangeCalendarState.ts
index 284500aa184..305d90df227 100644
--- a/packages/@react-stately/calendar/src/useRangeCalendarState.ts
+++ b/packages/@react-stately/calendar/src/useRangeCalendarState.ts
@@ -191,7 +191,11 @@ export function useRangeCalendarState<T extends DateValue = DateValue>(props: Ra
       return calendar.isInvalid(date) || isInvalid(date, availableRangeRef.current?.start, availableRangeRef.current?.end);
     },
     isDragging,
-    setDragging
+    setDragging,
+    clearSelection() {
+      setAnchorDate(null);
+      setValue(null);
+    }
   };
 }
 
diff --git a/packages/@react-stately/select/src/useSelectState.ts b/packages/@react-stately/select/src/useSelectState.ts
index 2bcf82787a9..058d71f23a3 100644
--- a/packages/@react-stately/select/src/useSelectState.ts
+++ b/packages/@react-stately/select/src/useSelectState.ts
@@ -79,7 +79,10 @@ export interface SelectState<T, M extends SelectionMode = 'single'> extends List
  * multiple selection state.
  */
 export function useSelectState<T extends object, M extends SelectionMode = 'single'>(props: SelectStateOptions<T, M>): SelectState<T, M>  {
-  let {selectionMode = 'single' as M} = props;
+  let {
+    selectionMode = 'single' as M,
+    shouldCloseOnSelect = selectionMode === 'single'
+  } = props;
   let triggerState = useOverlayTriggerState(props);
   let [focusStrategy, setFocusStrategy] = useState<FocusStrategy | null>(null);
   let defaultValue = useMemo(() => {
@@ -125,10 +128,12 @@ export function useSelectState<T extends object, M extends SelectionMode = 'sing
       if (selectionMode === 'single') {
         let key = keys.values().next().value ?? null;
         setValue(key);
-        triggerState.close();
       } else {
         setValue([...keys]);
       }
+      if (shouldCloseOnSelect) {
+        triggerState.close();
+      }
 
       validationState.commitValidation();
     }
diff --git a/packages/@react-types/calendar/src/index.d.ts b/packages/@react-types/calendar/src/index.d.ts
index 8d9e1e2381d..0fda150a6f9 100644
--- a/packages/@react-types/calendar/src/index.d.ts
+++ b/packages/@react-types/calendar/src/index.d.ts
@@ -67,8 +67,8 @@ export interface CalendarPropsBase {
    * The day that starts the week.
    */
   firstDayOfWeek?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat',
-  /** 
-   * Determines the alignment of the visible months on initial render based on the current selection or current date if there is no selection. 
+  /**
+   * Determines the alignment of the visible months on initial render based on the current selection or current date if there is no selection.
    * @default 'center'
    */
   selectionAlignment?: 'start' | 'center' | 'end'
@@ -86,7 +86,19 @@ export interface RangeCalendarProps<T extends DateValue> extends CalendarPropsBa
 
 export interface AriaCalendarProps<T extends DateValue> extends CalendarProps<T>, DOMProps, AriaLabelingProps {}
 
-export interface AriaRangeCalendarProps<T extends DateValue> extends RangeCalendarProps<T>, DOMProps, AriaLabelingProps {}
+export interface AriaRangeCalendarProps<T extends DateValue> extends RangeCalendarProps<T>, DOMProps, AriaLabelingProps {
+  /**
+   * Controls the behavior when a pointer is released outside the calendar:
+   *
+   * - `clear`: clear the currently selected range of dates.
+   *
+   * - `reset`: reset the selection to the previously selected range of dates.
+   *
+   * - `select`: select the currently hovered range of dates.
+   * @default 'select'
+   */
+  interactOutsideBehavior?: 'clear' | 'reset' | 'select'
+}
 
 export type PageBehavior = 'single' | 'visible';
 
diff --git a/packages/@react-types/combobox/src/index.d.ts b/packages/@react-types/combobox/src/index.d.ts
index 734d418a88e..fcd9c6e827b 100644
--- a/packages/@react-types/combobox/src/index.d.ts
+++ b/packages/@react-types/combobox/src/index.d.ts
@@ -37,7 +37,7 @@ export type MenuTriggerAction = 'focus' | 'input' | 'manual';
 export type SelectionMode = 'single' | 'multiple';
 export type ValueType<M extends SelectionMode> = M extends 'single' ? Key | null : readonly Key[];
 export type ChangeValueType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
-type ValidationType<M extends SelectionMode> = M extends 'single' ? Key : Key[];
+type ValidationType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
 
 export interface ComboBoxValidationValue<M extends SelectionMode = 'single'> {
   /**
@@ -51,7 +51,7 @@ export interface ComboBoxValidationValue<M extends SelectionMode = 'single'> {
   inputValue: string
 }
 
-export interface ComboBoxProps<T, M extends SelectionMode = 'single'> extends CollectionBase<T>, InputBase, ValueBase<ValueType<M>, ChangeValueType<M>>, TextInputBase, Validation<ComboBoxValidationValue>, FocusableProps<HTMLInputElement>, LabelableProps, HelpTextProps {
+export interface ComboBoxProps<T, M extends SelectionMode = 'single'> extends CollectionBase<T>, InputBase, ValueBase<ValueType<M>, ChangeValueType<M>>, TextInputBase, Validation<ComboBoxValidationValue<M>>, FocusableProps<HTMLInputElement>, LabelableProps, HelpTextProps {
   /** The list of ComboBox items (uncontrolled). */
   defaultItems?: Iterable<T>,
   /** The list of ComboBox items (controlled). */
diff --git a/packages/@react-types/select/src/index.d.ts b/packages/@react-types/select/src/index.d.ts
index edb951aab63..f028e50afc9 100644
--- a/packages/@react-types/select/src/index.d.ts
+++ b/packages/@react-types/select/src/index.d.ts
@@ -63,6 +63,8 @@ export interface SelectProps<T, M extends SelectionMode = 'single'> extends Coll
   defaultOpen?: boolean,
   /** Method that is called when the open state of the menu changes. */
   onOpenChange?: (isOpen: boolean) => void,
+  /** Whether the Select should close when an item is selected. Defaults to true if selectionMode is single, false otherwise. */
+  shouldCloseOnSelect?: boolean,
   /** Whether the select should be allowed to be open when the collection is empty. */
   allowsEmptyCollection?: boolean
 }
diff --git a/packages/react-aria-components/src/FieldError.tsx b/packages/react-aria-components/src/FieldError.tsx
index ca8331db63b..69af239de38 100644
--- a/packages/react-aria-components/src/FieldError.tsx
+++ b/packages/react-aria-components/src/FieldError.tsx
@@ -24,7 +24,13 @@ export interface FieldErrorProps extends RenderProps<FieldErrorRenderProps>, DOM
    * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
    * @default 'react-aria-FieldError'
    */
-  className?: ClassNameOrFunction<FieldErrorRenderProps>
+  className?: ClassNameOrFunction<FieldErrorRenderProps>,
+  /**
+   * The HTML element type to render. Defaults to `'span'`.
+   * Set to `'div'` when using block-level children (e.g. `<ul>`) to avoid invalid HTML.
+   * @default 'span'
+   */
+  elementType?: string
 }
 
 /**
@@ -41,9 +47,10 @@ export const FieldError = forwardRef(function FieldError(props: FieldErrorProps,
 
 const FieldErrorInner = forwardRef((props: FieldErrorProps, ref: ForwardedRef<HTMLElement>) => {
   let validation = useContext(FieldErrorContext)!;
-  let domProps = filterDOMProps(props, {global: true})!;
+  let {elementType, ...restProps} = props;
+  let domProps = filterDOMProps(restProps, {global: true})!;
   let renderProps = useRenderProps({
-    ...props,
+    ...restProps,
     defaultClassName: 'react-aria-FieldError',
     defaultChildren: validation.validationErrors.length === 0 ? undefined : validation.validationErrors.join(' '),
     values: validation
@@ -53,5 +60,5 @@ const FieldErrorInner = forwardRef((props: FieldErrorProps, ref: ForwardedRef<HT
     return null;
   }
 
-  return <Text slot="errorMessage" {...domProps} {...renderProps} ref={ref} />;
+  return <Text slot="errorMessage" elementType={elementType} {...domProps} {...renderProps} ref={ref} />;
 });
diff --git a/packages/react-aria-components/test/FieldError.test.js b/packages/react-aria-components/test/FieldError.test.js
index 455348fdb92..05638875463 100644
--- a/packages/react-aria-components/test/FieldError.test.js
+++ b/packages/react-aria-components/test/FieldError.test.js
@@ -20,4 +20,64 @@ describe('FieldError', function () {
     const element = getByTestId(TEST_ID);
     expect(element).toHaveTextContent('An error');
   });
+
+  it('renders as span by default', async () => {
+    const {getByText} = render(
+      <TextField isInvalid>
+        <Label>Email</Label>
+        <Input />
+        <FieldError>An error</FieldError>
+      </TextField>
+    );
+
+    const element = getByText('An error');
+    expect(element.tagName).toBe('SPAN');
+  });
+
+  it('supports elementType prop', async () => {
+    const {getByText} = render(
+      <TextField isInvalid>
+        <Label>Email</Label>
+        <Input />
+        <FieldError elementType="div">An error</FieldError>
+      </TextField>
+    );
+
+    const element = getByText('An error');
+    expect(element.tagName).toBe('DIV');
+  });
+
+  it('does not warn when render prop returns element matching elementType', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    render(
+      <TextField isInvalid>
+        <Label>Email</Label>
+        <Input />
+        <FieldError elementType="div" render={(props) => <div {...props}><ul><li>Error</li></ul></div>}>
+          Error
+        </FieldError>
+      </TextField>
+    );
+
+    expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('Unexpected DOM element'));
+    warnSpy.mockRestore();
+  });
+
+  it('warns when render prop returns element that does not match elementType', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    render(
+      <TextField isInvalid>
+        <Label>Email</Label>
+        <Input />
+        <FieldError render={(props) => <div {...props} />}>
+          Error
+        </FieldError>
+      </TextField>
+    );
+
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Unexpected DOM element'));
+    warnSpy.mockRestore();
+  });
 });
diff --git a/packages/react-aria-components/test/Select.test.js b/packages/react-aria-components/test/Select.test.js
index 78dea4fccc1..c5e44c1133b 100644
--- a/packages/react-aria-components/test/Select.test.js
+++ b/packages/react-aria-components/test/Select.test.js
@@ -222,6 +222,62 @@ describe('Select', () => {
     expect(trigger).toHaveTextContent('close');
   });
 
+  it('should stay open on selecting an option if shouldCloseOnSelect is false and single selection mode', async () => {
+    let {getByTestId} = render(
+      <Select data-testid="select" shouldCloseOnSelect={false}>
+        <Label>Favorite Animal</Label>
+        <Button>
+          <SelectValue />
+        </Button>
+        <Popover>
+          <ListBox>
+            <ListBoxItem>Cat</ListBoxItem>
+            <ListBoxItem>Dog</ListBoxItem>
+            <ListBoxItem>Kangaroo</ListBoxItem>
+          </ListBox>
+        </Popover>
+      </Select>
+    );
+
+    let selectTester = testUtilUser.createTester('Select', {root: getByTestId('select')});
+    let trigger = selectTester.trigger;
+
+    await selectTester.open();
+    expect(trigger).toHaveAttribute('data-pressed', 'true');
+
+    await selectTester.selectOption({option: 'Dog', closesOnSelect: false});
+    expect(trigger).toHaveTextContent('Dog');
+    expect(trigger).toHaveAttribute('data-pressed', 'true');
+  });
+
+  it('should close on selecting an option if shouldCloseOnSelect is true and multiple selection mode', async () => {
+    let {getByTestId} = render(
+      <Select data-testid="select" shouldCloseOnSelect selectionMode="multiple">
+        <Label>Favorite Animal</Label>
+        <Button>
+          <SelectValue />
+        </Button>
+        <Popover>
+          <ListBox>
+            <ListBoxItem>Cat</ListBoxItem>
+            <ListBoxItem>Dog</ListBoxItem>
+            <ListBoxItem>Kangaroo</ListBoxItem>
+          </ListBox>
+        </Popover>
+      </Select>
+    );
+
+    let selectTester = testUtilUser.createTester('Select', {root: getByTestId('select')});
+    let trigger = selectTester.trigger;
+
+    await selectTester.open();
+    expect(trigger).toHaveAttribute('data-pressed', 'true');
+
+    await selectTester.selectOption({option: 'Dog', closesOnSelect: true});
+    expect(trigger).toHaveTextContent('Dog');
+    expect(trigger).not.toHaveAttribute('data-pressed', 'true');
+  });
+
   it('should send disabled prop to the hidden field', () => {
     render(
       <TestSelect name="select" isDisabled />