diff --git a/packages/@internationalized/date/src/CalendarDate.ts b/packages/@internationalized/date/src/CalendarDate.ts
index 6eff9f68ee1..c214236ad0a 100644
--- a/packages/@internationalized/date/src/CalendarDate.ts
+++ b/packages/@internationalized/date/src/CalendarDate.ts
@@ -59,27 +59,27 @@ export class CalendarDate {
   /** The day number within the month. */
   public readonly day: number;
 
-  constructor(year: number, month: number, day: number);
-  constructor(era: string, year: number, month: number, day: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number);
+  constructor(year: number, month: number, day: number, constrainDay?: boolean);
+  constructor(era: string, year: number, month: number, day: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, year: number, month: number, day: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, constrainDay?: boolean);
   constructor(...args: any[]) {
-    let [calendar, era, year, month, day] = shiftArgs(args);
+    let [calendar, era, year, month, day, constrainDay] = shiftArgs(args);
     this.calendar = calendar;
     this.era = era;
     this.year = year;
     this.month = month;
     this.day = day;
 
-    constrain(this);
+    constrain(this, constrainDay);
   }
 
   /** Returns a copy of this date. */
-  copy(): CalendarDate {
+  copy(constrainDay?: boolean): CalendarDate {
     if (this.era) {
-      return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day);
+      return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day, constrainDay);
     } else {
-      return new CalendarDate(this.calendar, this.year, this.month, this.day);
+      return new CalendarDate(this.calendar, this.year, this.month, this.day, constrainDay);
     }
   }
 
@@ -94,16 +94,16 @@ export class CalendarDate {
   }
 
   /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: DateFields): CalendarDate {
-    return set(this, fields);
+  set(fields: DateFields, constrainDay?: boolean): CalendarDate {
+    return set(this, fields, constrainDay);
   }
 
   /**
    * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField, amount: number, options?: CycleOptions): CalendarDate {
-    return cycleDate(this, field, amount, options);
+  cycle(field: DateField, amount: number, options?: CycleOptions, constrainDay?: boolean): CalendarDate {
+    return cycleDate(this, field, amount, options, constrainDay);
   }
 
   /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
@@ -165,8 +165,8 @@ export class Time {
   }
 
   /** Returns a new `Time` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: TimeFields): Time {
-    return setTime(this, fields);
+  set(fields: TimeFields, constrainDay?: boolean): Time {
+    return setTime(this, fields, constrainDay);
   }
 
   /**
@@ -216,10 +216,10 @@ export class CalendarDateTime {
   /** The millisecond in the second. */
   public readonly millisecond: number;
 
-  constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+  constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
   constructor(...args: any[]) {
     let [calendar, era, year, month, day] = shiftArgs(args);
     this.calendar = calendar;
@@ -231,16 +231,17 @@ export class CalendarDateTime {
     this.minute = args.shift() || 0;
     this.second = args.shift() || 0;
     this.millisecond = args.shift() || 0;
+    const constrainDay = args.shift() || 0;
 
-    constrain(this);
+    constrain(this, constrainDay);
   }
 
   /** Returns a copy of this date. */
-  copy(): CalendarDateTime {
+  copy(constrainDay?: boolean): CalendarDateTime {
     if (this.era) {
-      return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+      return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond, constrainDay);
     } else {
-      return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+      return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond, constrainDay);
     }
   }
 
@@ -255,21 +256,21 @@ export class CalendarDateTime {
   }
 
   /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: DateFields & TimeFields): CalendarDateTime {
-    return set(setTime(this, fields), fields);
+  set(fields: DateFields & TimeFields, constrainDay?: boolean): CalendarDateTime {
+    return set(setTime(this, fields), fields, constrainDay);
   }
 
   /**
    * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime {
+  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions, constrainDay?: boolean): CalendarDateTime {
     switch (field) {
       case 'era':
       case 'year':
       case 'month':
       case 'day':
-        return cycleDate(this, field, amount, options);
+        return cycleDate(this, field, amount, options, constrainDay);
       default:
         return cycleTime(this, field, amount, options);
     }
@@ -328,10 +329,10 @@ export class ZonedDateTime {
   /** The UTC offset for this time, in milliseconds. */
   public readonly offset: number;
 
-  constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+  constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
+  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, constrainDay?: boolean);
   constructor(...args: any[]) {
     let [calendar, era, year, month, day] = shiftArgs(args);
     let timeZone = args.shift();
@@ -347,16 +348,17 @@ export class ZonedDateTime {
     this.minute = args.shift() || 0;
     this.second = args.shift() || 0;
     this.millisecond = args.shift() || 0;
+    const constrainDay = args.shift() || 0;
 
-    constrain(this);
+    constrain(this, constrainDay);
   }
 
   /** Returns a copy of this date. */
-  copy(): ZonedDateTime {
+  copy(constrainDay?: boolean): ZonedDateTime {
     if (this.era) {
-      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond, constrainDay);
     } else {
-      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond, constrainDay);
     }
   }
 
@@ -371,16 +373,23 @@ export class ZonedDateTime {
   }
 
   /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
-    return setZoned(this, fields, disambiguation);
+  set(fields: DateFields & TimeFields, value?: Disambiguation | boolean): ZonedDateTime { 
+    let disambiguation, constrainDay = false;
+    if (value && typeof value === 'string') {
+      disambiguation = value;
+    } else if (value && typeof value === 'boolean') {
+      constrainDay = value;
+    }
+    return setZoned(this, fields, disambiguation, constrainDay); 
   }
 
+
   /**
    * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
-    return cycleZoned(this, field, amount, options);
+  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions, constrainDay?: boolean): ZonedDateTime {
+    return cycleZoned(this, field, amount, options, constrainDay);
   }
 
   /** Converts the date to a native JavaScript Date object. */
diff --git a/packages/@internationalized/date/src/calendars/BuddhistCalendar.ts b/packages/@internationalized/date/src/calendars/BuddhistCalendar.ts
index f60c8bf1b3d..b7a60283aa6 100644
--- a/packages/@internationalized/date/src/calendars/BuddhistCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/BuddhistCalendar.ts
@@ -49,7 +49,6 @@ export class BuddhistCalendar extends GregorianCalendar {
   getDaysInMonth(date: AnyCalendarDate): number {
     return super.getDaysInMonth(toGregorian(date));
   }
-
   balanceDate(): void {}
 }
 
diff --git a/packages/@internationalized/date/src/calendars/EthiopicCalendar.ts b/packages/@internationalized/date/src/calendars/EthiopicCalendar.ts
index c96be3fb827..b520a4e4be1 100644
--- a/packages/@internationalized/date/src/calendars/EthiopicCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/EthiopicCalendar.ts
@@ -92,6 +92,10 @@ export class EthiopicCalendar implements Calendar {
     return getDaysInMonth(date.year, date.month);
   }
 
+  getMaxDays(): number {
+    return 30;
+  }
+
   getMonthsInYear(): number {
     return 13;
   }
diff --git a/packages/@internationalized/date/src/calendars/GregorianCalendar.ts b/packages/@internationalized/date/src/calendars/GregorianCalendar.ts
index 31106c379fe..1db651fa9df 100644
--- a/packages/@internationalized/date/src/calendars/GregorianCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/GregorianCalendar.ts
@@ -109,6 +109,10 @@ export class GregorianCalendar implements Calendar {
     return 12;
   }
 
+  getMaxDays(): number {
+    return 31;
+  }
+
   getDaysInYear(date: AnyCalendarDate): number {
     return isLeapYear(date.year) ? 366 : 365;
   }
diff --git a/packages/@internationalized/date/src/calendars/HebrewCalendar.ts b/packages/@internationalized/date/src/calendars/HebrewCalendar.ts
index 52d3f43bc2f..f48b30ec3f6 100644
--- a/packages/@internationalized/date/src/calendars/HebrewCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/HebrewCalendar.ts
@@ -172,6 +172,10 @@ export class HebrewCalendar implements Calendar {
     return getDaysInMonth(date.year, date.month);
   }
 
+  getMaxDays(): number {
+    return 30;
+  }
+
   getMonthsInYear(date: AnyCalendarDate): number {
     return isLeapYear(date.year) ? 13 : 12;
   }
diff --git a/packages/@internationalized/date/src/calendars/IslamicCalendar.ts b/packages/@internationalized/date/src/calendars/IslamicCalendar.ts
index 7696e852224..0106a887960 100644
--- a/packages/@internationalized/date/src/calendars/IslamicCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/IslamicCalendar.ts
@@ -69,6 +69,10 @@ export class IslamicCivilCalendar implements Calendar {
     return length;
   }
 
+  getMaxDays(): number {
+    return 30;
+  }
+
   getMonthsInYear(): number {
     return 12;
   }
