@@ -32,17 +32,30 @@ import {
 } from './native';
 import {observeSelectMutations} from './select';
 
+/**
+ * Normalizes a control value for comparison, collapsing an invalid `Date` to `null`.
+ *
+ * A `Date` with a `NaN` timestamp has no representation a date-like input can hold: assigning it to
+ * `valueAsDate` empties the input, which then reads back as `null`. Treating the two as the same
+ * value keeps that round-trip from looking like an edit.
+ */
+function normalizeControlValue(value: unknown): unknown {
+  return value instanceof Date && Number.isNaN(value.getTime()) ? null : value;
+}
+
 /**
  * Compares two control values, treating `Date`s for the same instant as equal.
  *
  * Date-like inputs are read through `valueAsDate`, which returns a fresh `Date` on every access, so
  * identity comparison alone would report a change even when the input was never touched.
  */
 function controlValuesEqual(a: unknown, b: unknown): boolean {
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
+  const normalizedA = normalizeControlValue(a);
+  const normalizedB = normalizeControlValue(b);
+  if (normalizedA instanceof Date && normalizedB instanceof Date) {
+    return normalizedA.getTime() === normalizedB.getTime();
   }
-  return Object.is(a, b);
+  return Object.is(normalizedA, normalizedB);
 }
 
 export function nativeControlCreate(
 
@@ -5662,6 +5662,34 @@ describe('field directive', () => {
       expect(field().value()).toEqual(new Date('2024-01-01T00:00:00.000Z'));
     });
 
+    // An invalid `Date` has a `NaN` timestamp, and `NaN === NaN` is false, so comparing instants
+    // alone reports a change on every sync and dirties the field on load. See #69632.
+    it('should not be dirty when the initial validity animation fires on an invalid Date model', () => {
+      @Component({
+        imports: [FormField],
+        template: `<input type="date" [formField]="f" />`,
+      })
+      class TestCmp {
+        f = form(signal<Date | null>(new Date('invalid')));
+      }
+
+      const fix = act(() => TestBed.createComponent(TestCmp));
+      const input = fix.nativeElement.firstChild as HTMLInputElement;
+      const field = fix.componentInstance.f;
+
+      expect(field().dirty()).toBe(false);
+
+      act(() => {
+        input.dispatchEvent(
+          new AnimationEvent('animationstart', {animationName: 'ng-invalid', bubbles: true}),
+        );
+      });
+
+      expect(field().dirty()).toBe(false);
+      // The model keeps the value the app supplied; the sync must not silently null it out.
+      expect(Number.isNaN((field().value() as Date).getTime())).toBe(true);
+    });
+
     // The initial `:valid` / `:invalid` animation fires for every input type we track validity on,
     // not just `date`, so none of them may dirty their field on load. See #69632.
     //