@angular/forms 21.0.4 → 21.1.0-next.1

package/fesm2022/_structure-chunk.mjs

@@ -1,28 +1,34 @@
 /**
- * @license Angular v21.0.4
+ * @license Angular v21.1.0-next.1
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
-import { untracked, computed, runInInjectionContext, Injector, linkedSignal, signal, APP_ID, effect, inject } from '@angular/core';
+import { computed, untracked, runInInjectionContext, linkedSignal, Injector, signal, APP_ID, effect, inject } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 import { SIGNAL } from '@angular/core/primitives/signals';
 
-let boundPathDepth = 0;
-function getBoundPathDepth() {
-  return boundPathDepth;
+function isArray(value) {
+  return Array.isArray(value);
 }
-function setBoundPathDepthForResolution(fn, depth) {
-  return (...args) => {
-    try {
-      boundPathDepth = depth;
-      return fn(...args);
-    } finally {
-      boundPathDepth = 0;
-    }
-  };
+function isObject(value) {
+  return (typeof value === 'object' || typeof value === 'function') && value != null;
 }
 
+function reduceChildren(node, initialValue, fn, shortCircuit) {
+  const childrenMap = node.structure.childrenMap();
+  if (!childrenMap) {
+    return initialValue;
+  }
+  let value = initialValue;
+  for (const child of childrenMap.values()) {
+    if (shortCircuit?.(value)) {
+      break;
+    }
+    value = fn(child, value);
+  }
+  return value;
+}
 function shortCircuitFalse(value) {
   return !value;
 }
@@ -36,11 +42,131 @@ function getInjectorFromOptions(options) {
   return options.parent.structure.root.structure.injector;
 }
 
-function isArray(value) {
-  return Array.isArray(value);
+function calculateValidationSelfStatus(state) {
+  if (state.errors().length > 0) {
+    return 'invalid';
+  }
+  if (state.pending()) {
+    return 'unknown';
+  }
+  return 'valid';
 }
-function isObject(value) {
-  return (typeof value === 'object' || typeof value === 'function') && value != null;
+class FieldValidationState {
+  node;
+  constructor(node) {
+    this.node = node;
+  }
+  rawSyncTreeErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
+    }
+    return [...this.node.logicNode.logic.syncTreeErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawSyncTreeErrors() ?? [])];
+  }, ...(ngDevMode ? [{
+    debugName: "rawSyncTreeErrors"
+  }] : []));
+  syncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
+    }
+    return [...this.node.logicNode.logic.syncErrors.compute(this.node.context), ...this.syncTreeErrors(), ...normalizeErrors(this.node.submitState.serverErrors())];
+  }, ...(ngDevMode ? [{
+    debugName: "syncErrors"
+  }] : []));
+  syncValid = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return true;
+    }
+    return reduceChildren(this.node, this.syncErrors().length === 0, (child, value) => value && child.validationState.syncValid(), shortCircuitFalse);
+  }, ...(ngDevMode ? [{
+    debugName: "syncValid"
+  }] : []));
+  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.field === this.node.fieldProxy), ...(ngDevMode ? [{
+    debugName: "syncTreeErrors"
+  }] : []));
+  rawAsyncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
+    }
+    return [...this.node.logicNode.logic.asyncErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawAsyncErrors() ?? [])];
+  }, ...(ngDevMode ? [{
+    debugName: "rawAsyncErrors"
+  }] : []));
+  asyncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
+    }
+    return this.rawAsyncErrors().filter(err => err === 'pending' || err.field === this.node.fieldProxy);
+  }, ...(ngDevMode ? [{
+    debugName: "asyncErrors"
+  }] : []));
+  errors = computed(() => [...this.syncErrors(), ...this.asyncErrors().filter(err => err !== 'pending')], ...(ngDevMode ? [{
+    debugName: "errors"
+  }] : []));
+  errorSummary = computed(() => reduceChildren(this.node, this.errors(), (child, result) => [...result, ...child.errorSummary()]), ...(ngDevMode ? [{
+    debugName: "errorSummary"
+  }] : []));
+  pending = computed(() => reduceChildren(this.node, this.asyncErrors().includes('pending'), (child, value) => value || child.validationState.asyncErrors().includes('pending')), ...(ngDevMode ? [{
+    debugName: "pending"
+  }] : []));
+  status = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return 'valid';
+    }
+    let ownStatus = calculateValidationSelfStatus(this);
+    return reduceChildren(this.node, ownStatus, (child, value) => {
+      if (value === 'invalid' || child.validationState.status() === 'invalid') {
+        return 'invalid';
+      } else if (value === 'unknown' || child.validationState.status() === 'unknown') {
+        return 'unknown';
+      }
+      return 'valid';
+    }, v => v === 'invalid');
+  }, ...(ngDevMode ? [{
+    debugName: "status"
+  }] : []));
+  valid = computed(() => this.status() === 'valid', ...(ngDevMode ? [{
+    debugName: "valid"
+  }] : []));
+  invalid = computed(() => this.status() === 'invalid', ...(ngDevMode ? [{
+    debugName: "invalid"
+  }] : []));
+  shouldSkipValidation = computed(() => this.node.hidden() || this.node.disabled() || this.node.readonly(), ...(ngDevMode ? [{
+    debugName: "shouldSkipValidation"
+  }] : []));
+}
+function normalizeErrors(error) {
+  if (error === undefined) {
+    return [];
+  }
+  if (isArray(error)) {
+    return error;
+  }
+  return [error];
+}
+function addDefaultField(errors, field) {
+  if (isArray(errors)) {
+    for (const error of errors) {
+      error.field ??= field;
+    }
+  } else if (errors) {
+    errors.field ??= field;
+  }
+  return errors;
+}
+
+let boundPathDepth = 0;
+function getBoundPathDepth() {
+  return boundPathDepth;
+}
+function setBoundPathDepthForResolution(fn, depth) {
+  return (...args) => {
+    try {
+      boundPathDepth = depth;
+      return fn(...args);
+    } finally {
+      boundPathDepth = 0;
+    }
+  };
 }
 
 const DYNAMIC = Symbol();
@@ -103,10 +229,10 @@ class ArrayMergeLogic extends ArrayMergeIgnoreLogic {
     super(predicates, undefined);
   }
 }
-class MetadataMergeLogic extends AbstractLogic {
+class AggregateMetadataMergeLogic extends AbstractLogic {
   key;
   get defaultValue() {
-    return this.key.reducer.getInitial();
+    return this.key.getInitial();
   }
   constructor(predicates, key) {
     super(predicates);
@@ -114,13 +240,13 @@ class MetadataMergeLogic extends AbstractLogic {
   }
   compute(ctx) {
     if (this.fns.length === 0) {
-      return this.key.reducer.getInitial();
+      return this.key.getInitial();
     }
-    let acc = this.key.reducer.getInitial();
+    let acc = this.key.getInitial();
     for (let i = 0; i < this.fns.length; i++) {
       const item = this.fns[i](ctx);
       if (item !== IGNORED) {
-        acc = this.key.reducer.reduce(acc, item);
+        acc = this.key.reduce(acc, item);
       }
     }
     return acc;
@@ -152,7 +278,8 @@ class LogicContainer {
   syncErrors;
   syncTreeErrors;
   asyncErrors;
-  metadata = new Map();
+  aggregateMetadataKeys = new Map();
+  metadataFactories = new Map();
   constructor(predicates) {
     this.predicates = predicates;
     this.hidden = new BooleanOrLogic(predicates);
@@ -162,17 +289,26 @@ class LogicContainer {
     this.syncTreeErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
     this.asyncErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
   }
-  hasMetadata(key) {
-    return this.metadata.has(key);
+  hasAggregateMetadata(key) {
+    return this.aggregateMetadataKeys.has(key);
   }
-  getMetadataKeys() {
-    return this.metadata.keys();
+  getAggregateMetadataEntries() {
+    return this.aggregateMetadataKeys.entries();
   }
-  getMetadata(key) {
-    if (!this.metadata.has(key)) {
-      this.metadata.set(key, new MetadataMergeLogic(this.predicates, key));
+  getMetadataFactoryEntries() {
+    return this.metadataFactories.entries();
+  }
+  getAggregateMetadata(key) {
+    if (!this.aggregateMetadataKeys.has(key)) {
+      this.aggregateMetadataKeys.set(key, new AggregateMetadataMergeLogic(this.predicates, key));
     }
-    return this.metadata.get(key);
+    return this.aggregateMetadataKeys.get(key);
+  }
+  addMetadataFactory(key, factory) {
+    if (this.metadataFactories.has(key)) {
+      throw new Error(`Can't define value twice for the same MetadataKey`);
+    }
+    this.metadataFactories.set(key, factory);
   }
   mergeIn(other) {
     this.hidden.mergeIn(other.hidden);
@@ -181,9 +317,11 @@ class LogicContainer {
     this.syncErrors.mergeIn(other.syncErrors);
     this.syncTreeErrors.mergeIn(other.syncTreeErrors);
     this.asyncErrors.mergeIn(other.asyncErrors);
-    for (const key of other.getMetadataKeys()) {
-      const metadataLogic = other.metadata.get(key);
-      this.getMetadata(key).mergeIn(metadataLogic);
+    for (const [key, metadataLogic] of other.getAggregateMetadataEntries()) {
+      this.getAggregateMetadata(key).mergeIn(metadataLogic);
+    }
+    for (const [key, metadataFactory] of other.getMetadataFactoryEntries()) {
+      this.addMetadataFactory(key, metadataFactory);
     }
   }
 }
@@ -221,8 +359,11 @@ class LogicNodeBuilder extends AbstractLogicNodeBuilder {
   addAsyncErrorRule(logic) {
     this.getCurrent().addAsyncErrorRule(logic);
   }
-  addMetadataRule(key, logic) {
-    this.getCurrent().addMetadataRule(key, logic);
+  addAggregateMetadataRule(key, logic) {
+    this.getCurrent().addAggregateMetadataRule(key, logic);
+  }
+  addMetadataFactory(key, factory) {
+    this.getCurrent().addMetadataFactory(key, factory);
   }
   getChild(key) {
     if (key === DYNAMIC) {
@@ -294,8 +435,11 @@ class NonMergeableLogicNodeBuilder extends AbstractLogicNodeBuilder {
   addAsyncErrorRule(logic) {
     this.logic.asyncErrors.push(setBoundPathDepthForResolution(logic, this.depth));
   }
-  addMetadataRule(key, logic) {
-    this.logic.getMetadata(key).push(setBoundPathDepthForResolution(logic, this.depth));
+  addAggregateMetadataRule(key, logic) {
+    this.logic.getAggregateMetadata(key).push(setBoundPathDepthForResolution(logic, this.depth));
+  }
+  addMetadataFactory(key, factory) {
+    this.logic.addMetadataFactory(key, setBoundPathDepthForResolution(factory, this.depth));
   }
   getChild(key) {
     if (!this.children.has(key)) {
@@ -513,196 +657,64 @@ function assertPathIsCurrent(path) {
   }
 }
 
-function metadata(path, key, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addMetadataRule(key, logic);
-  return key;
+class MetadataKey {
+  brand;
+  constructor() {}
 }
-const MetadataReducer = {
-  list() {
-    return {
-      reduce: (acc, item) => item === undefined ? acc : [...acc, item],
-      getInitial: () => []
-    };
-  },
-  min() {
-    return {
-      reduce: (acc, item) => {
-        if (acc === undefined || item === undefined) {
-          return acc ?? item;
-        }
-        return Math.min(acc, item);
-      },
-      getInitial: () => undefined
-    };
-  },
-  max() {
-    return {
-      reduce: (prev, next) => {
-        if (prev === undefined || next === undefined) {
-          return prev ?? next;
-        }
-        return Math.max(prev, next);
-      },
-      getInitial: () => undefined
-    };
-  },
-  or() {
-    return {
-      reduce: (prev, next) => prev || next,
-      getInitial: () => false
-    };
-  },
-  and() {
-    return {
-      reduce: (prev, next) => prev && next,
-      getInitial: () => true
-    };
-  },
-  override
-};
-function override(getInitial) {
-  return {
-    reduce: (_, item) => item,
-    getInitial: () => getInitial?.()
-  };
+function createMetadataKey() {
+  return new MetadataKey();
 }
-class MetadataKey {
-  reducer;
-  create;
+class AggregateMetadataKey {
+  reduce;
+  getInitial;
   brand;
-  constructor(reducer, create) {
-    this.reducer = reducer;
-    this.create = create;
+  constructor(reduce, getInitial) {
+    this.reduce = reduce;
+    this.getInitial = getInitial;
   }
 }
-function createMetadataKey(reducer) {
-  return new MetadataKey(reducer ?? MetadataReducer.override());
+function reducedMetadataKey(reduce, getInitial) {
+  return new AggregateMetadataKey(reduce, getInitial);
 }
-function createManagedMetadataKey(create, reducer) {
-  return new MetadataKey(reducer ?? MetadataReducer.override(), create);
-}
-const REQUIRED = createMetadataKey(MetadataReducer.or());
-const MIN = createMetadataKey(MetadataReducer.max());
-const MAX = createMetadataKey(MetadataReducer.min());
-const MIN_LENGTH = createMetadataKey(MetadataReducer.max());
-const MAX_LENGTH = createMetadataKey(MetadataReducer.min());
-const PATTERN = createMetadataKey(MetadataReducer.list());
-
-function calculateValidationSelfStatus(state) {
-  if (state.errors().length > 0) {
-    return 'invalid';
-  }
-  if (state.pending()) {
-    return 'unknown';
-  }
-  return 'valid';
+function listMetadataKey() {
+  return reducedMetadataKey((acc, item) => item === undefined ? acc : [...acc, item], () => []);
 }
-class FieldValidationState {
-  node;
-  constructor(node) {
-    this.node = node;
-  }
-  rawSyncTreeErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
+function minMetadataKey() {
+  return reducedMetadataKey((prev, next) => {
+    if (prev === undefined) {
+      return next;
     }
-    return [...this.node.logicNode.logic.syncTreeErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawSyncTreeErrors() ?? [])];
-  }, ...(ngDevMode ? [{
-    debugName: "rawSyncTreeErrors"
-  }] : []));
-  syncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
-    }
-    return [...this.node.logicNode.logic.syncErrors.compute(this.node.context), ...this.syncTreeErrors(), ...normalizeErrors(this.node.submitState.serverErrors())];
-  }, ...(ngDevMode ? [{
-    debugName: "syncErrors"
-  }] : []));
-  syncValid = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return true;
-    }
-    return this.node.structure.reduceChildren(this.syncErrors().length === 0, (child, value) => value && child.validationState.syncValid(), shortCircuitFalse);
-  }, ...(ngDevMode ? [{
-    debugName: "syncValid"
-  }] : []));
-  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.field === this.node.fieldProxy), ...(ngDevMode ? [{
-    debugName: "syncTreeErrors"
-  }] : []));
-  rawAsyncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
+    if (next === undefined) {
+      return prev;
     }
-    return [...this.node.logicNode.logic.asyncErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawAsyncErrors() ?? [])];
-  }, ...(ngDevMode ? [{
-    debugName: "rawAsyncErrors"
-  }] : []));
-  asyncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
+    return Math.min(prev, next);
+  }, () => undefined);
+}
+function maxMetadataKey() {
+  return reducedMetadataKey((prev, next) => {
+    if (prev === undefined) {
+      return next;
     }
-    return this.rawAsyncErrors().filter(err => err === 'pending' || err.field === this.node.fieldProxy);
-  }, ...(ngDevMode ? [{
-    debugName: "asyncErrors"
-  }] : []));
-  errors = computed(() => [...this.syncErrors(), ...this.asyncErrors().filter(err => err !== 'pending')], ...(ngDevMode ? [{
-    debugName: "errors"
-  }] : []));
-  errorSummary = computed(() => this.node.structure.reduceChildren(this.errors(), (child, result) => [...result, ...child.errorSummary()]), ...(ngDevMode ? [{
-    debugName: "errorSummary"
-  }] : []));
-  pending = computed(() => this.node.structure.reduceChildren(this.asyncErrors().includes('pending'), (child, value) => value || child.validationState.asyncErrors().includes('pending')), ...(ngDevMode ? [{
-    debugName: "pending"
-  }] : []));
-  status = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return 'valid';
+    if (next === undefined) {
+      return prev;
     }
-    let ownStatus = calculateValidationSelfStatus(this);
-    return this.node.structure.reduceChildren(ownStatus, (child, value) => {
-      if (value === 'invalid' || child.validationState.status() === 'invalid') {
-        return 'invalid';
-      } else if (value === 'unknown' || child.validationState.status() === 'unknown') {
-        return 'unknown';
-      }
-      return 'valid';
-    }, v => v === 'invalid');
-  }, ...(ngDevMode ? [{
-    debugName: "status"
-  }] : []));
-  valid = computed(() => this.status() === 'valid', ...(ngDevMode ? [{
-    debugName: "valid"
-  }] : []));
-  invalid = computed(() => this.status() === 'invalid', ...(ngDevMode ? [{
-    debugName: "invalid"
-  }] : []));
-  shouldSkipValidation = computed(() => this.node.hidden() || this.node.disabled() || this.node.readonly(), ...(ngDevMode ? [{
-    debugName: "shouldSkipValidation"
-  }] : []));
+    return Math.max(prev, next);
+  }, () => undefined);
 }
-function normalizeErrors(error) {
-  if (error === undefined) {
-    return [];
-  }
-  if (isArray(error)) {
-    return error;
-  }
-  return [error];
+function orMetadataKey() {
+  return reducedMetadataKey((prev, next) => prev || next, () => false);
 }
-function addDefaultField(errors, field) {
-  if (isArray(errors)) {
-    for (const error of errors) {
-      error.field ??= field;
-    }
-  } else if (errors) {
-    errors.field ??= field;
-  }
-  return errors;
+function andMetadataKey() {
+  return reducedMetadataKey((prev, next) => prev && next, () => true);
 }
+const REQUIRED = orMetadataKey();
+const MIN = maxMetadataKey();
+const MAX = minMetadataKey();
+const MIN_LENGTH = maxMetadataKey();
+const MAX_LENGTH = minMetadataKey();
+const PATTERN = listMetadataKey();
 
-const DEBOUNCER = createMetadataKey();
+const DEBOUNCER = reducedMetadataKey((_, item) => item, () => undefined);
 
 class FieldNodeContext {
   node;
@@ -777,28 +789,31 @@ class FieldMetadataState {
   metadata = new Map();
   constructor(node) {
     this.node = node;
-    for (const key of this.node.logicNode.logic.getMetadataKeys()) {
-      if (key.create) {
-        const logic = this.node.logicNode.logic.getMetadata(key);
-        const result = untracked(() => runInInjectionContext(this.node.structure.injector, () => key.create(computed(() => logic.compute(this.node.context)))));
-        this.metadata.set(key, result);
+    untracked(() => runInInjectionContext(this.node.structure.injector, () => {
+      for (const [key, factory] of this.node.logicNode.logic.getMetadataFactoryEntries()) {
+        this.metadata.set(key, factory(this.node.context));
       }
-    }
+    }));
   }
   get(key) {
-    if (this.has(key)) {
-      if (!this.metadata.has(key)) {
-        if (key.create) {
-          throw Error('Managed metadata cannot be created lazily');
-        }
-        const logic = this.node.logicNode.logic.getMetadata(key);
-        this.metadata.set(key, computed(() => logic.compute(this.node.context)));
-      }
+    if (key instanceof MetadataKey) {
+      return this.metadata.get(key);
+    }
+    if (!this.metadata.has(key)) {
+      const logic = this.node.logicNode.logic.getAggregateMetadata(key);
+      const result = computed(() => logic.compute(this.node.context), ...(ngDevMode ? [{
+        debugName: "result"
+      }] : []));
+      this.metadata.set(key, result);
     }
     return this.metadata.get(key);
   }
   has(key) {
-    return this.node.logicNode.logic.hasMetadata(key);
+    if (key instanceof AggregateMetadataKey) {
+      return this.node.logicNode.logic.hasAggregateMetadata(key);
+    } else {
+      return this.metadata.has(key);
+    }
   }
 }
 
@@ -815,10 +830,7 @@ const FIELD_PROXY_HANDLER = {
         return tgt.value().length;
       }
       if (p === Symbol.iterator) {
-        return () => {
-          tgt.value();
-          return Array.prototype[Symbol.iterator].apply(tgt.fieldProxy);
-        };
+        return Array.prototype[p];
       }
     }
     if (isObject(value)) {
@@ -873,8 +885,6 @@ function valueForWrite(sourceValue, newPropValue, prop) {
 
 class FieldNodeStructure {
   logic;
-  node;
-  createChildNode;
   identitySymbol = Symbol();
   _injector = undefined;
   get injector() {
@@ -884,146 +894,32 @@ class FieldNodeStructure {
     });
     return this._injector;
   }
-  constructor(logic, node, createChildNode) {
+  constructor(logic) {
     this.logic = logic;
-    this.node = node;
-    this.createChildNode = createChildNode;
   }
   children() {
-    const map = this.childrenMap();
-    if (map === undefined) {
-      return [];
-    }
-    return Array.from(map.byPropertyKey.values()).map(child => untracked(child.reader));
+    return this.childrenMap()?.values() ?? [];
   }
   getChild(key) {
-    const strKey = key.toString();
-    let reader = untracked(this.childrenMap)?.byPropertyKey.get(strKey)?.reader;
-    if (!reader) {
-      reader = this.createReader(strKey);
-    }
-    return reader();
-  }
-  reduceChildren(initialValue, fn, shortCircuit) {
     const map = this.childrenMap();
-    if (!map) {
-      return initialValue;
+    const value = this.value();
+    if (!map || !isObject(value)) {
+      return undefined;
     }
-    let value = initialValue;
-    for (const child of map.byPropertyKey.values()) {
-      if (shortCircuit?.(value)) {
-        break;
+    if (isArray(value)) {
+      const childValue = value[key];
+      if (isObject(childValue) && childValue.hasOwnProperty(this.identitySymbol)) {
+        key = childValue[this.identitySymbol];
       }
-      value = fn(untracked(child.reader), value);
     }
-    return value;
+    return map.get(typeof key === 'number' ? key.toString() : key);
   }
   destroy() {
     this.injector.destroy();
   }
-  createKeyInParent(options, identityInParent, initialKeyInParent) {
-    if (options.kind === 'root') {
-      return ROOT_KEY_IN_PARENT;
-    }
-    if (identityInParent === undefined) {
-      const key = initialKeyInParent;
-      return computed(() => {
-        if (this.parent.structure.getChild(key) !== this.node) {
-          throw new Error(`RuntimeError: orphan field, looking for property '${key}' of ${getDebugName(this.parent)}`);
-        }
-        return key;
-      });
-    } else {
-      let lastKnownKey = initialKeyInParent;
-      return computed(() => {
-        const parentValue = this.parent.structure.value();
-        if (!isArray(parentValue)) {
-          throw new Error(`RuntimeError: orphan field, expected ${getDebugName(this.parent)} to be an array`);
-        }
-        const data = parentValue[lastKnownKey];
-        if (isObject(data) && data.hasOwnProperty(this.parent.structure.identitySymbol) && data[this.parent.structure.identitySymbol] === identityInParent) {
-          return lastKnownKey;
-        }
-        for (let i = 0; i < parentValue.length; i++) {
-          const data = parentValue[i];
-          if (isObject(data) && data.hasOwnProperty(this.parent.structure.identitySymbol) && data[this.parent.structure.identitySymbol] === identityInParent) {
-            return lastKnownKey = i.toString();
-          }
-        }
-        throw new Error(`RuntimeError: orphan field, can't find element in array ${getDebugName(this.parent)}`);
-      });
-    }
-  }
-  createChildrenMap() {
-    return linkedSignal({
-      source: this.value,
-      computation: (value, previous) => {
-        if (!isObject(value)) {
-          return undefined;
-        }
-        const prevData = previous?.value ?? {
-          byPropertyKey: new Map()
-        };
-        let data;
-        const parentIsArray = isArray(value);
-        if (prevData !== undefined) {
-          if (parentIsArray) {
-            data = maybeRemoveStaleArrayFields(prevData, value, this.identitySymbol);
-          } else {
-            data = maybeRemoveStaleObjectFields(prevData, value);
-          }
-        }
-        for (const key of Object.keys(value)) {
-          let trackingKey = undefined;
-          const childValue = value[key];
-          if (childValue === undefined) {
-            if (prevData.byPropertyKey.has(key)) {
-              data ??= {
-                ...prevData
-              };
-              data.byPropertyKey.delete(key);
-            }
-            continue;
-          }
-          if (parentIsArray && isObject(childValue) && !isArray(childValue)) {
-            trackingKey = childValue[this.identitySymbol] ??= Symbol(ngDevMode ? `id:${globalId++}` : '');
-          }
-          let childNode;
-          if (trackingKey) {
-            if (!prevData.byTrackingKey?.has(trackingKey)) {
-              data ??= {
-                ...prevData
-              };
-              data.byTrackingKey ??= new Map();
-              data.byTrackingKey.set(trackingKey, this.createChildNode(key, trackingKey, parentIsArray));
-            }
-            childNode = (data ?? prevData).byTrackingKey.get(trackingKey);
-          }
-          const child = prevData.byPropertyKey.get(key);
-          if (child === undefined) {
-            data ??= {
-              ...prevData
-            };
-            data.byPropertyKey.set(key, {
-              reader: this.createReader(key),
-              node: childNode ?? this.createChildNode(key, trackingKey, parentIsArray)
-            });
-          } else if (childNode && childNode !== child.node) {
-            data ??= {
-              ...prevData
-            };
-            child.node = childNode;
-          }
-        }
-        return data ?? prevData;
-      }
-    });
-  }
-  createReader(key) {
-    return computed(() => this.childrenMap()?.byPropertyKey.get(key)?.node);
-  }
 }
 class RootFieldNodeStructure extends FieldNodeStructure {
+  node;
   fieldManager;
   value;
   get parent() {
@@ -1039,15 +935,15 @@ class RootFieldNodeStructure extends FieldNodeStructure {
     return ROOT_KEY_IN_PARENT;
   }
   childrenMap;
-  constructor(node, logic, fieldManager, value, createChildNode) {
-    super(logic, node, createChildNode);
+  constructor(node, pathNode, logic, fieldManager, value, adapter, createChildNode) {
+    super(logic);
+    this.node = node;
     this.fieldManager = fieldManager;
     this.value = value;
-    this.childrenMap = this.createChildrenMap();
+    this.childrenMap = makeChildrenMapSignal(node, value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
   }
 }
 class ChildFieldNodeStructure extends FieldNodeStructure {
-  logic;
   parent;
   root;
   pathKeys;
@@ -1057,25 +953,47 @@ class ChildFieldNodeStructure extends FieldNodeStructure {
   get fieldManager() {
     return this.root.structure.fieldManager;
   }
-  constructor(node, logic, parent, identityInParent, initialKeyInParent, createChildNode) {
-    super(logic, node, createChildNode);
-    this.logic = logic;
+  constructor(node, pathNode, logic, parent, identityInParent, initialKeyInParent, adapter, createChildNode) {
+    super(logic);
     this.parent = parent;
     this.root = this.parent.structure.root;
-    this.keyInParent = this.createKeyInParent({
-      kind: 'child',
-      parent,
-      pathNode: undefined,
-      logic,
-      initialKeyInParent,
-      identityInParent,
-      fieldAdapter: undefined
-    }, identityInParent, initialKeyInParent);
     this.pathKeys = computed(() => [...parent.structure.pathKeys(), this.keyInParent()], ...(ngDevMode ? [{
       debugName: "pathKeys"
     }] : []));
+    if (identityInParent === undefined) {
+      const key = initialKeyInParent;
+      this.keyInParent = computed(() => {
+        if (parent.structure.childrenMap()?.get(key) !== node) {
+          throw new Error(`RuntimeError: orphan field, looking for property '${key}' of ${getDebugName(parent)}`);
+        }
+        return key;
+      }, ...(ngDevMode ? [{
+        debugName: "keyInParent"
+      }] : []));
+    } else {
+      let lastKnownKey = initialKeyInParent;
+      this.keyInParent = computed(() => {
+        const parentValue = parent.structure.value();
+        if (!isArray(parentValue)) {
+          throw new Error(`RuntimeError: orphan field, expected ${getDebugName(parent)} to be an array`);
+        }
+        const data = parentValue[lastKnownKey];
+        if (isObject(data) && data.hasOwnProperty(parent.structure.identitySymbol) && data[parent.structure.identitySymbol] === identityInParent) {
+          return lastKnownKey;
+        }
+        for (let i = 0; i < parentValue.length; i++) {
+          const data = parentValue[i];
+          if (isObject(data) && data.hasOwnProperty(parent.structure.identitySymbol) && data[parent.structure.identitySymbol] === identityInParent) {
+            return lastKnownKey = i.toString();
+          }
+        }
+        throw new Error(`RuntimeError: orphan field, can't find element in array ${getDebugName(parent)}`);
+      }, ...(ngDevMode ? [{
+        debugName: "keyInParent"
+      }] : []));
+    }
     this.value = deepSignal(this.parent.structure.value, this.keyInParent);
-    this.childrenMap = this.createChildrenMap();
+    this.childrenMap = makeChildrenMapSignal(node, this.value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
     this.fieldManager.structures.add(this);
   }
 }
@@ -1088,50 +1006,80 @@ const ROOT_KEY_IN_PARENT = computed(() => {
 }, ...(ngDevMode ? [{
   debugName: "ROOT_KEY_IN_PARENT"
 }] : []));
+function makeChildrenMapSignal(node, valueSignal, identitySymbol, pathNode, logic, adapter, createChildNode) {
+  return linkedSignal({
+    source: valueSignal,
+    computation: (value, previous) => {
+      let childrenMap = previous?.value;
+      if (!isObject(value)) {
+        return undefined;
+      }
+      const isValueArray = isArray(value);
+      if (childrenMap !== undefined) {
+        let oldKeys = undefined;
+        if (isValueArray) {
+          oldKeys = new Set(childrenMap.keys());
+          for (let i = 0; i < value.length; i++) {
+            const childValue = value[i];
+            if (isObject(childValue) && childValue.hasOwnProperty(identitySymbol)) {
+              oldKeys.delete(childValue[identitySymbol]);
+            } else {
+              oldKeys.delete(i.toString());
+            }
+          }
+          for (const key of oldKeys) {
+            childrenMap.delete(key);
+          }
+        } else {
+          for (let key of childrenMap.keys()) {
+            if (!value.hasOwnProperty(key)) {
+              childrenMap.delete(key);
+            }
+          }
+        }
+      }
+      for (let key of Object.keys(value)) {
+        let trackingId = undefined;
+        const childValue = value[key];
+        if (childValue === undefined) {
+          childrenMap?.delete(key);
+          continue;
+        }
+        if (isValueArray && isObject(childValue) && !isArray(childValue)) {
+          trackingId = childValue[identitySymbol] ??= Symbol(ngDevMode ? `id:${globalId++}` : '');
+        }
+        const identity = trackingId ?? key;
+        if (childrenMap?.has(identity)) {
+          continue;
+        }
+        let childPath;
+        let childLogic;
+        if (isValueArray) {
+          childPath = pathNode.getChild(DYNAMIC);
+          childLogic = logic.getChild(DYNAMIC);
+        } else {
+          childPath = pathNode.getChild(key);
+          childLogic = logic.getChild(key);
+        }
+        childrenMap ??= new Map();
+        childrenMap.set(identity, createChildNode({
+          kind: 'child',
+          parent: node,
+          pathNode: childPath,
+          logic: childLogic,
+          initialKeyInParent: key,
+          identityInParent: trackingId,
+          fieldAdapter: adapter
+        }));
+      }
+      return childrenMap;
+    },
+    equal: () => false
+  });
+}
 function getDebugName(node) {
   return `<root>.${node.structure.pathKeys().join('.')}`;
 }
-function maybeRemoveStaleArrayFields(prevData, value, identitySymbol) {
-  let data;
-  const oldKeys = new Set(prevData.byPropertyKey.keys());
-  const oldTracking = new Set(prevData.byTrackingKey?.keys());
-  for (let i = 0; i < value.length; i++) {
-    const childValue = value[i];
-    oldKeys.delete(i.toString());
-    if (isObject(childValue) && childValue.hasOwnProperty(identitySymbol)) {
-      oldTracking.delete(childValue[identitySymbol]);
-    }
-  }
-  if (oldKeys.size > 0) {
-    data ??= {
-      ...prevData
-    };
-    for (const key of oldKeys) {
-      data.byPropertyKey.delete(key);
-    }
-  }
-  if (oldTracking.size > 0) {
-    data ??= {
-      ...prevData
-    };
-    for (const id of oldTracking) {
-      data.byTrackingKey?.delete(id);
-    }
-  }
-  return data;
-}
-function maybeRemoveStaleObjectFields(prevData, value) {
-  let data;
-  for (const key of prevData.byPropertyKey.keys()) {
-    if (!value.hasOwnProperty(key)) {
-      data ??= {
-        ...prevData
-      };
-      data.byPropertyKey.delete(key);
-    }
-  }
-  return data;
-}
 
 class FieldSubmitState {
   node;
@@ -1168,9 +1116,7 @@ class FieldNode {
     return this._context ??= new FieldNodeContext(this);
   }
   fieldProxy = new Proxy(() => this, FIELD_PROXY_HANDLER);
-  pathNode;
   constructor(options) {
-    this.pathNode = options.pathNode;
     this.fieldAdapter = options.fieldAdapter;
     this.structure = this.fieldAdapter.createStructure(this, options);
     this.validationState = this.fieldAdapter.createValidationState(this, options);
@@ -1245,23 +1191,26 @@ class FieldNode {
   get name() {
     return this.nodeState.name;
   }
+  metadataOrUndefined(key) {
+    return this.hasMetadata(key) ? this.metadata(key) : undefined;
+  }
   get max() {
-    return this.metadata(MAX);
+    return this.metadataOrUndefined(MAX);
   }
   get maxLength() {
-    return this.metadata(MAX_LENGTH);
+    return this.metadataOrUndefined(MAX_LENGTH);
   }
   get min() {
-    return this.metadata(MIN);
+    return this.metadataOrUndefined(MIN);
   }
   get minLength() {
-    return this.metadata(MIN_LENGTH);
+    return this.metadataOrUndefined(MIN_LENGTH);
   }
   get pattern() {
-    return this.metadata(PATTERN) ?? EMPTY;
+    return this.metadataOrUndefined(PATTERN) ?? EMPTY;
   }
   get required() {
-    return this.metadata(REQUIRED) ?? FALSE;
+    return this.metadataOrUndefined(REQUIRED) ?? FALSE;
   }
   metadata(key) {
     return this.metadataState.get(key);
@@ -1281,7 +1230,7 @@ class FieldNode {
     untracked(() => this._reset(value));
   }
   _reset(value) {
-    if (value !== undefined) {
+    if (value) {
       this.value.set(value);
     }
     this.nodeState.markAsUntouched();
@@ -1317,28 +1266,11 @@ class FieldNode {
   static newRoot(fieldManager, value, pathNode, adapter) {
     return adapter.newRoot(fieldManager, value, pathNode, adapter);
   }
+  static newChild(options) {
+    return options.fieldAdapter.newChild(options);
+  }
   createStructure(options) {
-    return options.kind === 'root' ? new RootFieldNodeStructure(this, options.logic, options.fieldManager, options.value, this.newChild.bind(this)) : new ChildFieldNodeStructure(this, options.logic, options.parent, options.identityInParent, options.initialKeyInParent, this.newChild.bind(this));
-  }
-  newChild(key, trackingId, isArray) {
-    let childPath;
-    let childLogic;
-    if (isArray) {
-      childPath = this.pathNode.getChild(DYNAMIC);
-      childLogic = this.structure.logic.getChild(DYNAMIC);
-    } else {
-      childPath = this.pathNode.getChild(key);
-      childLogic = this.structure.logic.getChild(key);
-    }
-    return this.fieldAdapter.newChild({
-      kind: 'child',
-      parent: this,
-      pathNode: childPath,
-      logic: childLogic,
-      initialKeyInParent: key,
-      identityInParent: trackingId,
-      fieldAdapter: this.fieldAdapter
-    });
+    return options.kind === 'root' ? new RootFieldNodeStructure(this, options.pathNode, options.logic, options.fieldManager, options.value, options.fieldAdapter, FieldNode.newChild) : new ChildFieldNodeStructure(this, options.pathNode, options.logic, options.parent, options.identityInParent, options.initialKeyInParent, options.fieldAdapter, FieldNode.newChild);
   }
 }
 const EMPTY = computed(() => [], ...(ngDevMode ? [{
@@ -1376,13 +1308,13 @@ class FieldNodeState {
   }
   dirty = computed(() => {
     const selfDirtyValue = this.selfDirty() && !this.isNonInteractive();
-    return this.node.structure.reduceChildren(selfDirtyValue, (child, value) => value || child.nodeState.dirty(), shortCircuitTrue);
+    return reduceChildren(this.node, selfDirtyValue, (child, value) => value || child.nodeState.dirty(), shortCircuitTrue);
   }, ...(ngDevMode ? [{
     debugName: "dirty"
   }] : []));
   touched = computed(() => {
     const selfTouchedValue = this.selfTouched() && !this.isNonInteractive();
-    return this.node.structure.reduceChildren(selfTouchedValue, (child, value) => value || child.nodeState.touched(), shortCircuitTrue);
+    return reduceChildren(this.node, selfTouchedValue, (child, value) => value || child.nodeState.touched(), shortCircuitTrue);
   }, ...(ngDevMode ? [{
     debugName: "touched"
   }] : []));
@@ -1408,8 +1340,8 @@ class FieldNodeState {
     debugName: "name"
   }] : []));
   debouncer = computed(() => {
-    if (this.node.logicNode.logic.hasMetadata(DEBOUNCER)) {
-      const debouncerLogic = this.node.logicNode.logic.getMetadata(DEBOUNCER);
+    if (this.node.logicNode.logic.hasAggregateMetadata(DEBOUNCER)) {
+      const debouncerLogic = this.node.logicNode.logic.getAggregateMetadata(DEBOUNCER);
       const debouncer = debouncerLogic.compute(this.node.context);
       if (debouncer) {
         return signal => debouncer(this.node.context, signal);
@@ -1574,5 +1506,5 @@ function markAllAsTouched(node) {
   }
 }
 
-export { BasicFieldAdapter, DEBOUNCER, FieldNode, FieldNodeState, FieldNodeStructure, FieldPathNode, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MetadataKey, MetadataReducer, PATTERN, REQUIRED, addDefaultField, apply, applyEach, applyWhen, applyWhenValue, assertPathIsCurrent, calculateValidationSelfStatus, createManagedMetadataKey, createMetadataKey, form, getInjectorFromOptions, isArray, metadata, normalizeFormArgs, schema, submit };
+export { AggregateMetadataKey, BasicFieldAdapter, DEBOUNCER, FieldNode, FieldNodeState, FieldNodeStructure, FieldPathNode, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MetadataKey, PATTERN, REQUIRED, addDefaultField, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, assertPathIsCurrent, calculateValidationSelfStatus, createMetadataKey, form, getInjectorFromOptions, isArray, listMetadataKey, maxMetadataKey, minMetadataKey, normalizeFormArgs, orMetadataKey, reducedMetadataKey, schema, submit };
 //# sourceMappingURL=_structure-chunk.mjs.map