diff --git a/packages/@internationalized/date/src/calendars/PersianCalendar.ts b/packages/@internationalized/date/src/calendars/PersianCalendar.ts
index 0ff6c86cec5..e1408e4aaa6 100644
--- a/packages/@internationalized/date/src/calendars/PersianCalendar.ts
+++ b/packages/@internationalized/date/src/calendars/PersianCalendar.ts
@@ -80,6 +80,10 @@ export class PersianCalendar implements Calendar {
     return isLeapYear ? 30 : 29;
   }
 
+  getMaxDays(): number {
+    return 31;
+  }
+
   getEras(): string[] {
     return ['AP'];
   }
diff --git a/packages/@internationalized/date/src/conversion.ts b/packages/@internationalized/date/src/conversion.ts
index 7b1ae398d1b..d60fb529b98 100644
--- a/packages/@internationalized/date/src/conversion.ts
+++ b/packages/@internationalized/date/src/conversion.ts
@@ -259,7 +259,7 @@ export function toTime(dateTime: CalendarDateTime | ZonedDateTime): Time {
 }
 
 /** Converts a date from one calendar system to another. */
-export function toCalendar<T extends AnyCalendarDate>(date: T, calendar: Calendar): T {
+export function toCalendar<T extends AnyCalendarDate>(date: T, calendar: Calendar, constrainDay?: boolean): T {
   if (isEqualCalendar(date.calendar, calendar)) {
     return date;
   }
@@ -271,7 +271,7 @@ export function toCalendar<T extends AnyCalendarDate>(date: T, calendar: Calenda
   copy.year = calendarDate.year;
   copy.month = calendarDate.month;
   copy.day = calendarDate.day;
-  constrain(copy);
+  constrain(copy, constrainDay);
   return copy;
 }
 
diff --git a/packages/@internationalized/date/src/manipulation.ts b/packages/@internationalized/date/src/manipulation.ts
index 87863dafaf6..0376c60507a 100644
--- a/packages/@internationalized/date/src/manipulation.ts
+++ b/packages/@internationalized/date/src/manipulation.ts
@@ -113,18 +113,22 @@ function balanceDay(date: Mutable<AnyCalendarDate>) {
   }
 }
 
-function constrainMonthDay(date: Mutable<AnyCalendarDate>) {
+function constrainMonthDay(date: Mutable<AnyCalendarDate>, constrainDay: boolean = true) {
   date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
-  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+  if (constrainDay) {
+    date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+  } else {
+    date.day = Math.max(1, Math.min(date.calendar.getMaxDays(), date.day));
+  }
 }
 
-export function constrain(date: Mutable<AnyCalendarDate>): void {
+export function constrain(date: Mutable<AnyCalendarDate>, constrainDay?: boolean): void {
   if (date.calendar.constrainDate) {
-    date.calendar.constrainDate(date);
+    date.calendar.constrainDate(date); 
   }
 
   date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
-  constrainMonthDay(date);
+  constrainMonthDay(date, constrainDay);
 }
 
 export function invertDuration(duration: DateTimeDuration): DateTimeDuration {
@@ -144,10 +148,10 @@ export function subtract(date: CalendarDate | CalendarDateTime, duration: DateTi
   return add(date, invertDuration(duration));
 }
 
-export function set(date: CalendarDateTime, fields: DateFields): CalendarDateTime;
-export function set(date: CalendarDate, fields: DateFields): CalendarDate;
-export function set(date: CalendarDate | CalendarDateTime, fields: DateFields): Mutable<AnyCalendarDate> {
-  let mutableDate: Mutable<AnyCalendarDate> = date.copy();
+export function set(date: CalendarDateTime, fields: DateFields, constrainDay?: boolean): CalendarDateTime;
+export function set(date: CalendarDate, fields: DateFields, constrainDay?: boolean): CalendarDate;
+export function set(date: CalendarDate | CalendarDateTime, fields: DateFields, constrainDay?: boolean): Mutable<AnyCalendarDate> {
+  let mutableDate: Mutable<AnyCalendarDate> = date.copy(constrainDay);
 
   if (fields.era != null) {
     mutableDate.era = fields.era;
@@ -165,14 +169,14 @@ export function set(date: CalendarDate | CalendarDateTime, fields: DateFields):
     mutableDate.day = fields.day;
   }
 
-  constrain(mutableDate);
+  constrain(mutableDate, constrainDay);
   return mutableDate;
 }
 
-export function setTime(value: CalendarDateTime, fields: TimeFields): CalendarDateTime;
-export function setTime(value: Time, fields: TimeFields): Time;
-export function setTime(value: Time | CalendarDateTime, fields: TimeFields): Mutable<Time | CalendarDateTime> {
-  let mutableValue: Mutable<Time | CalendarDateTime> = value.copy();
+export function setTime(value: CalendarDateTime, fields: TimeFields, constrainDay?: boolean): CalendarDateTime;
+export function setTime(value: Time, fields: TimeFields, constrainDay?: boolean): Time;
+export function setTime(value: Time | CalendarDateTime, fields: TimeFields, constrainDay?: boolean): Mutable<Time | CalendarDateTime> {
+  let mutableValue: Mutable<Time | CalendarDateTime> = value.copy(constrainDay);
 
   if (fields.hour != null) {
     mutableValue.hour = fields.hour;
@@ -243,9 +247,9 @@ export function subtractTime(time: Time, duration: TimeDuration): Time {
   return addTime(time, invertDuration(duration));
 }
 
-export function cycleDate(value: CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): CalendarDateTime;
-export function cycleDate(value: CalendarDate, field: DateField, amount: number, options?: CycleOptions): CalendarDate;
-export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): Mutable<CalendarDate | CalendarDateTime> {
+export function cycleDate(value: CalendarDateTime, field: DateField, amount: number, options?: CycleOptions, constrainDay?: boolean): CalendarDateTime;
+export function cycleDate(value: CalendarDate, field: DateField, amount: number, options?: CycleOptions, constrainDay?: boolean): CalendarDate;
+export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateField, amount: number, options?: CycleOptions, constrainDay?: boolean): Mutable<CalendarDate | CalendarDateTime> {
   let mutable: Mutable<CalendarDate | CalendarDateTime> = value.copy();
 
   switch (field) {
@@ -259,7 +263,7 @@ export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateFie
       mutable.era = eras[eraIndex];
 
       // Constrain the year and other fields within the era, so the era doesn't change when we balance below.
-      constrain(mutable);
+      constrain(mutable, constrainDay);
       break;
     }
     case 'year': {
@@ -284,7 +288,11 @@ export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateFie
       mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
       break;
     case 'day':
-      mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+      if (constrainDay) {
+        mutable.day = cycleValue(value.day, amount, 1, value.calendar.getMaxDays(), options?.round);
+      } else {
+        mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+      }
       break;
     default:
       throw new Error('Unsupported field ' + field);
@@ -294,7 +302,7 @@ export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateFie
     value.calendar.balanceDate(mutable);
   }
 
-  constrain(mutable);
+  constrain(mutable, constrainDay);
   return mutable;
 }
 
@@ -396,7 +404,7 @@ export function subtractZoned(dateTime: ZonedDateTime, duration: DateTimeDuratio
   return addZoned(dateTime, invertDuration(duration));
 }
 
-export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
+export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions, constrainDay?: boolean): ZonedDateTime {
   // For date fields, we want the time to remain consistent and the UTC offset to potentially change to account for DST changes.
   // For time fields, we want the time to change by the amount given. This may result in the hour field staying the same, but the UTC
   // offset changing in the case of a backward DST transition, or skipping an hour in the case of a forward DST transition.
@@ -450,20 +458,20 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
     case 'year':
     case 'month':
     case 'day': {
-      let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options);
+      let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options, constrainDay);
       let ms = toAbsolute(res, dateTime.timeZone);
-      return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+      return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar, constrainDay);
     }
     default:
       throw new Error('Unsupported field ' + field);
   }
 }
 
-export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
+export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation, constrainDay?: boolean): ZonedDateTime {
   // Set the date/time fields, and recompute the UTC offset to account for DST changes.
   // We also need to validate by converting back to a local time in case hours are skipped during forward DST transitions.
   let plainDateTime = toCalendarDateTime(dateTime);
-  let res = setTime(set(plainDateTime, fields), fields);
+  let res = setTime(set(plainDateTime, fields, constrainDay), fields);
 
   // If the resulting plain date time values are equal, return the original time.
   // We don't want to change the offset when setting the time to the same value.
diff --git a/packages/@internationalized/date/src/types.ts b/packages/@internationalized/date/src/types.ts
index 78fba68fe0d..4be08265ce3 100644
--- a/packages/@internationalized/date/src/types.ts
+++ b/packages/@internationalized/date/src/types.ts
@@ -57,6 +57,8 @@ export interface Calendar {
   getDaysInMonth(date: AnyCalendarDate): number,
   /** Returns the number of months in the year of the given date. */
   getMonthsInYear(date: AnyCalendarDate): number,
+  /** Returns the maximum day. */
+  getMaxDays(): number,
   /** Returns the number of years in the era of the given date. */
   getYearsInEra(date: AnyCalendarDate): number,
   /** Returns a list of era identifiers for the calendar. */
diff --git a/packages/@internationalized/date/tests/customCalendarImpl.ts b/packages/@internationalized/date/tests/customCalendarImpl.ts
index f8f48c65e69..0443a09307e 100644
--- a/packages/@internationalized/date/tests/customCalendarImpl.ts
+++ b/packages/@internationalized/date/tests/customCalendarImpl.ts
@@ -22,6 +22,10 @@ export class Custom454Calendar extends GregorianCalendar {
     return weekPattern[date.month - 1] * 7;
   }
 
+  getMaxDays(): number {
+    return 35;
+  }
+
   fromJulianDay(jd: number): CalendarDate {
     const date = super.fromJulianDay(jd);
     let year = date.year;
diff --git a/packages/@react-aria/datepicker/src/useDateField.ts b/packages/@react-aria/datepicker/src/useDateField.ts
index 5a04a465421..8d25e07ceea 100644
--- a/packages/@react-aria/datepicker/src/useDateField.ts
+++ b/packages/@react-aria/datepicker/src/useDateField.ts
@@ -81,9 +81,10 @@ export function useDateField<T extends DateValue>(props: AriaDateFieldOptions<T>
     },
     onBlurWithin: (e) => {
       state.confirmPlaceholder();
-      if (state.value !== valueOnFocus.current) {
+      if (state.shouldValidate) {
         state.commitValidation();
-      }
+        state.setShouldValidate(false);
+      };
       props.onBlur?.(e);
     },
     onFocusWithinChange: props.onFocusChange
diff --git a/packages/@react-aria/datepicker/src/useDateSegment.ts b/packages/@react-aria/datepicker/src/useDateSegment.ts
index 2aad84bc0ea..d1be8905b33 100644
--- a/packages/@react-aria/datepicker/src/useDateSegment.ts
+++ b/packages/@react-aria/datepicker/src/useDateSegment.ts
@@ -83,13 +83,13 @@ export function useDateSegment(segment: DateSegment, state: DateFieldState, ref:
     onIncrementToMax: () => {
       enteredKeys.current = '';
       if (segment.maxValue !== undefined) {
-        state.setSegment(segment.type, segment.maxValue);
+        state.incrementToMinMax(segment.type, segment.maxValue);
       }
     },
     onDecrementToMin: () => {
       enteredKeys.current = '';
       if (segment.minValue !== undefined) {
-        state.setSegment(segment.type, segment.minValue);
+        state.incrementToMinMax(segment.type, segment.minValue);
       }
     }
   });
diff --git a/packages/@react-spectrum/datepicker/test/DateField.test.js b/packages/@react-spectrum/datepicker/test/DateField.test.js
index 23f67cd79c1..fca23b29057 100644
--- a/packages/@react-spectrum/datepicker/test/DateField.test.js
+++ b/packages/@react-spectrum/datepicker/test/DateField.test.js
@@ -235,7 +235,11 @@ describe('DateField', function () {
           errorMessage="Date unavailable." />
       );
       await user.tab();
-      await user.keyboard('01011980');
+      await user.keyboard('1');
+      await user.keyboard('[ArrowRight]');
+      await user.keyboard('1');
+      await user.keyboard('[ArrowRight]');
+      await user.keyboard('1980[Tab]');
       expect(tree.getByText('Date unavailable.')).toBeInTheDocument();
     });
 
@@ -369,6 +373,7 @@ describe('DateField', function () {
       expect(input).toHaveAttribute('name', 'date');
       await user.tab();
       await user.keyboard('{ArrowUp}');
+      await user.tab({shift: true});
       expect(getDescription()).toBe('Selected Date: March 3, 2020');
       expect(input).toHaveValue('2020-03-03');
 
@@ -457,7 +462,7 @@ describe('DateField', function () {
           expect(document.activeElement).toBe(within(group).getAllByRole('spinbutton')[0]);
 
           await user.keyboard('[Tab][Tab][ArrowUp]');
-
+          
           expect(getDescription()).toContain('Value must be 2/3/2020 or later.');
           expect(input.validity.valid).toBe(true);
 
@@ -467,9 +472,13 @@ describe('DateField', function () {
 
           await user.tab({shift: true});
           await user.keyboard('2025');
+
           expect(getDescription()).not.toContain('Value must be 2/3/2024 or earlier.');
-          expect(input.validity.valid).toBe(false);
+          expect(input.validity.valid).toBe(true);
+
           await user.tab();
+          expect(getDescription()).toContain('Value must be 2/3/2024 or earlier.');
+          expect(input.validity.valid).toBe(false);
 
           act(() => {getByTestId('form').checkValidity();});
           expect(getDescription()).toContain('Value must be 2/3/2024 or earlier.');
@@ -503,12 +512,11 @@ describe('DateField', function () {
           expect(group).toHaveAttribute('aria-describedby');
           expect(getDescription()).toContain('Invalid value');
           expect(document.activeElement).toBe(within(group).getAllByRole('spinbutton')[0]);
-
           await user.keyboard('[ArrowRight][ArrowRight]2024');
 
           expect(getDescription()).toContain('Invalid value');
-          expect(input.validity.valid).toBe(true);
-
+          expect(input.validity.valid).toBe(false);
+          
           await user.tab();
 
           expect(getDescription()).not.toContain('Invalid value');
@@ -628,10 +636,12 @@ describe('DateField', function () {
           await user.keyboard('232023');
 
           expect(group).toHaveAttribute('aria-describedby');
-          expect(input.validity.valid).toBe(true);
+          expect(input.validity.valid).toBe(false);
 
           await user.tab();
           expect(getDescription()).not.toContain('Constraints not satisfied');
+          expect(group).toHaveAttribute('aria-describedby');
+          expect(input.validity.valid).toBe(true);
         });
       });
 
@@ -649,13 +659,13 @@ describe('DateField', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Value must be 2/3/2020 or later.');
 
-          await user.keyboard('[Tab][Tab][Tab][ArrowUp]');
+          await user.keyboard('[Tab][Tab][Tab][ArrowUp][Tab]');
           expect(getDescription()).not.toContain('Value must be 2/3/2020 or later.');
 
-          await user.keyboard('[ArrowUp][ArrowUp][ArrowUp][ArrowUp][ArrowUp]');
+          await user.keyboard('[Tab][Tab][Tab][ArrowUp][ArrowUp][ArrowUp][ArrowUp][ArrowUp][Tab]');
           expect(getDescription()).toContain('Value must be 2/3/2024 or earlier.');
 
-          await user.keyboard('[ArrowDown]');
+          await user.keyboard('[Tab][Tab][Tab][ArrowDown][Tab]');
           expect(getDescription()).not.toContain('Value must be 2/3/2024 or earlier.');
         });
 
@@ -673,7 +683,7 @@ describe('DateField', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Invalid value');
 
-          await user.keyboard('[Tab][ArrowRight][ArrowRight]2024');
+          await user.keyboard('[Tab][ArrowRight][ArrowRight]2024[Tab]');
           expect(getDescription()).not.toContain('Invalid value');
         });
 
diff --git a/packages/@react-spectrum/datepicker/test/DatePicker.test.js b/packages/@react-spectrum/datepicker/test/DatePicker.test.js
index 3b931ba8152..d484b6abedb 100644
--- a/packages/@react-spectrum/datepicker/test/DatePicker.test.js
+++ b/packages/@react-spectrum/datepicker/test/DatePicker.test.js
@@ -91,7 +91,7 @@ describe('DatePicker', function () {
       expect(segments[1].getAttribute('aria-valuenow')).toBe('3');
       expect(segments[1].getAttribute('aria-valuetext')).toBe('3');
       expect(segments[1].getAttribute('aria-valuemin')).toBe('1');
-      expect(segments[1].getAttribute('aria-valuemax')).toBe('28');
+      expect(segments[1].getAttribute('aria-valuemax')).toBe('31');
 
       expect(getTextValue(segments[2])).toBe('2019');
       expect(segments[2].getAttribute('aria-label')).toBe('year, ');
@@ -124,7 +124,7 @@ describe('DatePicker', function () {
       expect(segments[1].getAttribute('aria-valuenow')).toBe('3');
       expect(segments[1].getAttribute('aria-valuetext')).toBe('3');
       expect(segments[1].getAttribute('aria-valuemin')).toBe('1');
-      expect(segments[1].getAttribute('aria-valuemax')).toBe('28');
+      expect(segments[1].getAttribute('aria-valuemax')).toBe('31');
 
       expect(getTextValue(segments[2])).toBe('2019');
       expect(segments[2].getAttribute('aria-label')).toBe('year, ');
@@ -466,7 +466,6 @@ describe('DatePicker', function () {
 
       act(() => hour.focus());
       await user.keyboard('{ArrowUp}');
-
       expect(hour).toHaveAttribute('aria-valuetext', '9 AM');
 
       expect(dialog).toBeVisible();
@@ -512,16 +511,20 @@ describe('DatePicker', function () {
       expect(hour).toHaveAttribute('aria-valuetext', '10 AM');
 
       act(() => hour.focus());
+      expect(hour).toHaveAttribute('role', 'spinbutton');
+
       await user.keyboard('{Backspace}');
       expect(hour).toHaveAttribute('aria-valuetext', '1 AM');
 
       await user.keyboard('{Backspace}');
-      expect(hour).toHaveAttribute('aria-valuetext', '1 AM');
+      expect(hour).toHaveAttribute('aria-valuetext', 'Empty');
+
+      act(() => button.focus());
 
       expect(dialog).toBeVisible();
-      expect(onChange).toHaveBeenCalledTimes(2);
-      expect(onChange).toHaveBeenCalledWith(new CalendarDateTime(2019, 2, 4, 1, 45));
-      expect(getTextValue(combobox)).toBe('2/4/2019, 1:45 AM');
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith(new CalendarDateTime(2019, 2, 4, 10, 45));
+      expect(getTextValue(combobox)).toBe('2/4/2019, 10:45 AM');
     });
 
     it('should fire onChange until both date and time are selected', async function () {
@@ -1014,8 +1017,9 @@ describe('DatePicker', function () {
       expect(segments[2]).toHaveFocus();
     });
 
-    it('should focus the previous segment when the era is removed', async function () {
-      let {getByTestId, queryByTestId} = render(<DatePicker label="Date" defaultValue={new CalendarDate('BC', 2020, 2, 3)} />);
+    // This test should be reviewed
+    it('should focus the button when the era is removed', async function () {
+      let {getByTestId, queryByTestId, getByRole} = render(<DatePicker label="Date" defaultValue={new CalendarDate('BC', 2020, 2, 3)} />);
       let field = getByTestId('date-field');
       let era = getByTestId('era');
       expect(era).toBe(within(field).getAllByRole('spinbutton').pop());
@@ -1023,12 +1027,16 @@ describe('DatePicker', function () {
       act(() => era.focus());
       await user.keyboard('{ArrowUp}');
 
+      const button = getByRole('button');
+      act(() => button.focus());
+
       expect(queryByTestId('era')).toBeNull();
-      expect(document.activeElement).toBe(within(field).getAllByRole('spinbutton').pop());
+      expect(document.activeElement).toBe(button);
     });
 
-    it('should focus the next segment when the era is removed and is the first segment', async function () {
-      let {getByTestId, queryByTestId} = render(
+    // This test should be reviewed
+    it('should focus the button when the era is removed and is the first segment', async function () {
+      let {getByTestId, queryByTestId, getByRole} = render(
         <Provider theme={theme} locale="lv-LV">
           <DatePicker label="Date" defaultValue={new CalendarDate('BC', 2020, 2, 3)} />
         </Provider>
@@ -1040,8 +1048,10 @@ describe('DatePicker', function () {
       act(() => era.focus());
       await user.keyboard('{ArrowUp}');
 
+      const button = getByRole('button');
+      act(() => button.focus());
       expect(queryByTestId('era')).toBeNull();
-      expect(document.activeElement.textContent.replace(/[\u2066-\u2069]/g, '')).toBe('3');
+      expect(document.activeElement).toBe(button);
     });
 
     it('does not try to shift focus when the entire datepicker is unmounted while focused', function () {
@@ -1068,7 +1078,7 @@ describe('DatePicker', function () {
           </Provider>
         );
         let segment = getByLabelText(label);
-        let textContent = segment.textContent;
+        let textContent = segment.textContent;  
         act(() => {segment.focus();});
 
         await user.keyboard(`{${options?.upKey || 'ArrowUp'}}`);
@@ -1076,6 +1086,7 @@ describe('DatePicker', function () {
         expect(onChange).toHaveBeenCalledWith(incremented);
         expect(segment.textContent).toBe(textContent);
 
+        act(() => {segment.focus();});
         await user.keyboard(`{${options?.downKey || 'ArrowDown'}}`);
         expect(onChange).toHaveBeenCalledTimes(2);
         expect(onChange).toHaveBeenCalledWith(decremented);
@@ -1175,7 +1186,7 @@ describe('DatePicker', function () {
         });
 
         it('should wrap around when incrementing and decrementing the day', async function () {
-          await testArrows('day,', new CalendarDate(2019, 2, 28), new CalendarDate(2019, 2, 1), new CalendarDate(2019, 2, 27));
+          await testArrows('day,', new CalendarDate(2019, 8, 31), new CalendarDate(2019, 8, 1), new CalendarDate(2019, 8, 30));
           await testArrows('day,', new CalendarDate(2019, 2, 1), new CalendarDate(2019, 2, 2), new CalendarDate(2019, 2, 28));
         });
 
@@ -1308,7 +1319,7 @@ describe('DatePicker', function () {
       function testInput(label, value, keys, newValue, moved, props) {
         let onChange = jest.fn();
         // Test controlled mode
-        let {getByLabelText, getAllByRole, unmount} = render(
+        let {getByLabelText, getAllByRole, unmount, getByRole} = render(
           <Provider theme={theme} locale={props?.locale}>
             <DatePicker label="Date" value={value} onChange={onChange} {...props} />
           </Provider>
@@ -1319,22 +1330,18 @@ describe('DatePicker', function () {
         act(() => {segment.focus();});
 
         let allowsZero = (label.indexOf('hour') === 0 && props?.hourCycle === 24) || label.indexOf('minute') === 0 || label.indexOf('second') === 0;
-        let count = 0;
         for (let [i, key] of [...keys].entries()) {
           beforeInput(segment, key);
 
           if (key !== '0' || (moved && i === keys.length - 1) || allowsZero) {
-            expect(onChange).toHaveBeenCalledTimes(++count);
+            expect(onChange).toHaveBeenCalledTimes(0);
           }
-          expect(segment.textContent).toBe(textContent);
 
           if (i < keys.length - 1) {
             expect(segment).toHaveFocus();
           }
         }
 
-        expect(onChange).toHaveBeenCalledWith(newValue);
-
         if (moved) {
           let segments = getAllByRole('spinbutton');
           let nextSegment = segments[segments.indexOf(segment) + 1];
@@ -1343,6 +1350,11 @@ describe('DatePicker', function () {
           expect(segment).toHaveFocus();
         }
 
+        let button = getByRole('button');
+        act(() => button.focus());
+        expect(onChange).toHaveBeenCalledWith(newValue);
+        expect(segment.textContent).toBe(textContent);
+
         unmount();
 
         // Test uncontrolled mode
@@ -1356,13 +1368,11 @@ describe('DatePicker', function () {
         textContent = segment.textContent;
         act(() => {segment.focus();});
 
-        count = 0;
         for (let [i, key] of [...keys].entries()) {
           beforeInput(segment, key);
 
           if (key !== '0' || (moved && i === keys.length - 1) || allowsZero) {
-            expect(onChange).toHaveBeenCalledTimes(++count);
-            expect(segment.textContent).not.toBe(textContent);
+            expect(onChange).toHaveBeenCalledTimes(0);
           }
 
           if (i < keys.length - 1) {
@@ -1370,8 +1380,6 @@ describe('DatePicker', function () {
           }
         }
 
-        expect(onChange).toHaveBeenCalledWith(newValue);
-
         if (moved) {
           let segments = getAllByRole('spinbutton');
           let nextSegment = segments[segments.indexOf(segment) + 1];
@@ -1380,6 +1388,11 @@ describe('DatePicker', function () {
           expect(segment).toHaveFocus();
         }
 
+        button = getByRole('button');
+        act(() => button.focus());
+        expect(onChange).toHaveBeenCalledWith(newValue);
+        expect(segment.textContent).not.toBe(textContent);
+
         unmount();
 
         // Test read only mode
@@ -1521,12 +1534,14 @@ describe('DatePicker', function () {
         let onChange = jest.fn();
 
         // Test controlled mode
-        let {getByLabelText, unmount} = render(<DatePicker label="Date" value={value} onChange={onChange} {...options} />);
+        let {getByLabelText, unmount, getByRole} = render(<DatePicker label="Date" value={value} onChange={onChange} {...options} />);
         let segment = getByLabelText(label);
         let textContent = segment.textContent;
         act(() => {segment.focus();});
 
         await user.keyboard('{Backspace}');
+        let button = getByRole('button');
+        act(() => {button.focus();});
         expect(onChange).toHaveBeenCalledTimes(1);
         expect(onChange).toHaveBeenCalledWith(newValue);
         expect(segment.textContent).toBe(textContent);
@@ -1540,6 +1555,8 @@ describe('DatePicker', function () {
         act(() => {segment.focus();});
 
         await user.keyboard('{Backspace}');
+        button = getByRole('button');
+        act(() => {button.focus();});
         expect(onChange).toHaveBeenCalledTimes(1);
         expect(onChange).toHaveBeenCalledWith(newValue);
         if (label === 'AM/PM,') {
@@ -1613,6 +1630,7 @@ describe('DatePicker', function () {
         act(() => {segment.focus();});
 
         await user.keyboard('{Backspace}');
+        await user.tab();
         expect(onChange).toHaveBeenCalledTimes(1);
         expect(onChange).toHaveBeenCalledWith(new CalendarDate(201, 2, 3));
         expect(segment).toHaveTextContent('٢٠١');
@@ -1633,10 +1651,13 @@ describe('DatePicker', function () {
       let year = getByLabelText('year,');
       act(() => year.focus());
       await user.keyboard('{ArrowDown}');
+      await user.tab();
 
       expect(getByTestId('invalid-icon')).toBeVisible();
 
+      act(() => year.focus());
       await user.keyboard('{ArrowUp}');
+      await user.tab();
       expect(queryByTestId('invalid-icon')).toBeNull();
     });
 
@@ -1652,10 +1673,13 @@ describe('DatePicker', function () {
       let year = getByLabelText('year,');
       act(() => year.focus());
       await user.keyboard('{ArrowUp}');
+      await user.tab();
 
       expect(getByTestId('invalid-icon')).toBeVisible();
 
+      act(() => year.focus());
       await user.keyboard('{ArrowDown}');
+      await user.tab();
       expect(queryByTestId('invalid-icon')).toBeNull();
     });
   });
@@ -1758,7 +1782,7 @@ describe('DatePicker', function () {
       expectPlaceholder(combobox, formatter.format(value.toDate(getLocalTimeZone())));
     });
 
-    it('should enter a date to modify placeholder (uncontrolled)', function () {
+    it('should enter a date to modify placeholder (uncontrolled)', async function () {
       let onChange = jest.fn();
       let {getAllByRole} = render(<DatePicker label="Date" onChange={onChange} />);
 
@@ -1787,20 +1811,21 @@ describe('DatePicker', function () {
       expectPlaceholder(combobox, `${month}/${day}/yyyy`);
 
       beforeInput(document.activeElement, '2');
-      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '0');
-      expect(onChange).toHaveBeenCalledTimes(2);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '2');
-      expect(onChange).toHaveBeenCalledTimes(3);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '0');
       expect(segments[2]).toHaveFocus();
-      expect(onChange).toHaveBeenCalledTimes(4);
+      await user.tab();
+      expect(onChange).toHaveBeenCalledTimes(1);
       value = new CalendarDate(2020, 4, 5);
       expect(onChange).toHaveBeenCalledWith(value);
       expectPlaceholder(combobox, formatter.format(value.toDate(getLocalTimeZone())));
     });
 
-    it('should enter a date to modify placeholder (controlled)', function () {
+    it('should enter a date to modify placeholder (controlled)', async function () {
       let onChange = jest.fn();
       let {getAllByRole, rerender} = render(<DatePicker label="Date" onChange={onChange} value={null} />);
 
@@ -1828,10 +1853,18 @@ describe('DatePicker', function () {
       let day = parts.find(p => p.type === 'day').value;
       expectPlaceholder(combobox, `${month}/${day}/yyyy`);
 
-      beforeInput(document.activeElement, '2');
+      beforeInput(document.activeElement, '2'); 
+      expect(onChange).not.toHaveBeenCalled();
+      value = today(getLocalTimeZone()).set({month: 4, day: 5, year: 2});
+      parts = formatter.formatToParts(value.toDate(getLocalTimeZone()));
+      month = parts.find(p => p.type === 'month').value;
+      day = parts.find(p => p.type === 'day').value;
+      let year = parts.find(p => p.type === 'year').value;
+      expectPlaceholder(combobox, `${month}/${day}/${year}`);
+
+      await user.tab();
       expect(onChange).toHaveBeenCalledTimes(1);
       expect(onChange).toHaveBeenCalledWith(new CalendarDate(2, 4, 5));
-      expect(segments[2]).toHaveFocus();
       expectPlaceholder(combobox, 'mm/dd/yyyy'); // controlled
 
       value = new CalendarDate(2020, 4, 5);
@@ -2033,6 +2066,7 @@ describe('DatePicker', function () {
       expect(input).toHaveAttribute('name', 'date');
       await user.tab();
       await user.keyboard('{ArrowUp}');
+      await user.tab({shift: true});
       expect(getDescription()).toBe('Selected Date: March 3, 2020');
       expect(input).toHaveValue('2020-03-03');
 
@@ -2132,11 +2166,12 @@ describe('DatePicker', function () {
           await user.tab({shift: true});
           await user.keyboard('2025');
           expect(getDescription()).not.toContain('Value must be 2/3/2024 or earlier.');
-          expect(input.validity.valid).toBe(false);
+          expect(input.validity.valid).toBe(true);
           await user.tab();
 
           act(() => {getByTestId('form').checkValidity();});
           expect(getDescription()).toContain('Value must be 2/3/2024 or earlier.');
+          expect(input.validity.valid).toBe(false);
           expect(document.activeElement).toBe(within(group).getAllByRole('spinbutton')[0]);
 
           await user.keyboard('[Tab][Tab][ArrowDown]');
@@ -2171,7 +2206,7 @@ describe('DatePicker', function () {
           await user.keyboard('[ArrowRight][ArrowRight]2024');
 
           expect(getDescription()).toContain('Invalid value');
-          expect(input.validity.valid).toBe(true);
+          expect(input.validity.valid).toBe(false);
 
           await user.tab();
 
@@ -2307,13 +2342,13 @@ describe('DatePicker', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Value must be 2/3/2020 or later.');
 
-          await user.keyboard('[Tab][Tab][Tab][ArrowUp]');
+          await user.keyboard('[Tab][Tab][Tab][ArrowUp][Tab]');
           expect(getDescription()).not.toContain('Value must be 2/3/2020 or later.');
 
-          await user.keyboard('[ArrowUp][ArrowUp][ArrowUp][ArrowUp][ArrowUp]');
+          await user.keyboard('[Tab][Tab][Tab][Tab][ArrowUp][ArrowUp][ArrowUp][ArrowUp][ArrowUp][Tab]');
           expect(getDescription()).toContain('Value must be 2/3/2024 or earlier.');
 
-          await user.keyboard('[ArrowDown]');
+          await user.keyboard('[Tab][Tab][Tab][Tab][ArrowDown][Tab]');
           expect(getDescription()).not.toContain('Value must be 2/3/2024 or earlier.');
         });
 
@@ -2331,7 +2366,7 @@ describe('DatePicker', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Invalid value');
 
-          await user.keyboard('[Tab][ArrowRight][ArrowRight]2024');
+          await user.keyboard('[Tab][ArrowRight][ArrowRight]2024[Tab]');
           expect(getDescription()).not.toContain('Invalid value');
         });
 
diff --git a/packages/@react-spectrum/datepicker/test/DateRangePicker.test.js b/packages/@react-spectrum/datepicker/test/DateRangePicker.test.js
index cf027ab73ad..072dfddeba1 100644
--- a/packages/@react-spectrum/datepicker/test/DateRangePicker.test.js
+++ b/packages/@react-spectrum/datepicker/test/DateRangePicker.test.js
@@ -103,7 +103,7 @@ describe('DateRangePicker', function () {
       expect(segments[1].getAttribute('aria-valuenow')).toBe('3');
       expect(segments[1].getAttribute('aria-valuetext')).toBe('3');
       expect(segments[1].getAttribute('aria-valuemin')).toBe('1');
-      expect(segments[1].getAttribute('aria-valuemax')).toBe('28');
+      expect(segments[1].getAttribute('aria-valuemax')).toBe('31');
 
       expect(getTextValue(segments[2])).toBe('2019');
       expect(segments[2].getAttribute('aria-label')).toBe('year, Start Date, ');
@@ -157,7 +157,7 @@ describe('DateRangePicker', function () {
       expect(segments[1].getAttribute('aria-valuenow')).toBe('3');
       expect(segments[1].getAttribute('aria-valuetext')).toBe('3');
       expect(segments[1].getAttribute('aria-valuemin')).toBe('1');
-      expect(segments[1].getAttribute('aria-valuemax')).toBe('28');
+      expect(segments[1].getAttribute('aria-valuemax')).toBe('31');
 
       expect(getTextValue(segments[2])).toBe('2019');
       expect(segments[2].getAttribute('aria-label')).toBe('year, Start Date, ');
@@ -548,7 +548,7 @@ describe('DateRangePicker', function () {
       expect(hour).toHaveAttribute('aria-valuetext', '11 AM');
 
       expect(dialog).toBeVisible();
-      expect(onChange).toHaveBeenCalledTimes(3);
+      expect(onChange).toHaveBeenCalledTimes(4);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDateTime(2019, 2, 10, 9, 45), end: new CalendarDateTime(2019, 2, 17, 11, 45)});
       expect(getTextValue(startDate)).toBe('2/10/2019, 9:45 AM');
       expect(getTextValue(endDate)).toBe('2/17/2019, 11:45 AM');
@@ -764,6 +764,7 @@ describe('DateRangePicker', function () {
 
       for (let timeField of [startTimeField, endTimeField]) {
         let hour = within(timeField).getByLabelText('hour,');
+        
         act(() => hour.focus());
         fireEvent.keyDown(hour, {key: 'ArrowUp'});
         fireEvent.keyUp(hour, {key: 'ArrowUp'});
@@ -1140,7 +1141,7 @@ describe('DateRangePicker', function () {
       fireEvent.keyDown(endYear, {key: 'ArrowUp'});
 
       expect(endYear).toHaveTextContent('2020'); // uncontrolled
-      expect(onChange).toHaveBeenCalledTimes(2);
+      expect(onChange).toHaveBeenCalledTimes(3);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 1, 3), end: new CalendarDate(2020, 5, 6)});
     });
 
@@ -1168,11 +1169,11 @@ describe('DateRangePicker', function () {
       fireEvent.keyDown(endYear, {key: 'ArrowUp'});
 
       expect(endYear).toHaveTextContent('2019'); // controlled
-      expect(onChange).toHaveBeenCalledTimes(2);
+      expect(onChange).toHaveBeenCalledTimes(3);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 2, 3), end: new CalendarDate(2020, 5, 6)});
     });
 
-    it('should edit a date range by entering text (uncontrolled)', function () {
+    it('should edit a date range by entering text (uncontrolled)', async function () {
       let onChange = jest.fn();
       let {getByLabelText} = render(
         <DateRangePicker
@@ -1186,10 +1187,11 @@ describe('DateRangePicker', function () {
       beforeInput(startMonth, '8');
 
       expect(startMonth).toHaveTextContent('8'); // uncontrolled
+      expect(getByLabelText('day, Start Date,')).toHaveFocus();
+      await user.keyboard('[Tab][Tab]');
       expect(onChange).toHaveBeenCalledTimes(1);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 8, 3), end: new CalendarDate(2019, 5, 6)});
 
-      expect(getByLabelText('day, Start Date,')).toHaveFocus();
 
       let endYear = getByLabelText('year, End Date,');
       expect(endYear).toHaveTextContent('2019');
@@ -1200,11 +1202,12 @@ describe('DateRangePicker', function () {
       beforeInput(endYear, '2');
 
       expect(endYear).toHaveTextContent('2022'); // uncontrolled
-      expect(onChange).toHaveBeenCalledTimes(5);
+      act(() => {endYear.blur();});
+      expect(onChange).toHaveBeenCalledTimes(2);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 8, 3), end: new CalendarDate(2022, 5, 6)});
     });
 
-    it('should edit a date range by entering text (controlled)', function () {
+    it('should edit a date range by entering text (controlled)', async function () {
       let onChange = jest.fn();
       let {getByLabelText} = render(
         <DateRangePicker
@@ -1217,18 +1220,18 @@ describe('DateRangePicker', function () {
       act(() => {startMonth.focus();});
       beforeInput(startMonth, '8');
 
-      expect(startMonth).toHaveTextContent('2'); // controlled
+      expect(startMonth).toHaveTextContent('8'); // controlled
+      await user.keyboard('[Tab][Tab]');
       expect(onChange).toHaveBeenCalledTimes(1);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 8, 3), end: new CalendarDate(2019, 5, 6)});
 
-      expect(getByLabelText('day, Start Date,')).toHaveFocus();
-
       let endDay = getByLabelText('day, End Date,');
       expect(endDay).toHaveTextContent('6');
       act(() => {endDay.focus();});
       beforeInput(endDay, '4');
 
-      expect(endDay).toHaveTextContent('6'); // controlled
+      expect(endDay).toHaveTextContent('4'); // controlled
+      await user.keyboard('[Tab][Tab]');
       expect(onChange).toHaveBeenCalledTimes(2);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 2, 3), end: new CalendarDate(2019, 5, 4)});
     });
@@ -1246,13 +1249,13 @@ describe('DateRangePicker', function () {
       expect(endYear).toHaveTextContent('2019');
       act(() => {endYear.focus();});
       fireEvent.keyDown(endYear, {key: 'Backspace'});
-
+      act(() => {endYear.blur();});
       expect(endYear).toHaveTextContent('201'); // uncontrolled
       expect(onChange).toHaveBeenCalledTimes(1);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 2, 3), end: new CalendarDate(201, 5, 6)});
     });
 
-    it('should support backspace (controlled)', function () {
+    it('should support backspace (controlled)', async function () {
       let onChange = jest.fn();
       let {getByLabelText} = render(
         <DateRangePicker
@@ -1265,7 +1268,7 @@ describe('DateRangePicker', function () {
       expect(endYear).toHaveTextContent('2019');
       act(() => {endYear.focus();});
       fireEvent.keyDown(endYear, {key: 'Backspace'});
-
+      act(() => {endYear.blur();});
       expect(endYear).toHaveTextContent('2019'); // controlled
       expect(onChange).toHaveBeenCalledTimes(1);
       expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2019, 2, 3), end: new CalendarDate(201, 5, 6)});
@@ -1415,7 +1418,7 @@ describe('DateRangePicker', function () {
       expectPlaceholder(endDate, 'mm/dd/yyyy');
     });
 
-    it('should not fire onChange until both start and end dates have been entered', function () {
+    it('should not fire onChange until both start and end dates have been entered', async function () {
       let onChange = jest.fn();
       let {getByTestId, getAllByRole} = render(<DateRangePicker label="Date range" onChange={onChange} />);
 
@@ -1433,8 +1436,8 @@ describe('DateRangePicker', function () {
       expect(segments[1]).toHaveFocus();
       expect(onChange).not.toHaveBeenCalled();
 
-      beforeInput(document.activeElement, '3');
-      expectPlaceholder(startDate, '2/3/yyyy');
+      beforeInput(document.activeElement, '4');
+      expectPlaceholder(startDate, '2/4/yyyy');
       expect(segments[2]).toHaveFocus();
       expect(onChange).not.toHaveBeenCalled();
 
@@ -1442,7 +1445,7 @@ describe('DateRangePicker', function () {
       beforeInput(document.activeElement, '0');
       beforeInput(document.activeElement, '2');
       beforeInput(document.activeElement, '0');
-      expectPlaceholder(startDate, '2/3/2020');
+      expectPlaceholder(startDate, '2/4/2020');
       expect(segments[3]).toHaveFocus();
       expect(onChange).not.toHaveBeenCalled();
 
@@ -1457,15 +1460,15 @@ describe('DateRangePicker', function () {
       expect(onChange).not.toHaveBeenCalled();
 
       beforeInput(document.activeElement, '2');
-      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '0');
-      expect(onChange).toHaveBeenCalledTimes(2);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '2');
-      expect(onChange).toHaveBeenCalledTimes(3);
+      expect(onChange).toHaveBeenCalledTimes(0);
       beforeInput(document.activeElement, '2');
-      expect(onChange).toHaveBeenCalledTimes(4);
-
-      expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2020, 2, 3), end: new CalendarDate(2022, 4, 8)});
+      expect(onChange).toHaveBeenCalledTimes(0);
+      await user.keyboard('[Tab]');
+      expect(onChange).toHaveBeenCalledWith({start: new CalendarDate(2020, 2, 4), end: new CalendarDate(2022, 4, 8)});
     });
 
     it('should reset to the placeholder if controlled value is set to null', function () {
@@ -1662,8 +1665,8 @@ describe('DateRangePicker', function () {
 
           await user.keyboard('[ArrowRight][ArrowRight]2026');
           expect(getDescription()).toContain('Invalid value');
-          expect(startInput.validity.valid).toBe(true);
-          expect(endInput.validity.valid).toBe(true);
+          expect(startInput.validity.valid).toBe(false);
+          expect(endInput.validity.valid).toBe(false);
 
           await user.tab();
           expect(getDescription()).not.toContain('Invalid value');
diff --git a/packages/@react-spectrum/datepicker/test/TimeField.test.js b/packages/@react-spectrum/datepicker/test/TimeField.test.js
index 22dad189813..026462f0230 100644
--- a/packages/@react-spectrum/datepicker/test/TimeField.test.js
+++ b/packages/@react-spectrum/datepicker/test/TimeField.test.js
@@ -287,6 +287,7 @@ describe('TimeField', function () {
       expect(input).toHaveAttribute('name', 'time');
       fireEvent.keyDown(segments[0], {key: 'ArrowUp'});
       fireEvent.keyUp(segments[0], {key: 'ArrowUp'});
+      await user.keyboard('[Tab][Tab][Tab][Tab]');
       expect(getDescription()).toBe('Selected Time: 9:30 AM');
       expect(input).toHaveValue('09:30:00');
 
@@ -381,6 +382,7 @@ describe('TimeField', function () {
 
           await user.tab({shift: true});
           expect(getDescription()).not.toContain('Value must be 9:00 AM or later.');
+          expect(input.validity.valid).toBe(true);
 
           await user.tab();
           await user.keyboard('6[Tab][ArrowUp]');
@@ -390,6 +392,7 @@ describe('TimeField', function () {
 
           act(() => {getByTestId('form').checkValidity();});
           expect(getDescription()).toContain('Value must be 5:00 PM or earlier.');
+          expect(input.validity.valid).toBe(false);
           expect(document.activeElement).toBe(within(group).getAllByRole('spinbutton')[0]);
 
           await user.keyboard('[ArrowDown]');
@@ -398,6 +401,7 @@ describe('TimeField', function () {
           act(() => document.activeElement.blur());
 
           expect(getDescription()).not.toContain('Value must be 5:00 PM or earlier.');
+          expect(input.validity.valid).toBe(true);
         });
 
         it('supports validate function', async () => {
@@ -424,7 +428,7 @@ describe('TimeField', function () {
           await user.keyboard('10');
 
           expect(getDescription()).toContain('Invalid value');
-          expect(input.validity.valid).toBe(true);
+          expect(input.validity.valid).toBe(false);
 
           act(() => document.activeElement.blur());
 
@@ -530,13 +534,13 @@ describe('TimeField', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Value must be 9:00 AM or later.');
 
-          await user.keyboard('[Tab][ArrowUp]');
+          await user.keyboard('[Tab][ArrowUp][Tab][Tab][Tab]');
           expect(getDescription()).not.toContain('Value must be 9:00 AM or later');
 
-          await user.keyboard('6[Tab][ArrowUp]');
+          await user.keyboard('[Tab]6[Tab][ArrowUp][Tab][Tab][Tab]');
           expect(getDescription()).toContain('Value must be 5:00 PM or earlier');
 
-          await user.keyboard('[Tab][Tab][ArrowDown]');
+          await user.keyboard('[Tab][ArrowDown][Tab][Tab]');
           expect(getDescription()).not.toContain('Value must be 5:00 PM or earlier');
         });
 
@@ -554,7 +558,7 @@ describe('TimeField', function () {
           let getDescription = () => group.getAttribute('aria-describedby').split(' ').map(d => document.getElementById(d).textContent).join(' ');
           expect(getDescription()).toContain('Invalid value');
 
-          await user.keyboard('[Tab]10');
+          await user.keyboard('[Tab]10[Tab][Tab]');
           expect(getDescription()).not.toContain('Invalid value');
         });
 
diff --git a/packages/@react-stately/datepicker/src/useDateFieldState.ts b/packages/@react-stately/datepicker/src/useDateFieldState.ts
index 2bf28053575..a39cb2f7190 100644
--- a/packages/@react-stately/datepicker/src/useDateFieldState.ts
+++ b/packages/@react-stately/datepicker/src/useDateFieldState.ts
@@ -71,6 +71,9 @@ export interface DateFieldState extends FormValidationState {
   isReadOnly: boolean,
   /** Whether the field is required. */
   isRequired: boolean,
+  /** Whether the field is changed. */
+  shouldValidate: boolean,
+  setShouldValidate(value: boolean): void,
   /** Increments the given segment. Upon reaching the minimum or maximum value, the value wraps around to the opposite limit. */
   increment(type: SegmentType): void,
   /** Decrements the given segment. Upon reaching the minimum or maximum value, the value wraps around to the opposite limit. */
@@ -90,6 +93,8 @@ export interface DateFieldState extends FormValidationState {
   /** Sets the value of the given segment. */
   setSegment(type: 'era', value: string): void,
   setSegment(type: SegmentType, value: number): void,
+  /** Sets the value of the given segment by the maximum or the minimum, for example 31 days, 12 months, and 9999 years. */
+  incrementToMinMax(type: SegmentType, value: number): void,
   /** Updates the remaining unfilled segments with the placeholder value. */
   confirmPlaceholder(): void,
   /** Clears the value of the given segment, reverting it to the placeholder. */
@@ -167,6 +172,7 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
   let v: DateValue | null = props.value || props.defaultValue || props.placeholderValue || null;
   let [granularity, defaultTimeZone] = useDefaultProps(v, props.granularity);
   let timeZone = defaultTimeZone || 'UTC';
+  const [shouldValidate, setShouldValidate] = useState(false);
 
   // props.granularity must actually exist in the value if one is provided.
   if (v && !(granularity in v)) {
@@ -182,6 +188,9 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
     props.onChange
   );
 
+  const [isValueConfirmed, setIsValueConfirmed] = useState(!!(value));
+  const [previousValue, setPreviousValue] = useState(value);
+
   let [initialValue] = useState(value);
   let calendarValue = useMemo(() => convertValue(value, calendar) ?? null, [value, calendar]);
 
@@ -237,20 +246,24 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
   }, [calendar, granularity, validSegments, defaultTimeZone, props.placeholderValue]);
 
   // If there is a value prop, and some segments were previously placeholders, mark them all as valid.
-  if (value && Object.keys(validSegments).length < Object.keys(allSegments).length) {
+  if (value !== previousValue && value && Object.keys(validSegments).length <= Object.keys(allSegments).length) {
     validSegments = {...allSegments};
     setValidSegments(validSegments);
+    setPreviousValue(value);
+    setIsValueConfirmed(true);
   }
 
+
   // If the value is set to null and all segments are valid, reset the placeholder.
-  if (value == null && Object.keys(validSegments).length === Object.keys(allSegments).length) {
+  if (value !== previousValue && value == null && Object.keys(validSegments).length === Object.keys(allSegments).length) {
     validSegments = {};
     setValidSegments(validSegments);
     setPlaceholderDate(createPlaceholderDate(props.placeholderValue, granularity, calendar, defaultTimeZone));
+    setPreviousValue(value);
+    setIsValueConfirmed(true);
   }
-
   // If all segments are valid, use the date from state, otherwise use the placeholder date.
-  let displayValue = calendarValue && Object.keys(validSegments).length >= Object.keys(allSegments).length ? calendarValue : placeholderDate;
+  let displayValue = isValueConfirmed && value ? value :  placeholderDate ;
   let setValue = (newValue: DateValue) => {
     if (props.isDisabled || props.isReadOnly) {
       return;
@@ -261,6 +274,7 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
     // if all the segments are completed or a timefield with everything but am/pm set the time, also ignore when am/pm cleared
     if (newValue == null) {
       setDate(null);
+      setPreviousValue(null);
       setPlaceholderDate(createPlaceholderDate(props.placeholderValue, granularity, calendar, defaultTimeZone));
       setValidSegments({});
     } else if (
@@ -277,18 +291,30 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
 
       // The display calendar should not have any effect on the emitted value.
       // Emit dates in the same calendar as the original value, if any, otherwise gregorian.
-      newValue = toCalendar(newValue, v?.calendar || new GregorianCalendar());
-      setDate(newValue);
-    } else {
-      setPlaceholderDate(newValue);
+      const value = toCalendar(newValue, v?.calendar || new GregorianCalendar());
+      setDate(value);
+      setIsValueConfirmed(true);
+      setPreviousValue(value);
     }
-    clearedSegment.current = null;
+  };
+
+  let constrainDate = (value: DateValue) => {
+    const day = Math.max(1, Math.min(value.calendar.getDaysInMonth(value), value.day));
+    return setSegment(value, 'day', day, resolvedOptions); 
+  };
+
+  let updatePlaceholder = (newValue: DateValue) => {
+    if (props.isDisabled || props.isReadOnly) {
+      return;
+    }
+    displayValue = newValue;
+    setPlaceholderDate(newValue);
   };
 
   let dateValue = useMemo(() => displayValue.toDate(timeZone), [displayValue, timeZone]);
-  let segments = useMemo(() =>
-    processSegments(dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity),
-    [dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity]);
+  let segments = useMemo(() => 
+    processSegments(dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity, isValueConfirmed), 
+    [dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity, isValueConfirmed]);
 
   // When the era field appears, mark it valid if the year field is already valid.
   // If the era field disappears, remove it from the valid segments.
@@ -309,17 +335,27 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
   };
 
   let adjustSegment = (type: Intl.DateTimeFormatPartTypes, amount: number) => {
+    setShouldValidate(true);
+    setIsValueConfirmed(false);
+    
+    let v = displayValue;
     if (!validSegments[type]) {
       markValid(type);
-      let validKeys = Object.keys(validSegments);
-      let allKeys = Object.keys(allSegments);
-      if (validKeys.length >= allKeys.length || (validKeys.length === allKeys.length - 1 && allSegments.dayPeriod && !validSegments.dayPeriod)) {
-        setValue(displayValue);
-      }
     } else {
-      setValue(addSegment(displayValue, type, amount, resolvedOptions));
+      v = addSegment(displayValue, type, amount, resolvedOptions);
+    }
+
+    let validKeys = Object.keys(validSegments);
+    let allKeys = Object.keys(allSegments);
+    if (validKeys.length >= allKeys.length || (validKeys.length === allKeys.length - 1 && allSegments.dayPeriod && !validSegments.dayPeriod)) {
+      const constrained = constrainDate(v);
+      displayValue = constrained; 
+      setValue(constrained);
+    } else {
+      updatePlaceholder(v);
     }
   };
+  
 
   let builtinValidation = useMemo(() => getValidationResult(
     value,
@@ -354,6 +390,8 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
     isDisabled,
     isReadOnly,
     isRequired,
+    shouldValidate,
+    setShouldValidate,
     increment(part) {
       adjustSegment(part, 1);
     },
@@ -367,24 +405,44 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
       adjustSegment(part, -(PAGE_STEP[part] || 1));
     },
     setSegment(part, v: string | number) {
+      setIsValueConfirmed(false);
+      setShouldValidate(true);
       markValid(part);
-      setValue(setSegment(displayValue, part, v, resolvedOptions));
+      updatePlaceholder(setSegment(displayValue, part, v, resolvedOptions));
+    },
+    incrementToMinMax(part, v: string | number)  {
+      setIsValueConfirmed(false);
+      setShouldValidate(true);
+      markValid(part);
+      let validKeys = Object.keys(validSegments);
+      let allKeys = Object.keys(allSegments);
+      const value = setSegment(displayValue, part, v, resolvedOptions);
+      if (validKeys.length >= allKeys.length || (validKeys.length === allKeys.length - 1 && allSegments.dayPeriod && !validSegments.dayPeriod)) {
+        setValue(constrainDate(value));
+      } else {
+        updatePlaceholder(value);
+      }
     },
     confirmPlaceholder() {
       if (props.isDisabled || props.isReadOnly) {
         return;
       }
 
-      // Confirm the placeholder if only the day period is not filled in.
       let validKeys = Object.keys(validSegments);
       let allKeys = Object.keys(allSegments);
-      if (validKeys.length === allKeys.length - 1 && allSegments.dayPeriod && !validSegments.dayPeriod) {
+      if (validKeys.length >= allKeys.length || 
+      (validKeys.length === allKeys.length - 1 && allSegments.dayPeriod && !validSegments.dayPeriod && clearedSegment.current !== 'dayPeriod')) {
         validSegments = {...allSegments};
         setValidSegments(validSegments);
-        setValue(displayValue.copy());
+        setValue(constrainDate(displayValue));
+      } else {
+        setDate(null);
+        setPreviousValue(null);
+        setIsValueConfirmed(true);
       }
     },
     clearSegment(part) {
+      setIsValueConfirmed(false);
       delete validSegments[part];
       clearedSegment.current = part;
       setValidSegments({...validSegments});
@@ -397,18 +455,16 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
         let isPM = displayValue.hour >= 12;
         let shouldBePM = placeholder.hour >= 12;
         if (isPM && !shouldBePM) {
-          value = displayValue.set({hour: displayValue.hour - 12});
+          value = displayValue.set({hour: displayValue.hour - 12}, false);
         } else if (!isPM && shouldBePM) {
-          value = displayValue.set({hour: displayValue.hour + 12});
+          value = displayValue.set({hour: displayValue.hour + 12}, false);
         }
       } else if (part === 'hour' && 'hour' in displayValue && displayValue.hour >= 12 && validSegments.dayPeriod) {
-        value = displayValue.set({hour: placeholder['hour'] + 12});
+        value = displayValue.set({hour: placeholder['hour'] + 12}, false);
       } else if (part in displayValue) {
-        value = displayValue.set({[part]: placeholder[part]});
+        value = displayValue.set({[part]: placeholder[part]}, false);
       }
-
-      setDate(null);
-      setValue(value);
+      updatePlaceholder(value);
     },
     formatValue(fieldOptions: FieldOptions) {
       if (!calendarValue) {
@@ -427,7 +483,7 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
   };
 }
 
-function processSegments(dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity) : DateSegment[] {
+function processSegments(dateValue, validSegments, dateFormatter, resolvedOptions, displayValue, calendar, locale, granularity, isConfirmed: boolean) : DateSegment[] {
   let timeValue = ['hour', 'minute', 'second'];
   let segments = dateFormatter.formatToParts(dateValue);
   let processedSegments: DateSegment[] = [];
@@ -441,9 +497,25 @@ function processSegments(dateValue, validSegments, dateFormatter, resolvedOption
     let isPlaceholder = EDITABLE_SEGMENTS[type] && !validSegments[type];
     let placeholder = EDITABLE_SEGMENTS[type] ? getPlaceholder(type, segment.value, locale) : null;
 
+    let value = segment.value;
+
+    if (!isConfirmed && ['day', 'month', 'year'].includes(segment.type)) {
+      let numberFormatter = new Intl.NumberFormat(locale, {
+        useGrouping: false
+      });
+
+      let twoDigitFormatter = new Intl.NumberFormat(locale, {
+        useGrouping: false,
+        minimumIntegerDigits: 2
+      });
+
+      let f = dateFormatter.resolvedOptions()[segment.type] === '2-digit' ? twoDigitFormatter : numberFormatter;
+      value = f.format(displayValue[segment.type]);
+    }
+
     let dateSegment = {
       type,
-      text: isPlaceholder ? placeholder : segment.value,
+      text: isPlaceholder ? placeholder : value,
       ...getSegmentLimits(displayValue, type, resolvedOptions),
       isPlaceholder,
       placeholder,
@@ -502,7 +574,7 @@ function getSegmentLimits(date: DateValue, type: string, options: Intl.ResolvedD
       return {
         value: eras.indexOf(date.era),
         minValue: 0,
-        maxValue: eras.length - 1
+        maxValue: eras.length - 1  
       };
     }
     case 'year':
@@ -521,7 +593,7 @@ function getSegmentLimits(date: DateValue, type: string, options: Intl.ResolvedD
       return {
         value: date.day,
         minValue: getMinimumDayInMonth(date),
-        maxValue: date.calendar.getDaysInMonth(date)
+        maxValue: date.calendar.getMaxDays()
       };
   }
 
@@ -572,7 +644,7 @@ function addSegment(value: DateValue, part: string, amount: number, options: Int
     case 'year':
     case 'month':
     case 'day':
-      return value.cycle(part, amount, {round: part === 'year'});
+      return value.cycle(part, amount, {round: part === 'year'}, false);
   }
 
   if ('hour' in value) {
@@ -580,7 +652,7 @@ function addSegment(value: DateValue, part: string, amount: number, options: Int
       case 'dayPeriod': {
         let hours = value.hour;
         let isPM = hours >= 12;
-        return value.set({hour: isPM ? hours - 12 : hours + 12});
+        return value.set({hour: isPM ? hours - 12 : hours + 12}, false);
       }
       case 'hour':
       case 'minute':
@@ -588,7 +660,7 @@ function addSegment(value: DateValue, part: string, amount: number, options: Int
         return value.cycle(part, amount, {
           round: part !== 'hour',
           hourCycle: options.hour12 ? 12 : 24
-        });
+        }, false);
     }
   }
 
@@ -601,19 +673,19 @@ function setSegment(value: DateValue, part: string, segmentValue: number | strin
     case 'month':
     case 'year':
     case 'era':
-      return value.set({[part]: segmentValue});
+      return value.set({[part]: segmentValue}, false);
   }
 
   if ('hour' in value && typeof segmentValue === 'number') {
     switch (part) {
       case 'dayPeriod': {
-        let hours = value.hour;
+        let hours = value.hour; 
         let wasPM = hours >= 12;
         let isPM = segmentValue >= 12;
         if (isPM === wasPM) {
           return value;
         }
-        return value.set({hour: wasPM ? hours - 12 : hours + 12});
+        return value.set({hour: wasPM ? hours - 12 : hours + 12}, false);
       }
       case 'hour':
         // In 12 hour time, ensure that AM/PM does not change
@@ -630,7 +702,7 @@ function setSegment(value: DateValue, part: string, segmentValue: number | strin
         // fallthrough
       case 'minute':
       case 'second':
-        return value.set({[part]: segmentValue});
+        return value.set({[part]: segmentValue}, false);
     }
   }