@angular/forms 21.0.0-rc.2 → 21.0.0

package/fesm2022/signals.mjs

@@ -1,714 +1,16 @@
 /**
- * @license Angular v21.0.0-rc.2
+ * @license Angular v21.0.0
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import { httpResource } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { computed, untracked, InjectionToken, inject, Injector, input, ɵCONTROL as _CONTROL, effect, Directive, runInInjectionContext, linkedSignal, signal, APP_ID, ɵisPromise as _isPromise, resource } from '@angular/core';
-import { Validators, NG_VALUE_ACCESSOR, NgControl, AbstractControl } from '@angular/forms';
-import { SIGNAL } from '@angular/core/primitives/signals';
-
-function isArray(value) {
-  return Array.isArray(value);
-}
-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;
-}
-function shortCircuitTrue(value) {
-  return value;
-}
-
-function calculateValidationSelfStatus(state) {
-  if (state.errors().length > 0) {
-    return 'invalid';
-  }
-  if (state.pending()) {
-    return 'unknown';
-  }
-  return 'valid';
-}
-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();
-const IGNORED = Symbol();
-class AbstractLogic {
-  predicates;
-  fns = [];
-  constructor(predicates) {
-    this.predicates = predicates;
-  }
-  push(logicFn) {
-    this.fns.push(wrapWithPredicates(this.predicates, logicFn));
-  }
-  mergeIn(other) {
-    const fns = this.predicates ? other.fns.map(fn => wrapWithPredicates(this.predicates, fn)) : other.fns;
-    this.fns.push(...fns);
-  }
-}
-class BooleanOrLogic extends AbstractLogic {
-  get defaultValue() {
-    return false;
-  }
-  compute(arg) {
-    return this.fns.some(f => {
-      const result = f(arg);
-      return result && result !== IGNORED;
-    });
-  }
-}
-class ArrayMergeIgnoreLogic extends AbstractLogic {
-  ignore;
-  static ignoreNull(predicates) {
-    return new ArrayMergeIgnoreLogic(predicates, e => e === null);
-  }
-  constructor(predicates, ignore) {
-    super(predicates);
-    this.ignore = ignore;
-  }
-  get defaultValue() {
-    return [];
-  }
-  compute(arg) {
-    return this.fns.reduce((prev, f) => {
-      const value = f(arg);
-      if (value === undefined || value === IGNORED) {
-        return prev;
-      } else if (isArray(value)) {
-        return [...prev, ...(this.ignore ? value.filter(e => !this.ignore(e)) : value)];
-      } else {
-        if (this.ignore && this.ignore(value)) {
-          return prev;
-        }
-        return [...prev, value];
-      }
-    }, []);
-  }
-}
-class ArrayMergeLogic extends ArrayMergeIgnoreLogic {
-  constructor(predicates) {
-    super(predicates, undefined);
-  }
-}
-class AggregateMetadataMergeLogic extends AbstractLogic {
-  key;
-  get defaultValue() {
-    return this.key.getInitial();
-  }
-  constructor(predicates, key) {
-    super(predicates);
-    this.key = key;
-  }
-  compute(ctx) {
-    if (this.fns.length === 0) {
-      return this.key.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.reduce(acc, item);
-      }
-    }
-    return acc;
-  }
-}
-function wrapWithPredicates(predicates, logicFn) {
-  if (predicates.length === 0) {
-    return logicFn;
-  }
-  return arg => {
-    for (const predicate of predicates) {
-      let predicateField = arg.stateOf(predicate.path);
-      const depthDiff = untracked(predicateField.structure.pathKeys).length - predicate.depth;
-      for (let i = 0; i < depthDiff; i++) {
-        predicateField = predicateField.structure.parent;
-      }
-      if (!predicate.fn(predicateField.context)) {
-        return IGNORED;
-      }
-    }
-    return logicFn(arg);
-  };
-}
-class LogicContainer {
-  predicates;
-  hidden;
-  disabledReasons;
-  readonly;
-  syncErrors;
-  syncTreeErrors;
-  asyncErrors;
-  aggregateMetadataKeys = new Map();
-  metadataFactories = new Map();
-  constructor(predicates) {
-    this.predicates = predicates;
-    this.hidden = new BooleanOrLogic(predicates);
-    this.disabledReasons = new ArrayMergeLogic(predicates);
-    this.readonly = new BooleanOrLogic(predicates);
-    this.syncErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
-    this.syncTreeErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
-    this.asyncErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
-  }
-  hasAggregateMetadata(key) {
-    return this.aggregateMetadataKeys.has(key);
-  }
-  getAggregateMetadataEntries() {
-    return this.aggregateMetadataKeys.entries();
-  }
-  getMetadataFactoryEntries() {
-    return this.metadataFactories.entries();
-  }
-  getAggregateMetadata(key) {
-    if (!this.aggregateMetadataKeys.has(key)) {
-      this.aggregateMetadataKeys.set(key, new AggregateMetadataMergeLogic(this.predicates, 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);
-    this.disabledReasons.mergeIn(other.disabledReasons);
-    this.readonly.mergeIn(other.readonly);
-    this.syncErrors.mergeIn(other.syncErrors);
-    this.syncTreeErrors.mergeIn(other.syncTreeErrors);
-    this.asyncErrors.mergeIn(other.asyncErrors);
-    for (const [key, metadataLogic] of other.getAggregateMetadataEntries()) {
-      this.getAggregateMetadata(key).mergeIn(metadataLogic);
-    }
-    for (const [key, metadataFactory] of other.getMetadataFactoryEntries()) {
-      this.addMetadataFactory(key, metadataFactory);
-    }
-  }
-}
-
-class AbstractLogicNodeBuilder {
-  depth;
-  constructor(depth) {
-    this.depth = depth;
-  }
-  build() {
-    return new LeafLogicNode(this, [], 0);
-  }
-}
-class LogicNodeBuilder extends AbstractLogicNodeBuilder {
-  constructor(depth) {
-    super(depth);
-  }
-  current;
-  all = [];
-  addHiddenRule(logic) {
-    this.getCurrent().addHiddenRule(logic);
-  }
-  addDisabledReasonRule(logic) {
-    this.getCurrent().addDisabledReasonRule(logic);
-  }
-  addReadonlyRule(logic) {
-    this.getCurrent().addReadonlyRule(logic);
-  }
-  addSyncErrorRule(logic) {
-    this.getCurrent().addSyncErrorRule(logic);
-  }
-  addSyncTreeErrorRule(logic) {
-    this.getCurrent().addSyncTreeErrorRule(logic);
-  }
-  addAsyncErrorRule(logic) {
-    this.getCurrent().addAsyncErrorRule(logic);
-  }
-  addAggregateMetadataRule(key, logic) {
-    this.getCurrent().addAggregateMetadataRule(key, logic);
-  }
-  addMetadataFactory(key, factory) {
-    this.getCurrent().addMetadataFactory(key, factory);
-  }
-  getChild(key) {
-    if (key === DYNAMIC) {
-      const children = this.getCurrent().children;
-      if (children.size > (children.has(DYNAMIC) ? 1 : 0)) {
-        this.current = undefined;
-      }
-    }
-    return this.getCurrent().getChild(key);
-  }
-  hasLogic(builder) {
-    if (this === builder) {
-      return true;
-    }
-    return this.all.some(({
-      builder: subBuilder
-    }) => subBuilder.hasLogic(builder));
-  }
-  mergeIn(other, predicate) {
-    if (predicate) {
-      this.all.push({
-        builder: other,
-        predicate: {
-          fn: setBoundPathDepthForResolution(predicate.fn, this.depth),
-          path: predicate.path
-        }
-      });
-    } else {
-      this.all.push({
-        builder: other
-      });
-    }
-    this.current = undefined;
-  }
-  getCurrent() {
-    if (this.current === undefined) {
-      this.current = new NonMergeableLogicNodeBuilder(this.depth);
-      this.all.push({
-        builder: this.current
-      });
-    }
-    return this.current;
-  }
-  static newRoot() {
-    return new LogicNodeBuilder(0);
-  }
-}
-class NonMergeableLogicNodeBuilder extends AbstractLogicNodeBuilder {
-  logic = new LogicContainer([]);
-  children = new Map();
-  constructor(depth) {
-    super(depth);
-  }
-  addHiddenRule(logic) {
-    this.logic.hidden.push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addDisabledReasonRule(logic) {
-    this.logic.disabledReasons.push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addReadonlyRule(logic) {
-    this.logic.readonly.push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addSyncErrorRule(logic) {
-    this.logic.syncErrors.push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addSyncTreeErrorRule(logic) {
-    this.logic.syncTreeErrors.push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addAsyncErrorRule(logic) {
-    this.logic.asyncErrors.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)) {
-      this.children.set(key, new LogicNodeBuilder(this.depth + 1));
-    }
-    return this.children.get(key);
-  }
-  hasLogic(builder) {
-    return this === builder;
-  }
-}
-class LeafLogicNode {
-  builder;
-  predicates;
-  depth;
-  logic;
-  constructor(builder, predicates, depth) {
-    this.builder = builder;
-    this.predicates = predicates;
-    this.depth = depth;
-    this.logic = builder ? createLogic(builder, predicates, depth) : new LogicContainer([]);
-  }
-  getChild(key) {
-    const childBuilders = this.builder ? getAllChildBuilders(this.builder, key) : [];
-    if (childBuilders.length === 0) {
-      return new LeafLogicNode(undefined, [], this.depth + 1);
-    } else if (childBuilders.length === 1) {
-      const {
-        builder,
-        predicates
-      } = childBuilders[0];
-      return new LeafLogicNode(builder, [...this.predicates, ...predicates.map(p => bindLevel(p, this.depth))], this.depth + 1);
-    } else {
-      const builtNodes = childBuilders.map(({
-        builder,
-        predicates
-      }) => new LeafLogicNode(builder, [...this.predicates, ...predicates.map(p => bindLevel(p, this.depth))], this.depth + 1));
-      return new CompositeLogicNode(builtNodes);
-    }
-  }
-  hasLogic(builder) {
-    return this.builder?.hasLogic(builder) ?? false;
-  }
-}
-class CompositeLogicNode {
-  all;
-  logic;
-  constructor(all) {
-    this.all = all;
-    this.logic = new LogicContainer([]);
-    for (const node of all) {
-      this.logic.mergeIn(node.logic);
-    }
-  }
-  getChild(key) {
-    return new CompositeLogicNode(this.all.flatMap(child => child.getChild(key)));
-  }
-  hasLogic(builder) {
-    return this.all.some(node => node.hasLogic(builder));
-  }
-}
-function getAllChildBuilders(builder, key) {
-  if (builder instanceof LogicNodeBuilder) {
-    return builder.all.flatMap(({
-      builder,
-      predicate
-    }) => {
-      const children = getAllChildBuilders(builder, key);
-      if (predicate) {
-        return children.map(({
-          builder,
-          predicates
-        }) => ({
-          builder,
-          predicates: [...predicates, predicate]
-        }));
-      }
-      return children;
-    });
-  } else if (builder instanceof NonMergeableLogicNodeBuilder) {
-    return [...(key !== DYNAMIC && builder.children.has(DYNAMIC) ? [{
-      builder: builder.getChild(DYNAMIC),
-      predicates: []
-    }] : []), ...(builder.children.has(key) ? [{
-      builder: builder.getChild(key),
-      predicates: []
-    }] : [])];
-  } else {
-    throw new Error('Unknown LogicNodeBuilder type');
-  }
-}
-function createLogic(builder, predicates, depth) {
-  const logic = new LogicContainer(predicates);
-  if (builder instanceof LogicNodeBuilder) {
-    const builtNodes = builder.all.map(({
-      builder,
-      predicate
-    }) => new LeafLogicNode(builder, predicate ? [...predicates, bindLevel(predicate, depth)] : predicates, depth));
-    for (const node of builtNodes) {
-      logic.mergeIn(node.logic);
-    }
-  } else if (builder instanceof NonMergeableLogicNodeBuilder) {
-    logic.mergeIn(builder.logic);
-  } else {
-    throw new Error('Unknown LogicNodeBuilder type');
-  }
-  return logic;
-}
-function bindLevel(predicate, depth) {
-  return {
-    ...predicate,
-    depth: depth
-  };
-}
-
-const PATH = Symbol('PATH');
-class FieldPathNode {
-  keys;
-  parent;
-  keyInParent;
-  root;
-  children = new Map();
-  fieldPathProxy = new Proxy(this, FIELD_PATH_PROXY_HANDLER);
-  logicBuilder;
-  constructor(keys, root, parent, keyInParent) {
-    this.keys = keys;
-    this.parent = parent;
-    this.keyInParent = keyInParent;
-    this.root = root ?? this;
-    if (!parent) {
-      this.logicBuilder = LogicNodeBuilder.newRoot();
-    }
-  }
-  get builder() {
-    if (this.logicBuilder) {
-      return this.logicBuilder;
-    }
-    return this.parent.builder.getChild(this.keyInParent);
-  }
-  getChild(key) {
-    if (!this.children.has(key)) {
-      this.children.set(key, new FieldPathNode([...this.keys, key], this.root, this, key));
-    }
-    return this.children.get(key);
-  }
-  mergeIn(other, predicate) {
-    const path = other.compile();
-    this.builder.mergeIn(path.builder, predicate);
-  }
-  static unwrapFieldPath(formPath) {
-    return formPath[PATH];
-  }
-  static newRoot() {
-    return new FieldPathNode([], undefined, undefined, undefined);
-  }
-}
-const FIELD_PATH_PROXY_HANDLER = {
-  get(node, property) {
-    if (property === PATH) {
-      return node;
-    }
-    return node.getChild(property).fieldPathProxy;
-  }
-};
-
-let currentCompilingNode = undefined;
-const compiledSchemas = new Map();
-class SchemaImpl {
-  schemaFn;
-  constructor(schemaFn) {
-    this.schemaFn = schemaFn;
-  }
-  compile() {
-    if (compiledSchemas.has(this)) {
-      return compiledSchemas.get(this);
-    }
-    const path = FieldPathNode.newRoot();
-    compiledSchemas.set(this, path);
-    let prevCompilingNode = currentCompilingNode;
-    try {
-      currentCompilingNode = path;
-      this.schemaFn(path.fieldPathProxy);
-    } finally {
-      currentCompilingNode = prevCompilingNode;
-    }
-    return path;
-  }
-  static create(schema) {
-    if (schema instanceof SchemaImpl) {
-      return schema;
-    }
-    return new SchemaImpl(schema);
-  }
-  static rootCompile(schema) {
-    try {
-      compiledSchemas.clear();
-      if (schema === undefined) {
-        return FieldPathNode.newRoot();
-      }
-      if (schema instanceof SchemaImpl) {
-        return schema.compile();
-      }
-      return new SchemaImpl(schema).compile();
-    } finally {
-      compiledSchemas.clear();
-    }
-  }
-}
-function isSchemaOrSchemaFn(value) {
-  return value instanceof SchemaImpl || typeof value === 'function';
-}
-function assertPathIsCurrent(path) {
-  if (currentCompilingNode !== FieldPathNode.unwrapFieldPath(path).root) {
-    throw new Error(`A FieldPath can only be used directly within the Schema that owns it,` + ` **not** outside of it or within a sub-schema.`);
-  }
-}
-
-class MetadataKey {
-  brand;
-  constructor() {}
-}
-function createMetadataKey() {
-  return new MetadataKey();
-}
-class AggregateMetadataKey {
-  reduce;
-  getInitial;
-  brand;
-  constructor(reduce, getInitial) {
-    this.reduce = reduce;
-    this.getInitial = getInitial;
-  }
-}
-function reducedMetadataKey(reduce, getInitial) {
-  return new AggregateMetadataKey(reduce, getInitial);
-}
-function listMetadataKey() {
-  return reducedMetadataKey((acc, item) => item === undefined ? acc : [...acc, item], () => []);
-}
-function minMetadataKey() {
-  return reducedMetadataKey((prev, next) => {
-    if (prev === undefined) {
-      return next;
-    }
-    if (next === undefined) {
-      return prev;
-    }
-    return Math.min(prev, next);
-  }, () => undefined);
-}
-function maxMetadataKey() {
-  return reducedMetadataKey((prev, next) => {
-    if (prev === undefined) {
-      return next;
-    }
-    if (next === undefined) {
-      return prev;
-    }
-    return Math.max(prev, next);
-  }, () => undefined);
-}
-function orMetadataKey() {
-  return reducedMetadataKey((prev, next) => prev || next, () => false);
-}
-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();
+import { computed, InjectionToken, inject, Injector, input, ɵCONTROL as _CONTROL, effect, Directive, ɵisPromise as _isPromise, resource } from '@angular/core';
+import { isArray, assertPathIsCurrent, addDefaultField, FieldPathNode, createMetadataKey, DEBOUNCER, REQUIRED, MAX, MAX_LENGTH, MIN, MIN_LENGTH, PATTERN } from './_structure-chunk.mjs';
+export { AggregateMetadataKey, MetadataKey, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, form, listMetadataKey, maxMetadataKey, minMetadataKey, orMetadataKey, reducedMetadataKey, schema, submit } from './_structure-chunk.mjs';
+import { Validators, NG_VALUE_ACCESSOR, NgControl } from '@angular/forms';
+import '@angular/core/primitives/signals';
 
 function requiredError(options) {
   return new RequiredValidationError(options);
@@ -957,8 +259,6 @@ function validateHttp(path, opts) {
   });
 }
 
-const DEBOUNCER = reducedMetadataKey((_, item) => item, () => undefined);
-
 function debounce(path, durationOrDebouncer) {
   assertPathIsCurrent(path);
   const pathNode = FieldPathNode.unwrapFieldPath(path);
@@ -966,8 +266,11 @@ function debounce(path, durationOrDebouncer) {
   pathNode.builder.addAggregateMetadataRule(DEBOUNCER, () => debouncer);
 }
 function debounceForDuration(durationInMilliseconds) {
-  return () => {
-    return new Promise(resolve => setTimeout(resolve, durationInMilliseconds));
+  return (_context, abortSignal) => {
+    return new Promise(resolve => {
+      const timeoutId = setTimeout(resolve, durationInMilliseconds);
+      abortSignal.addEventListener('abort', () => clearTimeout(timeoutId));
+    });
   };
 }
 function immediate() {}
@@ -1078,7 +381,7 @@ class Field {
   }
   static ɵfac = i0.ɵɵngDeclareFactory({
     minVersion: "12.0.0",
-    version: "21.0.0-rc.2",
+    version: "21.0.0",
     ngImport: i0,
     type: Field,
     deps: [],
@@ -1086,7 +389,7 @@ class Field {
   });
   static ɵdir = i0.ɵɵngDeclareDirective({
     minVersion: "17.1.0",
-    version: "21.0.0-rc.2",
+    version: "21.0.0",
     type: Field,
     isStandalone: true,
     selector: "[field]",
@@ -1111,7 +414,7 @@ class Field {
 }
 i0.ɵɵngDeclareClassMetadata({
   minVersion: "12.0.0",
-  version: "21.0.0-rc.2",
+  version: "21.0.0",
   ngImport: i0,
   type: Field,
   decorators: [{
@@ -1139,784 +442,6 @@ i0.ɵɵngDeclareClassMetadata({
   }
 });
 
-class FieldNodeContext {
-  node;
-  cache = new WeakMap();
-  constructor(node) {
-    this.node = node;
-  }
-  resolve(target) {
-    if (!this.cache.has(target)) {
-      const resolver = computed(() => {
-        const targetPathNode = FieldPathNode.unwrapFieldPath(target);
-        let field = this.node;
-        let stepsRemaining = getBoundPathDepth();
-        while (stepsRemaining > 0 || !field.structure.logic.hasLogic(targetPathNode.root.builder)) {
-          stepsRemaining--;
-          field = field.structure.parent;
-          if (field === undefined) {
-            throw new Error('Path is not part of this field tree.');
-          }
-        }
-        for (let key of targetPathNode.keys) {
-          field = field.structure.getChild(key);
-          if (field === undefined) {
-            throw new Error(`Cannot resolve path .${targetPathNode.keys.join('.')} relative to field ${['<root>', ...this.node.structure.pathKeys()].join('.')}.`);
-          }
-        }
-        return field.fieldProxy;
-      }, ...(ngDevMode ? [{
-        debugName: "resolver"
-      }] : []));
-      this.cache.set(target, resolver);
-    }
-    return this.cache.get(target)();
-  }
-  get field() {
-    return this.node.fieldProxy;
-  }
-  get state() {
-    return this.node;
-  }
-  get value() {
-    return this.node.structure.value;
-  }
-  get key() {
-    return this.node.structure.keyInParent;
-  }
-  get pathKeys() {
-    return this.node.structure.pathKeys;
-  }
-  index = computed(() => {
-    const key = this.key();
-    if (!isArray(untracked(this.node.structure.parent.value))) {
-      throw new Error(`RuntimeError: cannot access index, parent field is not an array`);
-    }
-    return Number(key);
-  }, ...(ngDevMode ? [{
-    debugName: "index"
-  }] : []));
-  fieldTreeOf = p => this.resolve(p);
-  stateOf = p => this.resolve(p)();
-  valueOf = p => {
-    const result = this.resolve(p)().value();
-    if (result instanceof AbstractControl) {
-      throw new Error(`Tried to read an 'AbstractControl' value form a 'form()'. Did you mean to use 'compatForm()' instead?`);
-    }
-    return result;
-  };
-}
-
-class FieldMetadataState {
-  node;
-  metadata = new Map();
-  constructor(node) {
-    this.node = node;
-    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 (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) {
-    if (key instanceof AggregateMetadataKey) {
-      return this.node.logicNode.logic.hasAggregateMetadata(key);
-    } else {
-      return this.metadata.has(key);
-    }
-  }
-}
-
-const FIELD_PROXY_HANDLER = {
-  get(getTgt, p, receiver) {
-    const tgt = getTgt();
-    const child = tgt.structure.getChild(p);
-    if (child !== undefined) {
-      return child.fieldProxy;
-    }
-    const value = untracked(tgt.value);
-    if (isArray(value)) {
-      if (p === 'length') {
-        return tgt.value().length;
-      }
-      if (p === Symbol.iterator) {
-        return Array.prototype[p];
-      }
-    }
-    if (isObject(value)) {
-      if (p === Symbol.iterator) {
-        return function* () {
-          for (const key in receiver) {
-            yield [key, receiver[key]];
-          }
-        };
-      }
-    }
-    return undefined;
-  },
-  getOwnPropertyDescriptor(getTgt, prop) {
-    const value = untracked(getTgt().value);
-    const desc = Reflect.getOwnPropertyDescriptor(value, prop);
-    if (desc && !desc.configurable) {
-      desc.configurable = true;
-    }
-    return desc;
-  },
-  ownKeys(getTgt) {
-    const value = untracked(getTgt().value);
-    return typeof value === 'object' && value !== null ? Reflect.ownKeys(value) : [];
-  }
-};
-
-function deepSignal(source, prop) {
-  const read = computed(() => source()[prop()]);
-  read[SIGNAL] = source[SIGNAL];
-  read.set = value => {
-    source.update(current => valueForWrite(current, value, prop()));
-  };
-  read.update = fn => {
-    read.set(fn(untracked(read)));
-  };
-  read.asReadonly = () => read;
-  return read;
-}
-function valueForWrite(sourceValue, newPropValue, prop) {
-  if (isArray(sourceValue)) {
-    const newValue = [...sourceValue];
-    newValue[prop] = newPropValue;
-    return newValue;
-  } else {
-    return {
-      ...sourceValue,
-      [prop]: newPropValue
-    };
-  }
-}
-
-class FieldNodeStructure {
-  logic;
-  identitySymbol = Symbol();
-  _injector = undefined;
-  get injector() {
-    this._injector ??= Injector.create({
-      providers: [],
-      parent: this.fieldManager.injector
-    });
-    return this._injector;
-  }
-  constructor(logic) {
-    this.logic = logic;
-  }
-  children() {
-    return this.childrenMap()?.values() ?? [];
-  }
-  getChild(key) {
-    const map = this.childrenMap();
-    const value = this.value();
-    if (!map || !isObject(value)) {
-      return undefined;
-    }
-    if (isArray(value)) {
-      const childValue = value[key];
-      if (isObject(childValue) && childValue.hasOwnProperty(this.identitySymbol)) {
-        key = childValue[this.identitySymbol];
-      }
-    }
-    return map.get(typeof key === 'number' ? key.toString() : key);
-  }
-  destroy() {
-    this.injector.destroy();
-  }
-}
-class RootFieldNodeStructure extends FieldNodeStructure {
-  node;
-  fieldManager;
-  value;
-  get parent() {
-    return undefined;
-  }
-  get root() {
-    return this.node;
-  }
-  get pathKeys() {
-    return ROOT_PATH_KEYS;
-  }
-  get keyInParent() {
-    return ROOT_KEY_IN_PARENT;
-  }
-  childrenMap;
-  constructor(node, pathNode, logic, fieldManager, value, adapter, createChildNode) {
-    super(logic);
-    this.node = node;
-    this.fieldManager = fieldManager;
-    this.value = value;
-    this.childrenMap = makeChildrenMapSignal(node, value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
-  }
-}
-class ChildFieldNodeStructure extends FieldNodeStructure {
-  parent;
-  root;
-  pathKeys;
-  keyInParent;
-  value;
-  childrenMap;
-  get fieldManager() {
-    return this.root.structure.fieldManager;
-  }
-  constructor(node, pathNode, logic, parent, identityInParent, initialKeyInParent, adapter, createChildNode) {
-    super(logic);
-    this.parent = parent;
-    this.root = this.parent.structure.root;
-    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 = makeChildrenMapSignal(node, this.value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
-    this.fieldManager.structures.add(this);
-  }
-}
-let globalId = 0;
-const ROOT_PATH_KEYS = computed(() => [], ...(ngDevMode ? [{
-  debugName: "ROOT_PATH_KEYS"
-}] : []));
-const ROOT_KEY_IN_PARENT = computed(() => {
-  throw new Error(`RuntimeError: the top-level field in the form has no parent`);
-}, ...(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('.')}`;
-}
-
-class FieldSubmitState {
-  node;
-  selfSubmitting = signal(false, ...(ngDevMode ? [{
-    debugName: "selfSubmitting"
-  }] : []));
-  serverErrors;
-  constructor(node) {
-    this.node = node;
-    this.serverErrors = linkedSignal(...(ngDevMode ? [{
-      debugName: "serverErrors",
-      source: this.node.structure.value,
-      computation: () => []
-    }] : [{
-      source: this.node.structure.value,
-      computation: () => []
-    }]));
-  }
-  submitting = computed(() => {
-    return this.selfSubmitting() || (this.node.structure.parent?.submitting() ?? false);
-  }, ...(ngDevMode ? [{
-    debugName: "submitting"
-  }] : []));
-}
-
-class FieldNode {
-  structure;
-  validationState;
-  metadataState;
-  nodeState;
-  submitState;
-  fieldAdapter;
-  _context = undefined;
-  get context() {
-    return this._context ??= new FieldNodeContext(this);
-  }
-  fieldProxy = new Proxy(() => this, FIELD_PROXY_HANDLER);
-  constructor(options) {
-    this.fieldAdapter = options.fieldAdapter;
-    this.structure = this.fieldAdapter.createStructure(this, options);
-    this.validationState = this.fieldAdapter.createValidationState(this, options);
-    this.nodeState = this.fieldAdapter.createNodeState(this, options);
-    this.metadataState = new FieldMetadataState(this);
-    this.submitState = new FieldSubmitState(this);
-  }
-  pendingSync = linkedSignal(...(ngDevMode ? [{
-    debugName: "pendingSync",
-    source: () => this.value(),
-    computation: () => undefined
-  }] : [{
-    source: () => this.value(),
-    computation: () => undefined
-  }]));
-  get logicNode() {
-    return this.structure.logic;
-  }
-  get value() {
-    return this.structure.value;
-  }
-  _controlValue = linkedSignal(() => this.value(), ...(ngDevMode ? [{
-    debugName: "_controlValue"
-  }] : []));
-  get controlValue() {
-    return this._controlValue.asReadonly();
-  }
-  get keyInParent() {
-    return this.structure.keyInParent;
-  }
-  get errors() {
-    return this.validationState.errors;
-  }
-  get errorSummary() {
-    return this.validationState.errorSummary;
-  }
-  get pending() {
-    return this.validationState.pending;
-  }
-  get valid() {
-    return this.validationState.valid;
-  }
-  get invalid() {
-    return this.validationState.invalid;
-  }
-  get dirty() {
-    return this.nodeState.dirty;
-  }
-  get touched() {
-    return this.nodeState.touched;
-  }
-  get disabled() {
-    return this.nodeState.disabled;
-  }
-  get disabledReasons() {
-    return this.nodeState.disabledReasons;
-  }
-  get hidden() {
-    return this.nodeState.hidden;
-  }
-  get readonly() {
-    return this.nodeState.readonly;
-  }
-  get fieldBindings() {
-    return this.nodeState.fieldBindings;
-  }
-  get submitting() {
-    return this.submitState.submitting;
-  }
-  get name() {
-    return this.nodeState.name;
-  }
-  metadataOrUndefined(key) {
-    return this.hasMetadata(key) ? this.metadata(key) : undefined;
-  }
-  get max() {
-    return this.metadataOrUndefined(MAX);
-  }
-  get maxLength() {
-    return this.metadataOrUndefined(MAX_LENGTH);
-  }
-  get min() {
-    return this.metadataOrUndefined(MIN);
-  }
-  get minLength() {
-    return this.metadataOrUndefined(MIN_LENGTH);
-  }
-  get pattern() {
-    return this.metadataOrUndefined(PATTERN) ?? EMPTY;
-  }
-  get required() {
-    return this.metadataOrUndefined(REQUIRED) ?? FALSE;
-  }
-  metadata(key) {
-    return this.metadataState.get(key);
-  }
-  hasMetadata(key) {
-    return this.metadataState.has(key);
-  }
-  markAsTouched() {
-    this.nodeState.markAsTouched();
-    this.sync();
-  }
-  markAsDirty() {
-    this.nodeState.markAsDirty();
-  }
-  reset() {
-    this.nodeState.markAsUntouched();
-    this.nodeState.markAsPristine();
-    for (const child of this.structure.children()) {
-      child.reset();
-    }
-  }
-  setControlValue(newValue) {
-    this._controlValue.set(newValue);
-    this.markAsDirty();
-    this.debounceSync();
-  }
-  sync() {
-    this.value.set(this.controlValue());
-    this.pendingSync.set(undefined);
-  }
-  debounceSync() {
-    const promise = this.nodeState.debouncer();
-    if (promise) {
-      promise.then(() => {
-        if (promise === this.pendingSync()) {
-          this.sync();
-        }
-      });
-      this.pendingSync.set(promise);
-    } else {
-      this.sync();
-    }
-  }
-  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.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 ? [{
-  debugName: "EMPTY"
-}] : []));
-const FALSE = computed(() => false, ...(ngDevMode ? [{
-  debugName: "FALSE"
-}] : []));
-
-class FieldNodeState {
-  node;
-  selfTouched = signal(false, ...(ngDevMode ? [{
-    debugName: "selfTouched"
-  }] : []));
-  selfDirty = signal(false, ...(ngDevMode ? [{
-    debugName: "selfDirty"
-  }] : []));
-  markAsTouched() {
-    this.selfTouched.set(true);
-  }
-  markAsDirty() {
-    this.selfDirty.set(true);
-  }
-  markAsPristine() {
-    this.selfDirty.set(false);
-  }
-  markAsUntouched() {
-    this.selfTouched.set(false);
-  }
-  fieldBindings = signal([], ...(ngDevMode ? [{
-    debugName: "fieldBindings"
-  }] : []));
-  constructor(node) {
-    this.node = node;
-  }
-  dirty = computed(() => {
-    const selfDirtyValue = this.selfDirty() && !this.isNonInteractive();
-    return reduceChildren(this.node, selfDirtyValue, (child, value) => value || child.nodeState.dirty(), shortCircuitTrue);
-  }, ...(ngDevMode ? [{
-    debugName: "dirty"
-  }] : []));
-  touched = computed(() => {
-    const selfTouchedValue = this.selfTouched() && !this.isNonInteractive();
-    return reduceChildren(this.node, selfTouchedValue, (child, value) => value || child.nodeState.touched(), shortCircuitTrue);
-  }, ...(ngDevMode ? [{
-    debugName: "touched"
-  }] : []));
-  disabledReasons = computed(() => [...(this.node.structure.parent?.nodeState.disabledReasons() ?? []), ...this.node.logicNode.logic.disabledReasons.compute(this.node.context)], ...(ngDevMode ? [{
-    debugName: "disabledReasons"
-  }] : []));
-  disabled = computed(() => !!this.disabledReasons().length, ...(ngDevMode ? [{
-    debugName: "disabled"
-  }] : []));
-  readonly = computed(() => (this.node.structure.parent?.nodeState.readonly() || this.node.logicNode.logic.readonly.compute(this.node.context)) ?? false, ...(ngDevMode ? [{
-    debugName: "readonly"
-  }] : []));
-  hidden = computed(() => (this.node.structure.parent?.nodeState.hidden() || this.node.logicNode.logic.hidden.compute(this.node.context)) ?? false, ...(ngDevMode ? [{
-    debugName: "hidden"
-  }] : []));
-  name = computed(() => {
-    const parent = this.node.structure.parent;
-    if (!parent) {
-      return this.node.structure.fieldManager.rootName;
-    }
-    return `${parent.name()}.${this.node.structure.keyInParent()}`;
-  }, ...(ngDevMode ? [{
-    debugName: "name"
-  }] : []));
-  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 debouncer(this.node.context);
-      }
-    }
-    return this.node.structure.parent?.nodeState.debouncer();
-  }
-  isNonInteractive = computed(() => this.hidden() || this.disabled() || this.readonly(), ...(ngDevMode ? [{
-    debugName: "isNonInteractive"
-  }] : []));
-}
-
-class BasicFieldAdapter {
-  newRoot(fieldManager, value, pathNode, adapter) {
-    return new FieldNode({
-      kind: 'root',
-      fieldManager,
-      value,
-      pathNode,
-      logic: pathNode.builder.build(),
-      fieldAdapter: adapter
-    });
-  }
-  newChild(options) {
-    return new FieldNode(options);
-  }
-  createNodeState(node) {
-    return new FieldNodeState(node);
-  }
-  createValidationState(node) {
-    return new FieldValidationState(node);
-  }
-  createStructure(node, options) {
-    return node.createStructure(options);
-  }
-}
-
-class FormFieldManager {
-  injector;
-  rootName;
-  constructor(injector, rootName) {
-    this.injector = injector;
-    this.rootName = rootName ?? `${this.injector.get(APP_ID)}.form${nextFormId++}`;
-  }
-  structures = new Set();
-  createFieldManagementEffect(root) {
-    effect(() => {
-      const liveStructures = new Set();
-      this.markStructuresLive(root, liveStructures);
-      for (const structure of this.structures) {
-        if (!liveStructures.has(structure)) {
-          this.structures.delete(structure);
-          untracked(() => structure.destroy());
-        }
-      }
-    }, {
-      injector: this.injector
-    });
-  }
-  markStructuresLive(structure, liveStructures) {
-    liveStructures.add(structure);
-    for (const child of structure.children()) {
-      this.markStructuresLive(child.structure, liveStructures);
-    }
-  }
-}
-let nextFormId = 0;
-
-function normalizeFormArgs(args) {
-  let model;
-  let schema;
-  let options;
-  if (args.length === 3) {
-    [model, schema, options] = args;
-  } else if (args.length === 2) {
-    if (isSchemaOrSchemaFn(args[1])) {
-      [model, schema] = args;
-    } else {
-      [model, options] = args;
-    }
-  } else {
-    [model] = args;
-  }
-  return [model, schema, options];
-}
-
-function form(...args) {
-  const [model, schema, options] = normalizeFormArgs(args);
-  const injector = options?.injector ?? inject(Injector);
-  const pathNode = runInInjectionContext(injector, () => SchemaImpl.rootCompile(schema));
-  const fieldManager = new FormFieldManager(injector, options?.name);
-  const adapter = options?.adapter ?? new BasicFieldAdapter();
-  const fieldRoot = FieldNode.newRoot(fieldManager, model, pathNode, adapter);
-  fieldManager.createFieldManagementEffect(fieldRoot.structure);
-  return fieldRoot.fieldProxy;
-}
-function applyEach(path, schema) {
-  assertPathIsCurrent(path);
-  const elementPath = FieldPathNode.unwrapFieldPath(path).getChild(DYNAMIC).fieldPathProxy;
-  apply(elementPath, schema);
-}
-function apply(path, schema) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.mergeIn(SchemaImpl.create(schema));
-}
-function applyWhen(path, logic, schema) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.mergeIn(SchemaImpl.create(schema), {
-    fn: logic,
-    path
-  });
-}
-function applyWhenValue(path, predicate, schema) {
-  applyWhen(path, ({
-    value
-  }) => predicate(value()), schema);
-}
-async function submit(form, action) {
-  const node = form();
-  markAllAsTouched(node);
-  if (node.invalid()) {
-    return;
-  }
-  node.submitState.selfSubmitting.set(true);
-  try {
-    const errors = await action(form);
-    errors && setServerErrors(node, errors);
-  } finally {
-    node.submitState.selfSubmitting.set(false);
-  }
-}
-function setServerErrors(submittedField, errors) {
-  if (!isArray(errors)) {
-    errors = [errors];
-  }
-  const errorsByField = new Map();
-  for (const error of errors) {
-    const errorWithField = addDefaultField(error, submittedField.fieldProxy);
-    const field = errorWithField.field();
-    let fieldErrors = errorsByField.get(field);
-    if (!fieldErrors) {
-      fieldErrors = [];
-      errorsByField.set(field, fieldErrors);
-    }
-    fieldErrors.push(errorWithField);
-  }
-  for (const [field, fieldErrors] of errorsByField) {
-    field.submitState.serverErrors.set(fieldErrors);
-  }
-}
-function schema(fn) {
-  return SchemaImpl.create(fn);
-}
-function markAllAsTouched(node) {
-  node.markAsTouched();
-  for (const child of node.structure.children()) {
-    markAllAsTouched(child);
-  }
-}
-
 const EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 function email(path, config) {
   validate(path, ctx => {
@@ -1949,7 +474,9 @@ function max(path, maxValue, config) {
     if (max === undefined || Number.isNaN(max)) {
       return undefined;
     }
-    if (ctx.value() > max) {
+    const value = ctx.value();
+    const numValue = !value && value !== 0 ? NaN : Number(value);
+    if (numValue > max) {
       if (config?.error) {
         return getOption(config.error, ctx);
       } else {
@@ -2001,7 +528,9 @@ function min(path, minValue, config) {
     if (min === undefined || Number.isNaN(min)) {
       return undefined;
     }
-    if (ctx.value() < min) {
+    const value = ctx.value();
+    const numValue = !value && value !== 0 ? NaN : Number(value);
+    if (numValue < min) {
       if (config?.error) {
         return getOption(config.error, ctx);
       } else {
@@ -2130,8 +659,10 @@ function standardIssueToFormTreeError(field, issue) {
     const pathKey = typeof pathPart === 'object' ? pathPart.key : pathPart;
     target = target[pathKey];
   }
-  return addDefaultField(standardSchemaError(issue), target);
+  return addDefaultField(standardSchemaError(issue, {
+    message: issue.message
+  }), target);
 }
 
-export { AggregateMetadataKey, CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MetadataKey, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PatternValidationError, REQUIRED, RequiredValidationError, StandardSchemaValidationError, aggregateMetadata, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, createMetadataKey, customError, debounce, disabled, email, emailError, form, hidden, listMetadataKey, max, maxError, maxLength, maxLengthError, maxMetadataKey, metadata, min, minError, minLength, minLengthError, minMetadataKey, orMetadataKey, pattern, patternError, readonly, reducedMetadataKey, required, requiredError, schema, standardSchemaError, submit, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
+export { CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PatternValidationError, REQUIRED, RequiredValidationError, StandardSchemaValidationError, aggregateMetadata, createMetadataKey, customError, debounce, disabled, email, emailError, hidden, max, maxError, maxLength, maxLengthError, metadata, min, minError, minLength, minLengthError, pattern, patternError, readonly, required, requiredError, standardSchemaError, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
 //# sourceMappingURL=signals.mjs.map