@@ -335,9 +335,13 @@ export class FormField<T> {
           this as FormField<unknown>,
         ]);
         onCleanup(() => {
-          fieldNode.nodeState.formFieldBindings.update((controls) =>
-            controls.filter((c) => c !== this),
-          );
+          const remaining = fieldNode.nodeState.formFieldBindings().filter((c) => c !== this);
+          fieldNode.nodeState.formFieldBindings.set(remaining);
+          // Once the last control is gone, nothing can blur anymore, so write any value still
+          // waiting for a blur debounce (e.g. `debounce(path, 'blur')`).
+          if (remaining.length === 0 && !fieldNode.structure.isOrphaned()) {
+            fieldNode.flushSync();
+          }
         });
       },
       {injector: this.injector},
 
@@ -117,8 +117,7 @@ export class FieldNode implements FieldState<unknown> {
    * first focusable binding in the DOM for any descendant node of this one.
    */
   private getBindingForFocus():
-    | (FormField<unknown> & {focus: (options?: FocusOptions) => void})
-    | undefined {
+    (FormField<unknown> & {focus: (options?: FocusOptions) => void}) | undefined {
     // First try to focus one of our own bindings.
     const own = this.formFieldBindings()
       .filter(
@@ -411,7 +410,7 @@ export class FieldNode implements FieldState<unknown> {
   /**
    * If there is a pending sync, abort it and sync immediately.
    */
-  private flushSync() {
+  flushSync() {
     const pending = this.pendingSync();
     if (pending && !pending.signal.aborted) {
       pending.abort();
 
@@ -42,6 +42,7 @@ function isFirefox() {
 
 import {NG_STATUS_CLASSES} from '../../compat/public_api';
 import {
+  applyEach,
   debounce,
   disabled,
   form,
@@ -6146,6 +6147,126 @@ describe('field directive', () => {
       expect(input.value).toBe('initial');
       expect(cmp.f().value()).toEqual({child: 'initial'});
     });
+
+    it('should write a value pending a blur debounce when the control is destroyed', () => {
+      @Component({
+        imports: [FormField],
+        template: `
+          @if (show()) {
+            <input [formField]="f" />
+          }
+        `,
+      })
+      class TestCmp {
+        readonly show = signal(true);
+        readonly f = form(signal('initial'), (p) => {
+          debounce(p, 'blur');
+        });
+      }
+
+      const fixture = act(() => TestBed.createComponent(TestCmp));
+      const input = fixture.nativeElement.querySelector('input');
+      const cmp = fixture.componentInstance;
+
+      act(() => {
+        input.value = 'typing';
+        input.dispatchEvent(new Event('input'));
+      });
+      expect(cmp.f().value()).toBe('initial');
+
+      act(() => cmp.show.set(false));
+      expect(cmp.f().value()).toBe('typing');
+      expect(cmp.f().touched()).toBe(false);
+    });
+
+    it('should write a value pending a blur debounce when the control is bound to another field', () => {
+      @Component({
+        imports: [FormField],
+        template: `<input [formField]="useFirst() ? f.first : f.second" />`,
+      })
+      class TestCmp {
+        readonly useFirst = signal(true);
+        readonly f = form(signal({first: '', second: ''}), (p) => {
+          debounce(p.first, 'blur');
+        });
+      }
+
+      const fixture = act(() => TestBed.createComponent(TestCmp));
+      const input = fixture.nativeElement.querySelector('input');
+      const cmp = fixture.componentInstance;
+
+      act(() => {
+        input.value = 'typing';
+        input.dispatchEvent(new Event('input'));
+      });
+      expect(cmp.f().value()).toEqual({first: '', second: ''});
+
+      act(() => cmp.useFirst.set(false));
+      expect(cmp.f().value()).toEqual({first: 'typing', second: ''});
+    });
+
+    it('should not write a value pending a blur debounce when its field is removed', () => {
+      @Component({
+        imports: [FormField],
+        template: `
+          @for (item of f; track $index) {
+            <input [formField]="item" />
+          }
+        `,
+      })
+      class TestCmp {
+        readonly model = signal(['a', 'b']);
+        readonly f = form(this.model, (p) => {
+          applyEach(p, (item) => debounce(item, 'blur'));
+        });
+      }
+
+      const fixture = act(() => TestBed.createComponent(TestCmp));
+      const input = fixture.nativeElement.querySelectorAll('input')[1];
+      const cmp = fixture.componentInstance;
+
+      act(() => {
+        input.value = 'typing';
+        input.dispatchEvent(new Event('input'));
+      });
+
+      act(() => cmp.model.set(['a']));
+      expect(cmp.model()).toEqual(['a']);
+    });
+
+    it('should not write a value pending a blur debounce while another control is still bound', () => {
+      @Component({
+        imports: [FormField],
+        template: `
+          @if (show()) {
+            <input id="first" [formField]="f" />
+          }
+          <input id="second" [formField]="f" />
+        `,
+      })
+      class TestCmp {
+        readonly show = signal(true);
+        readonly f = form(signal('initial'), (p) => {
+          debounce(p, 'blur');
+        });
+      }
+
+      const fixture = act(() => TestBed.createComponent(TestCmp));
+      const second = fixture.nativeElement.querySelector('input#second');
+      const cmp = fixture.componentInstance;
+
+      act(() => {
+        second.value = 'typing';
+        second.dispatchEvent(new Event('input'));
+      });
+      expect(cmp.f().value()).toBe('initial');
+
+      act(() => cmp.show.set(false));
+      expect(cmp.f().value()).toBe('initial');
+
+      act(() => second.dispatchEvent(new Event('blur')));
+      expect(cmp.f().value()).toBe('typing');
+    });
   });
 
   describe('config', () => {