react-f0rm 1.1.1 → 1.3.0

package/dist/index.umd.js

@@ -23,6 +23,67 @@
 
   var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _createForOfIteratorHelper(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (!t) {
+      if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+        t && (r = t);
+        var n = 0,
+          F = function () {};
+        return {
+          s: F,
+          n: function () {
+            return n >= r.length ? {
+              done: true
+            } : {
+              done: false,
+              value: r[n++]
+            };
+          },
+          e: function (r) {
+            throw r;
+          },
+          f: F
+        };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var o,
+      a = true,
+      u = false;
+    return {
+      s: function () {
+        t = t.call(r);
+      },
+      n: function () {
+        var r = t.next();
+        return a = r.done, r;
+      },
+      e: function (r) {
+        u = true, o = r;
+      },
+      f: function () {
+        try {
+          a || null == t.return || t.return();
+        } finally {
+          if (u) throw o;
+        }
+      }
+    };
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
   function getSet(ee, key) {
     var set = ee.get(key);
     if (set) return set;
@@ -30,20 +91,85 @@
     ee.set(key, newSet);
     return newSet;
   }
+
+  // DEV-only listener-leak warning. Checked via process.env.NODE_ENV because the
+  // build pipeline has no compile-time constant injection; the typeof guard
+  // keeps direct browser usage of the UMD build safe. In production the whole
+  // machinery is skipped and `on` only pays one boolean test.
+  var DEV = typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production';
+  var DEFAULT_MAX_LISTENERS = 10;
+  var maxListenersMap = new WeakMap();
+  var warnedKeysMap = new WeakMap();
+  function _setMaxListeners(ee, n) {
+    maxListenersMap.set(ee, n);
+  }
+  function checkMaxListeners(ee, key, size) {
+    var max = maxListenersMap.get(ee);
+    if (max === undefined) max = DEFAULT_MAX_LISTENERS;
+    if (max <= 0 || size <= max) return;
+    var warnedKeys = warnedKeysMap.get(ee);
+    if (!warnedKeys) {
+      warnedKeys = new Set();
+      warnedKeysMap.set(ee, warnedKeys);
+    }
+    if (warnedKeys.has(key)) return;
+    warnedKeys.add(key);
+    // eslint-disable-next-line no-console
+    console.warn("Possible event-emitter memory leak: ".concat(size, " \"").concat(String(key), "\" listeners added. ") + "Use setMaxListeners(ee, n) to raise the limit, or 0 to disable this warning.");
+  }
+  var errorEvent = Symbol('error');
   function create$2() {
     return new Map();
   }
+
+  // A throwing handler must not stop its peers: errors are collected while the
+  // remaining handlers still run, then reported through emitError (the
+  // errorEvent channel). If no error handler is subscribed either, the first
+  // collected error is rethrown to the emit caller instead of being swallowed.
+  // Iteration follows Set semantics: a listener added while this emit runs is
+  // still visited by that same emit, and a listener removed before it is
+  // visited is skipped. Removing a whole key (off/removeAllListeners) does not
+  // affect an emit already in flight.
   function emit(ee, key) {
     for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
       args[_key - 2] = arguments[_key];
     }
-    (ee.get(key) || []).forEach(function (h) {
-      return h.apply(void 0, args);
+    var set = ee.get(key);
+    if (!set || !set.size) return;
+    var errors;
+    set.forEach(function (h) {
+      try {
+        h.apply(void 0, args);
+      } catch (err) {
+        if (errors) errors.push(err);else errors = [err];
+      }
+    });
+    if (errors) {
+      var _iterator = _createForOfIteratorHelper(errors),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var err = _step.value;
+          emitError(ee, err);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+  function emitError(ee, err) {
+    var handlerSet = ee.get(errorEvent);
+    if (!handlerSet || !handlerSet.size) throw err;
+    handlerSet.forEach(function (h) {
+      return h(err);
     });
   }
   function on(ee, key, handler) {
     var set = getSet(ee, key);
     set.add(handler);
+    if (DEV) checkMaxListeners(ee, key, set.size);
     return function () {
       return set.delete(handler);
     };
@@ -230,110 +356,59 @@
     return { value, key: JSON.stringify(value) };
   }
 
-  const VALIDATION_OUTCOME = /* @__PURE__ */ Symbol("validation-outcome");
-  function create(options) {
-    const emitter = create$2();
-    return {
-      emitter,
-      ...options,
-      mode: options?.mode ?? "onSubmit",
-      reValidateMode: options?.reValidateMode ?? "onChange",
-      disabled: options?.disabled ?? false,
-      validateDeps: options?.validateDeps ? new Set(options.validateDeps.map((dep) => create$1(dep).key)) : void 0,
-      initialValues: options?.initialValues ?? {},
-      values: /* @__PURE__ */ new Map(),
-      deleted: /* @__PURE__ */ new Set(),
-      errors: /* @__PURE__ */ new Map(),
-      touched: /* @__PURE__ */ new Set(),
-      validators: /* @__PURE__ */ new Map(),
-      changeHandlers: /* @__PURE__ */ new Map(),
-      validating: /* @__PURE__ */ new Set(),
-      parsedValues: void 0,
-      isSubmitting: false,
-      submitCount: 0,
-      isSubmitSuccessful: void 0
-    };
-  }
   const valuesCaches = /* @__PURE__ */ new WeakMap();
   function bumpValuesVersion(form) {
     const cache = valuesCaches.get(form);
     if (cache) cache.version++;
   }
-  function getValues(form) {
-    let cache = valuesCaches.get(form);
-    if (!cache) {
-      cache = { version: 0, result: computeValues(form) };
-      valuesCaches.set(form, cache);
-    } else if (cache.version > 0) {
-      cache.result = computeValues(form);
-      cache.version = 0;
-    }
-    return cache.result;
+  const dirtyBaselines = /* @__PURE__ */ new WeakMap();
+  function getDirtyBaseline(form, key, segments) {
+    const baselines = dirtyBaselines.get(form);
+    if (baselines?.has(key)) return baselines.get(key);
+    return get(form.initialValues, segments);
   }
-  function computeValues(form) {
-    const { initialValues, parsedValues, values, deleted } = form;
-    const owned = /* @__PURE__ */ new Set();
-    let merged = parsedValues ?? initialValues;
-    for (const [key, value] of values) {
-      merged = setOwned(merged, JSON.parse(key), value, owned);
-    }
-    for (const key of deleted) {
-      merged = unset(merged, JSON.parse(key));
+  function setDirtyBaseline(form, { key }, value) {
+    let baselines = dirtyBaselines.get(form);
+    if (!baselines) {
+      baselines = /* @__PURE__ */ new Map();
+      dirtyBaselines.set(form, baselines);
     }
-    return merged;
-  }
-  function getValue(form, name) {
-    return getValueByPath(form, create$1(name));
+    baselines.set(key, value);
   }
-  function getValueByPath({ initialValues, parsedValues, values, deleted }, path) {
-    const { key, value: segments } = path;
-    if (values.has(key)) return values.get(key);
-    if (deleted.has(key)) return void 0;
-    for (let i = segments.length - 1; i > 0; i--) {
-      const ancestorKey = JSON.stringify(segments.slice(0, i));
-      if (values.has(ancestorKey)) {
-        return get(values.get(ancestorKey), segments.slice(i));
-      }
+  function pruneDirtyBaselines(form, { key }) {
+    const baselines = dirtyBaselines.get(form);
+    if (!baselines?.size) return;
+    const stem = `${key.slice(0, -1)},`;
+    for (const baselineKey of baselines.keys()) {
+      if (baselineKey.startsWith(stem)) baselines.delete(baselineKey);
     }
-    return get(parsedValues ?? initialValues, segments);
-  }
-  function setValue(form, name, value, options) {
-    setValueByPath(form, create$1(name), value, options);
   }
-  function setValueByPath(form, path, value, options) {
-    const { emitter, values, deleted } = form;
-    values.set(path.key, value);
-    pruneDescendantKeys(values, path);
-    reviveBranch(deleted, path);
-    pruneDirtyBaselines(form, path);
-    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
-    bumpDirtyVersion(form);
-    bumpValuesVersion(form);
-    if (options?.shouldTouch) setTouchedByPath(form, path);
-    if (options?.shouldValidate) form.validators.get(path.key)?.();
-    emit(emitter, "change", path);
+  function clearDirtyBaselines(form, key) {
+    const baselines = dirtyBaselines.get(form);
+    if (!baselines) return;
+    if (key === void 0) baselines.clear();
+    else baselines.delete(key);
   }
-  function seedValueByPath(form, path, value) {
-    const { values, deleted } = form;
-    values.set(path.key, value);
-    pruneDescendantKeys(values, path);
-    reviveBranch(deleted, path);
-    pruneDirtyBaselines(form, path);
-    bumpDirtyVersion(form);
-    bumpValuesVersion(form);
+  const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
+  function bumpDirtyVersion(form) {
+    const cache = dirtyFieldsCaches.get(form);
+    if (cache) cache.version++;
   }
-  function emitChangeByPath({ emitter }, path) {
-    emit(emitter, "change", path);
+  function isSegmentsPath(name) {
+    return name.some((part) => typeof part === "number");
   }
-  function changeValue(form, name, value, options) {
-    changeValueByPath(form, create$1(name), value, options);
+  function isFieldError(value) {
+    return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.message === "string";
   }
-  function changeValueByPath(form, path, value, options) {
-    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
-    const change = form.changeHandlers.get(path.key);
-    if (change) change(value);
-    else setValueByPath(form, path, value, options);
+  function setParsedValues(form, values) {
+    if (values === void 0 || values === form.parsedValues) return;
+    form.parsedValues = values;
+    bumpValuesVersion(form);
+    emit(form.emitter, "change");
   }
+
+  const FORM_ERROR = "_form";
+  const VALIDATION_OUTCOME = /* @__PURE__ */ Symbol("validation-outcome");
   function getError(form, name) {
     return getErrorByPath(form, create$1(name));
   }
@@ -358,37 +433,16 @@
   function getFirstError({ errors }) {
     return errors.values().next().value?.[0]?.message;
   }
-  function getFieldState(form, name) {
-    const path = create$1(name);
-    const { values, touched, validating } = form;
-    const live = values.get(path.key);
-    return {
-      value: getValueByPath(form, path),
-      error: getErrorByPath(form, path),
-      errors: getFieldErrorsByPath(form, path),
-      // Same rule as getDirtyFields, committed baselines included: the field
-      // is dirty while its live value differs from its effective baseline.
-      isDirty: values.has(path.key) && getDirtyBaseline(form, path.key, path.value) !== live,
-      isTouched: touched.has(path.key),
-      isValidating: validating.has(path.key)
-    };
-  }
-  function unsetValidatingByPath({ emitter, validating }, path) {
-    validating.delete(path.key);
-    emit(emitter, "validating", path);
-  }
-  function setValidatingByPath({ emitter, validating }, path) {
-    validating.add(path.key);
-    emit(emitter, "validating", path);
+  function setError(form, name, error, options) {
+    setErrorByPath(form, create$1(name), error, options);
   }
-  function setError(form, name, error) {
-    setErrorByPath(form, create$1(name), error);
-  }
-  function setErrorByPath({ emitter, errors }, path, error) {
+  function setErrorByPath(form, path, error, options) {
+    const { emitter, errors } = form;
     const list = normalizeErrors(error);
     if (list) errors.set(path.key, list);
     else errors.delete(path.key);
     emit(emitter, "errors", path);
+    if (options?.shouldFocus) emit(emitter, "focusError", path.key);
   }
   function normalizeErrors(error) {
     if (typeof error === "string") {
@@ -430,19 +484,13 @@
       );
     }
   }
-  function setTouched(form, name) {
-    setTouchedByPath(form, create$1(name));
-  }
-  function setTouchedByPath({ emitter, touched }, path) {
-    if (touched.has(path.key)) return;
-    touched.add(path.key);
-    emit(emitter, "touched", path);
-  }
-  function hasTouched(form, name) {
-    return hasTouchedByPath(form, create$1(name));
+  function hasErrors({ errors }) {
+    return errors.size > 0;
   }
-  function hasTouchedByPath({ touched }, path) {
-    return touched.has(path.key);
+
+  function isFieldDirtyByPath(form, path) {
+    const live = form.values.get(path.key);
+    return form.values.has(path.key) && getDirtyBaseline(form, path.key, path.value) !== live;
   }
   function isDirty(form) {
     let dirty = false;
@@ -457,39 +505,6 @@
       if (getDirtyBaseline(form, key, path) !== value) fn(path.join("."));
     }
   }
-  const dirtyBaselines = /* @__PURE__ */ new WeakMap();
-  function getDirtyBaseline(form, key, segments) {
-    const baselines = dirtyBaselines.get(form);
-    if (baselines?.has(key)) return baselines.get(key);
-    return get(form.initialValues, segments);
-  }
-  function setDirtyBaseline(form, { key }, value) {
-    let baselines = dirtyBaselines.get(form);
-    if (!baselines) {
-      baselines = /* @__PURE__ */ new Map();
-      dirtyBaselines.set(form, baselines);
-    }
-    baselines.set(key, value);
-  }
-  function pruneDirtyBaselines(form, { key }) {
-    const baselines = dirtyBaselines.get(form);
-    if (!baselines?.size) return;
-    const stem = `${key.slice(0, -1)},`;
-    for (const baselineKey of baselines.keys()) {
-      if (baselineKey.startsWith(stem)) baselines.delete(baselineKey);
-    }
-  }
-  function clearDirtyBaselines(form, key) {
-    const baselines = dirtyBaselines.get(form);
-    if (!baselines) return;
-    if (key === void 0) baselines.clear();
-    else baselines.delete(key);
-  }
-  const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
-  function bumpDirtyVersion(form) {
-    const cache = dirtyFieldsCaches.get(form);
-    if (cache) cache.version++;
-  }
   function computeDirtyFields(form) {
     const dirtyFields = {};
     forEachDirtyField(form, (key) => {
@@ -514,6 +529,21 @@
     }
     return cache.result;
   }
+
+  function setTouched(form, name) {
+    setTouchedByPath(form, create$1(name));
+  }
+  function setTouchedByPath({ emitter, touched }, path) {
+    if (touched.has(path.key)) return;
+    touched.add(path.key);
+    emit(emitter, "touched", path);
+  }
+  function hasTouched(form, name) {
+    return hasTouchedByPath(form, create$1(name));
+  }
+  function hasTouchedByPath({ touched }, path) {
+    return touched.has(path.key);
+  }
   function getTouchedFields({ touched }) {
     return Array.from(
       touched,
@@ -523,18 +553,102 @@
   function isTouched({ touched }) {
     return touched.size > 0;
   }
-  function removeField(form, name) {
-    removeFieldByPath(form, create$1(name));
+
+  function getValues(form) {
+    let cache = valuesCaches.get(form);
+    if (!cache) {
+      cache = { version: 0, result: computeValues(form) };
+      valuesCaches.set(form, cache);
+    } else if (cache.version > 0) {
+      cache.result = computeValues(form);
+      cache.version = 0;
+    }
+    return cache.result;
+  }
+  function computeValues(form) {
+    const { initialValues, parsedValues, values, deleted } = form;
+    const owned = /* @__PURE__ */ new Set();
+    let merged = parsedValues ?? initialValues;
+    for (const [key, value] of values) {
+      merged = setOwned(merged, JSON.parse(key), value, owned);
+    }
+    for (const key of deleted) {
+      merged = unset(merged, JSON.parse(key));
+    }
+    return merged;
+  }
+  function getValue(form, name) {
+    return getValueByPath(form, create$1(name));
+  }
+  function getValueByPath({ initialValues, parsedValues, values, deleted }, path) {
+    const { key, value: segments } = path;
+    if (values.has(key)) return values.get(key);
+    if (deleted.has(key)) return void 0;
+    for (let i = segments.length - 1; i > 0; i--) {
+      const ancestorKey = JSON.stringify(segments.slice(0, i));
+      if (values.has(ancestorKey)) {
+        return get(values.get(ancestorKey), segments.slice(i));
+      }
+    }
+    return get(parsedValues ?? initialValues, segments);
+  }
+  function setValue(form, name, value, options) {
+    setValueByPath(form, create$1(name), value, options);
+  }
+  function setValueByPath(form, path, value, options) {
+    const { emitter, values, deleted } = form;
+    const next = typeof value === "function" ? value(getValueByPath(form, path)) : value;
+    values.set(path.key, next);
+    pruneDescendantKeys(values, path);
+    reviveBranch(deleted, path);
+    pruneDirtyBaselines(form, path);
+    if (options?.shouldDirty === false) setDirtyBaseline(form, path, next);
+    bumpDirtyVersion(form);
+    bumpValuesVersion(form);
+    if (options?.shouldTouch) setTouchedByPath(form, path);
+    if (options?.shouldValidate) form.validators.get(path.key)?.();
+    emit(emitter, "change", path);
+  }
+  function seedValueByPath(form, path, value) {
+    const { values, deleted } = form;
+    values.set(path.key, value);
+    pruneDescendantKeys(values, path);
+    reviveBranch(deleted, path);
+    pruneDirtyBaselines(form, path);
+    bumpDirtyVersion(form);
+    bumpValuesVersion(form);
+  }
+  function emitChangeByPath({ emitter }, path) {
+    emit(emitter, "change", path);
+  }
+  function getFieldState(form, name) {
+    const path = create$1(name);
+    const { touched, validating } = form;
+    return {
+      value: getValueByPath(form, path),
+      error: getErrorByPath(form, path),
+      errors: getFieldErrorsByPath(form, path),
+      // The shared per-field rule (committed baselines included): the field
+      // is dirty while its live value differs from its effective baseline.
+      isDirty: isFieldDirtyByPath(form, path),
+      isTouched: touched.has(path.key),
+      isValidating: validating.has(path.key)
+    };
+  }
+  function removeField(form, name, options) {
+    removeFieldByPath(form, create$1(name), options);
   }
-  function removeFieldByPath(form, path) {
+  function removeFieldByPath(form, path, options) {
     const { key, value: segments } = path;
     const { emitter, values, touched, errors, validating, deleted } = form;
-    values.delete(key);
-    touched.delete(key);
-    errors.delete(key);
+    if (!options?.keepValue && !options?.keepDirty) {
+      values.delete(key);
+      clearDirtyBaselines(form, key);
+      if (!hasLiveBranch(values, segments)) deleted.add(key);
+    }
+    if (!options?.keepTouched) touched.delete(key);
+    if (!options?.keepError) errors.delete(key);
     validating.delete(key);
-    clearDirtyBaselines(form, key);
-    if (!hasLiveBranch(values, segments)) deleted.add(key);
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
     emit(emitter, "change", path);
@@ -580,17 +694,37 @@
     bumpValuesVersion(form);
     emit(form.emitter, "change");
   }
+  function collectValueLeaves(node, segments, out) {
+    if (node !== null && typeof node === "object") {
+      if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+          collectValueLeaves(node[i], [...segments, i], out);
+        }
+        return;
+      }
+      const keys = Object.keys(node);
+      if (keys.length > 0) {
+        for (const k of keys) {
+          collectValueLeaves(node[k], [...segments, k], out);
+        }
+        return;
+      }
+    }
+    out.push({ segments, value: node });
+  }
   function reset(form, initialValues, options) {
-    const dirtyValues = [];
-    if (options?.keepDirtyValues) {
+    const keptValues = [];
+    if (options?.keepValues) {
+      collectValueLeaves(getValues(form), [], keptValues);
+    } else if (options?.keepDirtyValues) {
       for (const [key, value] of form.values) {
         const segments = JSON.parse(key);
         if (getDirtyBaseline(form, key, segments) !== value) {
-          dirtyValues.push({ segments, value });
+          keptValues.push({ segments, value });
         }
       }
     }
-    form.initialValues = initialValues;
+    form.initialValues = options?.keepDefaultValues ? form.initialValues : initialValues ?? form.initialValues;
     form.parsedValues = void 0;
     if (!options?.keepErrors) clearErrors(form);
     const { emitter, touched, values, deleted, validating } = form;
@@ -601,10 +735,11 @@
     validating.clear();
     if (!options?.keepIsSubmitting) form.isSubmitting = false;
     if (!options?.keepSubmitCount) form.submitCount = 0;
-    if (!options?.keepIsSubmitted) form.isSubmitSuccessful = void 0;
+    if (!options?.keepIsSubmitted) form.isSubmitted = false;
+    if (!options?.keepIsSubmitSuccessful) form.isSubmitSuccessful = void 0;
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
-    for (const { segments, value } of dirtyValues) {
+    for (const { segments, value } of keptValues) {
       setValueByPath(form, create$1(segments), value);
     }
     emit(emitter, "change");
@@ -639,10 +774,151 @@
     bumpDirtyVersion(form);
     bumpValuesVersion(form);
   }
-  function hasErrors({ errors }) {
-    return errors.size > 0;
+
+  function unsetValidatingByPath({ emitter, validating }, path) {
+    validating.delete(path.key);
+    emit(emitter, "validating", path);
+  }
+  function setValidatingByPath({ emitter, validating }, path) {
+    validating.add(path.key);
+    emit(emitter, "validating", path);
+  }
+  function registerValidatorByPath(form, path, registration) {
+    let timer = null;
+    let controller = null;
+    let marked = false;
+    let lock = null;
+    let errorSource = null;
+    const hasErrors2 = (errors) => errors !== void 0 && !(Array.isArray(errors) && errors.length === 0);
+    const mark = () => {
+      if (marked) return;
+      marked = true;
+      setValidatingByPath(form, path);
+    };
+    const unmark = () => {
+      if (!marked) return;
+      marked = false;
+      unsetValidatingByPath(form, path);
+    };
+    const runSync = () => {
+      const sync = registration.sync();
+      if (!sync) return false;
+      const errors = sync(getValueByPath(form, path), { form, path });
+      if (!hasErrors2(errors)) {
+        if (!registration.validate() || errorSource === "sync") {
+          setErrorByPath(form, path, void 0);
+          errorSource = null;
+        }
+        return false;
+      }
+      setErrorByPath(form, path, errors);
+      errorSource = "sync";
+      return true;
+    };
+    const collectSyncErrors = () => {
+      const sync = registration.sync();
+      if (!sync) return null;
+      const errors = sync(getValueByPath(form, path), { form, path });
+      if (errors === void 0) return null;
+      const list = Array.isArray(errors) ? errors : [errors];
+      return list.length ? list : null;
+    };
+    const land = (result) => {
+      if (registration.asyncAlways?.()) {
+        const gate = collectSyncErrors();
+        const own = result === void 0 ? [] : Array.isArray(result) ? result : [result];
+        setErrorByPath(form, path, [...gate ?? [], ...own]);
+        errorSource = hasErrors2(result) ? "validator" : gate ? "sync" : null;
+      } else {
+        setErrorByPath(form, path, result);
+        errorSource = hasErrors2(result) ? "validator" : null;
+      }
+    };
+    const supersede = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      controller?.abort();
+      lock = {};
+    };
+    const runValidator = () => {
+      const fn = registration.validate();
+      if (!fn) {
+        unmark();
+        return;
+      }
+      controller?.abort();
+      controller = new AbortController();
+      const round = lock = {};
+      let result;
+      try {
+        result = fn(getValueByPath(form, path), {
+          form,
+          path,
+          signal: controller.signal
+        });
+      } catch (e) {
+        unmark();
+        throw e;
+      }
+      if (!isPromise(result)) {
+        land(result);
+        unmark();
+        return;
+      }
+      mark();
+      result.then(
+        (error) => {
+          if (lock === round) {
+            land(error);
+          }
+        }
+      ).catch(() => {
+      }).finally(() => {
+        if (lock === round) {
+          unmark();
+          lock = null;
+        }
+      });
+    };
+    const run = () => {
+      timer = null;
+      if (runSync() && !registration.asyncAlways?.()) {
+        supersede();
+        unmark();
+        return;
+      }
+      runValidator();
+    };
+    const kick = () => {
+      if (runSync() && !registration.asyncAlways?.()) {
+        supersede();
+        unmark();
+        return;
+      }
+      if (!registration.validate()) return;
+      const debounce = registration.debounce();
+      if (debounce > 0) {
+        if (timer !== null) clearTimeout(timer);
+        else mark();
+        timer = setTimeout(run, debounce);
+        return;
+      }
+      runValidator();
+    };
+    form.validators.set(path.key, kick);
+    return () => {
+      form.validators.delete(path.key);
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      unmark();
+      controller?.abort();
+    };
   }
-  async function trigger(form, name) {
+  async function trigger(form, name, options) {
     const settle = (keys2) => waitUntil(
       form.emitter,
       "validating",
@@ -653,18 +929,25 @@
       form.validators.forEach((validator) => validator());
       await settle();
       if (form.validate) await runFormValidate(form);
+      if (options?.shouldTouch) touchKeys(form, [...form.validators.keys()]);
+      if (options?.shouldFocus) {
+        const firstKey = form.errors.keys().next().value;
+        if (firstKey !== void 0) emit(form.emitter, "focusError", firstKey);
+      }
       return !hasErrors(form);
     }
     const keys = typeof name === "string" || isSegmentsPath(name) ? [create$1(name).key] : name.map((one) => create$1(one).key);
     keys.forEach((key) => form.validators.get(key)?.());
     await settle(keys);
+    if (options?.shouldTouch) touchKeys(form, keys);
+    if (options?.shouldFocus) {
+      const firstKey = keys.find((key) => form.errors.has(key));
+      if (firstKey !== void 0) emit(form.emitter, "focusError", firstKey);
+    }
     return keys.every((key) => !form.errors.has(key));
   }
-  function isSegmentsPath(name) {
-    return name.some((part) => typeof part === "number");
-  }
-  function isFieldError(value) {
-    return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.message === "string";
+  function touchKeys(form, keys) {
+    keys.forEach((key) => setTouchedByPath(form, create$1(JSON.parse(key))));
   }
   function setFormErrors(form, result, segments = [], footprint) {
     Object.entries(result).forEach(([key, value]) => {
@@ -694,12 +977,6 @@
     const stored = form.errors.get(path.key);
     if (stored) footprint.set(path.key, stored);
   }
-  function setParsedValues(form, values) {
-    if (values === void 0 || values === form.parsedValues) return;
-    form.parsedValues = values;
-    bumpValuesVersion(form);
-    emit(form.emitter, "change");
-  }
   function applyValidateResult(form, result) {
     const footprint = form.validateDeps ? getFormErrorFootprint(form) : void 0;
     if (footprint) {
@@ -897,6 +1174,55 @@
   async function validate(form) {
     return ensureValidate(form).catch((e) => e.message);
   }
+
+  const fieldModes = /* @__PURE__ */ new WeakMap();
+  function changeValue(form, name, value, options) {
+    changeValueByPath(form, create$1(name), value, options);
+  }
+  function changeValueByPath(form, path, value, options) {
+    if (options?.shouldDirty === false) setDirtyBaseline(form, path, value);
+    if (fieldModes.get(form)?.get(path.key)) {
+      userChangeByPath(form, path, value);
+    } else {
+      setValueByPath(form, path, value, options);
+    }
+  }
+  function registerFieldMode(form, path, mode) {
+    let modes = fieldModes.get(form);
+    if (!modes) {
+      modes = /* @__PURE__ */ new Map();
+      fieldModes.set(form, modes);
+    }
+    const displaced = modes.has(path.key);
+    const token = {};
+    modes.set(path.key, { mode, token });
+    return { token, displaced };
+  }
+  function unregisterFieldMode(form, path, token) {
+    const modes = fieldModes.get(form);
+    const entry = modes?.get(path.key);
+    if (modes && entry && entry.token === token) modes.delete(path.key);
+  }
+  function runUserChangeGate(form, path, mode) {
+    if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || getFieldErrorsByPath(form, path).length > 0 && form.reValidateMode === "onChange")
+      form.validators.get(path.key)?.();
+    revalidateFormOnChange(form, path, mode);
+    revalidateDependentsOnChange(form, path, mode);
+  }
+  function userChangeByPath(form, path, value) {
+    setValueByPath(form, path, value);
+    const entry = fieldModes.get(form)?.get(path.key);
+    if (entry) runUserChangeGate(form, path, entry.mode ?? form.mode);
+  }
+  function userBlur(form, path) {
+    setTouchedByPath(form, path);
+    const entry = fieldModes.get(form)?.get(path.key);
+    if (!entry) return;
+    const mode = entry.mode ?? form.mode;
+    if (mode === "onBlur" || mode === "onTouched" || mode === "all" || getFieldErrorsByPath(form, path).length > 0 && form.reValidateMode === "onBlur")
+      form.validators.get(path.key)?.();
+  }
+
   function setIsSubmitting(form, value) {
     form.isSubmitting = value;
     emit(form.emitter, "submitting");
@@ -913,6 +1239,10 @@
     form.disabled = value;
     emit(form.emitter, "disabled");
   }
+  function setStatus(form, value) {
+    form.status = value;
+    emit(form.emitter, "status");
+  }
   function nameToPath(name) {
     if (name.startsWith("[")) {
       try {
@@ -943,6 +1273,7 @@
       onSubmit,
       onValidSubmit,
       onInvalidSubmit,
+      onAction,
       shouldFocusError = true
     } = options ?? {};
     return async (e) => {
@@ -950,6 +1281,7 @@
         e.preventDefault();
       }
       const formEl = e?.currentTarget;
+      form.isSubmitted = true;
       setIsSubmitting(form, true);
       incrementSubmitCount(form);
       const values = getValues(form);
@@ -979,6 +1311,7 @@
         const submitted = getValues(form);
         if (onSubmit) await onSubmit(submitted, e);
         if (onValidSubmit) await onValidSubmit(submitted, e);
+        if (onAction) await onAction(submitted, e);
         setSubmitSuccessful(form, true);
       } catch {
         setSubmitSuccessful(form, false);
@@ -987,12 +1320,62 @@
       }
     };
   }
+
   function setFocus(form, name, options) {
     const { key } = create$1(name);
     if (options) emit(form.emitter, "focusError", key, options);
     else emit(form.emitter, "focusError", key);
   }
 
+  function create(options) {
+    const emitter = create$2();
+    _setMaxListeners(emitter, 0);
+    let source = options?.initialValues ?? {};
+    if (typeof source === "function") source = source();
+    const form = {
+      emitter,
+      ...options,
+      mode: options?.mode ?? "onSubmit",
+      reValidateMode: options?.reValidateMode ?? "onChange",
+      disabled: options?.disabled ?? false,
+      validateOnMount: options?.validateOnMount ?? false,
+      asyncAlways: options?.asyncAlways ?? false,
+      validateDeps: options?.validateDeps ? new Set(options.validateDeps.map((dep) => create$1(dep).key)) : void 0,
+      initialValues: {},
+      values: /* @__PURE__ */ new Map(),
+      deleted: /* @__PURE__ */ new Set(),
+      errors: /* @__PURE__ */ new Map(),
+      touched: /* @__PURE__ */ new Set(),
+      validators: /* @__PURE__ */ new Map(),
+      validating: /* @__PURE__ */ new Set(),
+      parsedValues: void 0,
+      isSubmitting: false,
+      isSubmitted: false,
+      submitCount: 0,
+      isSubmitSuccessful: void 0,
+      isLoading: false,
+      status: void 0
+    };
+    if (isPromise(source)) {
+      form.isLoading = true;
+      emit(emitter, "loading");
+      Promise.resolve(source).then(
+        (resolved) => {
+          setInitialValues(form, resolved ?? {});
+          form.isLoading = false;
+          emit(emitter, "loading");
+        },
+        (error) => {
+          form.isLoading = false;
+          emit(emitter, "loading");
+        }
+      );
+    } else {
+      form.initialValues = source;
+    }
+    return form;
+  }
+
   function defaultMessage(type, bound) {
     switch (type) {
       case "required":
@@ -1012,9 +1395,9 @@
     }
   }
   function rulesToValidator(rules) {
-    return (value) => {
+    return (value, meta) => {
       if (rules.required) {
-        if (value === "" || value === void 0 || value === null) {
+        if (value === "" || value === void 0 || value === null || Array.isArray(value) && value.length === 0) {
           return [
             {
               type: "required",
@@ -1037,13 +1420,14 @@
           errors.push({ type: "max", message: message("max", rules.max) });
         }
       }
-      if (rules.minLength !== void 0 && typeof value === "string" && value.length < rules.minLength) {
+      const isSized = typeof value === "string" || Array.isArray(value);
+      if (rules.minLength !== void 0 && isSized && value.length < rules.minLength) {
         errors.push({
           type: "minLength",
           message: message("minLength", rules.minLength)
         });
       }
-      if (rules.maxLength !== void 0 && typeof value === "string" && value.length > rules.maxLength) {
+      if (rules.maxLength !== void 0 && isSized && value.length > rules.maxLength) {
         errors.push({
           type: "maxLength",
           message: message("maxLength", rules.maxLength)
@@ -1056,207 +1440,32 @@
           message: rules.messages?.pattern ?? rules.pattern.message ?? defaultMessage("pattern")
         });
       }
+      if (rules.validate !== void 0) {
+        const fns = typeof rules.validate === "function" ? { validate: rules.validate } : rules.validate;
+        for (const [type, fn] of Object.entries(fns)) {
+          const result = fn(value, meta);
+          if (result === void 0) continue;
+          for (const entry of Array.isArray(result) ? result : [result]) {
+            errors.push(
+              typeof entry === "string" ? { type, message: entry } : { ...entry, type }
+            );
+          }
+        }
+      }
       return errors.length ? errors : void 0;
     };
   }
-
-  var shim = {exports: {}};
-
-  var useSyncExternalStoreShim_production = {};
-
-  /**
-   * @license React
-   * use-sync-external-store-shim.production.js
-   *
-   * Copyright (c) Meta Platforms, Inc. and affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-
-  var hasRequiredUseSyncExternalStoreShim_production;
-
-  function requireUseSyncExternalStoreShim_production () {
-  	if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
-  	hasRequiredUseSyncExternalStoreShim_production = 1;
-  	var React$1 = React;
-  	function is(x, y) {
-  	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-  	}
-  	var objectIs = "function" === typeof Object.is ? Object.is : is,
-  	  useState = React$1.useState,
-  	  useEffect = React$1.useEffect,
-  	  useLayoutEffect = React$1.useLayoutEffect,
-  	  useDebugValue = React$1.useDebugValue;
-  	function useSyncExternalStore$2(subscribe, getSnapshot) {
-  	  var value = getSnapshot(),
-  	    _useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
-  	    inst = _useState[0].inst,
-  	    forceUpdate = _useState[1];
-  	  useLayoutEffect(
-  	    function () {
-  	      inst.value = value;
-  	      inst.getSnapshot = getSnapshot;
-  	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	    },
-  	    [subscribe, value, getSnapshot]
-  	  );
-  	  useEffect(
-  	    function () {
-  	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	      return subscribe(function () {
-  	        checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	      });
-  	    },
-  	    [subscribe]
-  	  );
-  	  useDebugValue(value);
-  	  return value;
-  	}
-  	function checkIfSnapshotChanged(inst) {
-  	  var latestGetSnapshot = inst.getSnapshot;
-  	  inst = inst.value;
-  	  try {
-  	    var nextValue = latestGetSnapshot();
-  	    return !objectIs(inst, nextValue);
-  	  } catch (error) {
-  	    return true;
-  	  }
-  	}
-  	function useSyncExternalStore$1(subscribe, getSnapshot) {
-  	  return getSnapshot();
-  	}
-  	var shim =
-  	  "undefined" === typeof window ||
-  	  "undefined" === typeof window.document ||
-  	  "undefined" === typeof window.document.createElement
-  	    ? useSyncExternalStore$1
-  	    : useSyncExternalStore$2;
-  	useSyncExternalStoreShim_production.useSyncExternalStore =
-  	  void 0 !== React$1.useSyncExternalStore ? React$1.useSyncExternalStore : shim;
-  	return useSyncExternalStoreShim_production;
-  }
-
-  var useSyncExternalStoreShim_development = {};
-
-  /**
-   * @license React
-   * use-sync-external-store-shim.development.js
-   *
-   * Copyright (c) Meta Platforms, Inc. and affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-
-  var hasRequiredUseSyncExternalStoreShim_development;
-
-  function requireUseSyncExternalStoreShim_development () {
-  	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
-  	hasRequiredUseSyncExternalStoreShim_development = 1;
-  	"production" !== process.env.NODE_ENV &&
-  	  (function () {
-  	    function is(x, y) {
-  	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
-  	    }
-  	    function useSyncExternalStore$2(subscribe, getSnapshot) {
-  	      didWarnOld18Alpha ||
-  	        void 0 === React$1.startTransition ||
-  	        ((didWarnOld18Alpha = true),
-  	        console.error(
-  	          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
-  	        ));
-  	      var value = getSnapshot();
-  	      if (!didWarnUncachedGetSnapshot) {
-  	        var cachedValue = getSnapshot();
-  	        objectIs(value, cachedValue) ||
-  	          (console.error(
-  	            "The result of getSnapshot should be cached to avoid an infinite loop"
-  	          ),
-  	          (didWarnUncachedGetSnapshot = true));
-  	      }
-  	      cachedValue = useState({
-  	        inst: { value: value, getSnapshot: getSnapshot }
-  	      });
-  	      var inst = cachedValue[0].inst,
-  	        forceUpdate = cachedValue[1];
-  	      useLayoutEffect(
-  	        function () {
-  	          inst.value = value;
-  	          inst.getSnapshot = getSnapshot;
-  	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	        },
-  	        [subscribe, value, getSnapshot]
-  	      );
-  	      useEffect(
-  	        function () {
-  	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	          return subscribe(function () {
-  	            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
-  	          });
-  	        },
-  	        [subscribe]
-  	      );
-  	      useDebugValue(value);
-  	      return value;
-  	    }
-  	    function checkIfSnapshotChanged(inst) {
-  	      var latestGetSnapshot = inst.getSnapshot;
-  	      inst = inst.value;
-  	      try {
-  	        var nextValue = latestGetSnapshot();
-  	        return !objectIs(inst, nextValue);
-  	      } catch (error) {
-  	        return true;
-  	      }
-  	    }
-  	    function useSyncExternalStore$1(subscribe, getSnapshot) {
-  	      return getSnapshot();
-  	    }
-  	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-  	      "function" ===
-  	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
-  	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-  	    var React$1 = React,
-  	      objectIs = "function" === typeof Object.is ? Object.is : is,
-  	      useState = React$1.useState,
-  	      useEffect = React$1.useEffect,
-  	      useLayoutEffect = React$1.useLayoutEffect,
-  	      useDebugValue = React$1.useDebugValue,
-  	      didWarnOld18Alpha = false,
-  	      didWarnUncachedGetSnapshot = false,
-  	      shim =
-  	        "undefined" === typeof window ||
-  	        "undefined" === typeof window.document ||
-  	        "undefined" === typeof window.document.createElement
-  	          ? useSyncExternalStore$1
-  	          : useSyncExternalStore$2;
-  	    useSyncExternalStoreShim_development.useSyncExternalStore =
-  	      void 0 !== React$1.useSyncExternalStore ? React$1.useSyncExternalStore : shim;
-  	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
-  	      "function" ===
-  	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
-  	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  	  })();
-  	return useSyncExternalStoreShim_development;
-  }
-
-  var hasRequiredShim;
-
-  function requireShim () {
-  	if (hasRequiredShim) return shim.exports;
-  	hasRequiredShim = 1;
-
-  	if (process.env.NODE_ENV === 'production') {
-  	  shim.exports = requireUseSyncExternalStoreShim_production();
-  	} else {
-  	  shim.exports = requireUseSyncExternalStoreShim_development();
-  	}
-  	return shim.exports;
+  function rulesToConstraintAttrs(rules) {
+    const attrs = {};
+    if (rules.required) attrs.required = true;
+    if (rules.min !== void 0) attrs.min = rules.min;
+    if (rules.max !== void 0) attrs.max = rules.max;
+    if (rules.minLength !== void 0) attrs.minLength = rules.minLength;
+    if (rules.maxLength !== void 0) attrs.maxLength = rules.maxLength;
+    if (rules.pattern) attrs.pattern = rules.pattern.value.source;
+    return attrs;
   }
 
-  var shimExports = requireShim();
-
   function isDescendant(key, ancestorKey) {
     return key.startsWith(`${ancestorKey.slice(0, -1)},`);
   }
@@ -1302,6 +1511,9 @@
       seededRef.current = { done: false, source: void 0 };
     React.useEffect(() => {
       if (initialValues === void 0) return;
+      if (typeof initialValues === "function" || isPromise(initialValues)) {
+        return;
+      }
       const seeded = seededRef.current;
       if (seeded.done && (seeded.source === initialValues || isEqual(seeded.source, initialValues))) {
         return;
@@ -1324,14 +1536,29 @@
       seeded.source = values;
       setInitialValues(form, values);
     }, [form, values]);
+    React.useEffect(() => {
+      if (!form.validateOnMount || !form.validate) return;
+      const run = () => {
+        void runFormValidate(form).catch(() => void 0);
+      };
+      if (!form.isLoading) {
+        run();
+        return;
+      }
+      return on(form.emitter, "loading", () => {
+        run();
+      });
+    }, [form]);
     return form;
   }
-  function useWatchCore(subscribeFactory, getter) {
+  function useWatchCore(subscribeFactory, getter, isEqual2) {
     const cacheRef = React.useRef(null);
     if (cacheRef.current === null) cacheRef.current = { hasValue: false };
     const cache = cacheRef.current;
     const getterRef = React.useRef(getter);
     getterRef.current = getter;
+    const isEqualRef = React.useRef(isEqual2);
+    isEqualRef.current = isEqual2;
     const getSnapshot = React.useCallback(() => {
       if (!cache.hasValue) {
         cache.value = getterRef.current();
@@ -1343,6 +1570,14 @@
       (notify) => {
         cache.hasValue = false;
         const invalidate = () => {
+          const compare = isEqualRef.current;
+          if (compare && cache.hasValue) {
+            const next = getterRef.current();
+            if (compare(cache.value, next)) return;
+            cache.value = next;
+            notify();
+            return;
+          }
           cache.hasValue = false;
           notify();
         };
@@ -1350,27 +1585,35 @@
       },
       [subscribeFactory, cache]
     );
-    return shimExports.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   }
-  function useWatch(emitter, event, getter) {
+  function useWatch(formOrEmitter, event, getter, isEqual2) {
+    const emitter = "emitter" in formOrEmitter ? formOrEmitter.emitter : formOrEmitter;
     const subscribeFactory = React.useCallback(
       (invalidate) => on(emitter, event, invalidate),
       [emitter, event]
     );
-    return useWatchCore(subscribeFactory, getter);
+    return useWatchCore(subscribeFactory, getter, isEqual2);
   }
-  function useValue(form, name) {
-    return useValueByPath(form, create$1(name));
+  function useValue(form, name, options) {
+    return useValueByPath(form, create$1(name), options);
   }
-  function useValueByPath(form, path) {
+  function useValueByPath(form, path, options) {
     const { emitter } = form;
     const { key } = path;
+    const scope = options?.exact === false ? "branch" : "leaf";
     const subscribeFactory = React.useCallback(
-      (invalidate) => onPathEvent(emitter, "change", path, "leaf", invalidate),
+      (invalidate) => onPathEvent(emitter, "change", path, scope, invalidate),
       // eslint-disable-next-line react-hooks/exhaustive-deps -- deps are `key` on purpose: useValue creates a fresh Path per render, so the object must stay out of the deps while the key string pins the subscription
-      [emitter, key]
+      [emitter, key, scope]
     );
-    return useWatchCore(subscribeFactory, getValueByPath.bind(null, form, path));
+    return useWatchCore(subscribeFactory, () => {
+      if (options?.exact === false) {
+        return get(getValues(form), path.value);
+      }
+      const value = getValueByPath(form, path);
+      return value === void 0 ? options?.defaultValue : value;
+    });
   }
   function useTouched(form, name) {
     return useTouchedByPath(form, create$1(name));
@@ -1415,19 +1658,88 @@
     );
   }
   function useIsDirty(form) {
-    return useWatch(form.emitter, "change", isDirty.bind(null, form));
+    return useWatch(form, "change", isDirty.bind(null, form));
+  }
+  function useIsFieldDirty(form, name) {
+    return useIsFieldDirtyByPath(form, create$1(name));
+  }
+  function useIsFieldDirtyByPath(form, path) {
+    const { emitter } = form;
+    const { key } = path;
+    const subscribeFactory = React.useCallback(
+      (invalidate) => onPathEvent(emitter, "change", path, "leaf", invalidate),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- same key-pinning convention as useValueByPath
+      [emitter, key]
+    );
+    return useWatchCore(subscribeFactory, () => isFieldDirtyByPath(form, path));
   }
   function useDirtyFields(form) {
-    return useWatch(form.emitter, "change", getDirtyFields.bind(null, form));
+    return useWatch(form, "change", getDirtyFields.bind(null, form));
   }
   function useTouchedFields(form) {
-    return useWatch(form.emitter, "touched", getTouchedFields.bind(null, form));
+    return useWatch(form, "touched", getTouchedFields.bind(null, form));
+  }
+  const FORM_STATE_EVENTS = [
+    "change",
+    "errors",
+    "touched",
+    "validating",
+    "submitting",
+    "submitCount",
+    "submitSuccessful",
+    "disabled",
+    "loading"
+  ];
+  function getFormState(form) {
+    return {
+      isDirty: isDirty(form),
+      dirtyFields: getDirtyFields(form),
+      isTouched: form.touched.size > 0,
+      touchedFields: getTouchedFields(form),
+      hasErrors: hasErrors(form),
+      isValid: !hasErrors(form),
+      isSubmitting: form.isSubmitting,
+      isSubmitted: form.isSubmitted,
+      isValidating: form.validating.size > 0,
+      isSubmitSuccessful: form.isSubmitSuccessful,
+      submitCount: form.submitCount,
+      isLoading: form.isLoading,
+      disabled: form.disabled
+    };
+  }
+  function isSameFormState(a, b) {
+    const sameTouched = a.touchedFields.length === b.touchedFields.length && a.touchedFields.every((path, i) => path === b.touchedFields[i]);
+    return a.isDirty === b.isDirty && a.dirtyFields === b.dirtyFields && a.isTouched === b.isTouched && sameTouched && a.hasErrors === b.hasErrors && a.isValid === b.isValid && a.isSubmitting === b.isSubmitting && a.isSubmitted === b.isSubmitted && a.isValidating === b.isValidating && a.isSubmitSuccessful === b.isSubmitSuccessful && a.submitCount === b.submitCount && a.isLoading === b.isLoading && a.disabled === b.disabled;
+  }
+  function useFormState(form) {
+    const getter = React.useCallback(() => getFormState(form), [form]);
+    const subscribeFactory = React.useCallback(
+      (invalidate) => {
+        const offs = FORM_STATE_EVENTS.map(
+          (event) => on(form.emitter, event, invalidate)
+        );
+        return () => {
+          for (const off of offs) off();
+        };
+      },
+      [form.emitter]
+    );
+    return useWatchCore(subscribeFactory, getter, isSameFormState);
   }
   function useHasErrors(form) {
-    return useWatch(form.emitter, "errors", hasErrors.bind(null, form));
+    return useWatch(form, "errors", hasErrors.bind(null, form));
+  }
+  function useIsValid(form) {
+    return useWatch(form, "errors", () => !hasErrors(form));
   }
   function useIsSubmitting(form) {
-    return useWatch(form.emitter, "submitting", () => form.isSubmitting);
+    return useWatch(form, "submitting", () => form.isSubmitting);
+  }
+  function useIsLoading(form) {
+    return useWatch(form, "loading", () => form.isLoading);
+  }
+  function useStatus(form) {
+    return useWatch(form, "status", () => form.status);
   }
   function useCanSubmit(form) {
     const { emitter } = form;
@@ -1448,7 +1760,23 @@
     );
   }
   function useSubmitCount(form) {
-    return useWatch(form.emitter, "submitCount", () => form.submitCount);
+    return useWatch(form, "submitCount", () => form.submitCount);
+  }
+  function useIsValidating(form) {
+    return useWatch(form, "validating", () => form.validating.size > 0);
+  }
+  function useIsSubmitSuccessful(form) {
+    return useWatch(
+      form.emitter,
+      "submitSuccessful",
+      () => !!form.isSubmitSuccessful
+    );
+  }
+  function useFormError(form) {
+    return useErrorByPath(form, create$1(FORM_ERROR))?.message;
+  }
+  function useFormErrors(form) {
+    return useFieldErrorsByPath(form, create$1(FORM_ERROR));
   }
 
   function usePath(name) {
@@ -1468,97 +1796,94 @@
       [ref]
     );
   }
+  function useUnmountRestore(teardown, restore) {
+    const removedRef = React.useRef(false);
+    React.useEffect(() => {
+      if (removedRef.current) {
+        removedRef.current = false;
+        restore();
+      }
+      return () => {
+        removedRef.current = true;
+        teardown();
+      };
+    }, []);
+  }
 
   function useValidate(validate, path, formProp, options) {
     const contextForm = React.useContext(FormContext);
     const form = formProp || contextForm;
     if (!form) throw new Error("no form provided");
-    const lockRef = React.useRef(null);
     const validateRef = React.useRef(validate);
     validateRef.current = validate;
     const debounceRef = React.useRef(options?.debounce ?? 0);
     debounceRef.current = options?.debounce ?? 0;
+    const syncRef = React.useRef(options?.sync);
+    syncRef.current = options?.sync;
+    const asyncAlwaysRef = React.useRef(options?.asyncAlways ?? false);
+    asyncAlwaysRef.current = options?.asyncAlways ?? false;
     React.useEffect(() => {
-      let timer = null;
-      let controller = null;
-      let marked = false;
-      const mark = () => {
-        if (marked) return;
-        marked = true;
-        setValidatingByPath(form, path);
-      };
-      const unmark = () => {
-        if (!marked) return;
-        marked = false;
-        unsetValidatingByPath(form, path);
+      const dispose = registerValidatorByPath(form, path, {
+        validate: () => validateRef.current,
+        debounce: () => debounceRef.current,
+        sync: () => syncRef.current,
+        asyncAlways: () => asyncAlwaysRef.current
+      });
+      const validateOnMount = options?.validateOnMount ?? form.validateOnMount;
+      if (!validateOnMount || !validateRef.current && !syncRef.current) {
+        return dispose;
+      }
+      let disposed = false;
+      const kick = () => {
+        if (disposed) return;
+        form.validators.get(path.key)?.();
       };
-      const run = () => {
-        timer = null;
-        const fn = validateRef.current;
-        if (!fn) {
-          unmark();
-          return;
-        }
-        controller?.abort();
-        controller = new AbortController();
-        const lock = lockRef.current = {};
-        let result;
-        try {
-          result = fn(getValueByPath(form, path), {
-            form,
-            path,
-            signal: controller.signal
-          });
-        } catch (e) {
-          unmark();
-          throw e;
-        }
-        if (!isPromise(result)) {
-          setErrorByPath(form, path, result);
-          unmark();
-          return;
-        }
-        mark();
-        result.then(
-          (error) => {
-            if (lock === lockRef.current) {
-              setErrorByPath(form, path, error);
-            }
-          }
-        ).catch(() => {
-        }).finally(() => {
-          if (lock === lockRef.current) {
-            unmark();
-            lockRef.current = null;
-          }
+      if (!form.isLoading) {
+        kick();
+      } else {
+        const off = on(form.emitter, "loading", () => {
+          off();
+          kick();
         });
-      };
-      const validator = () => {
-        const debounce = debounceRef.current;
-        if (debounce > 0) {
-          if (timer !== null) clearTimeout(timer);
-          else mark();
-          timer = setTimeout(run, debounce);
-          return;
-        }
-        run();
-      };
-      form.validators.set(path.key, validator);
+      }
       return () => {
-        form.validators.delete(path.key);
-        if (timer !== null) {
-          clearTimeout(timer);
-          timer = null;
-        }
-        unmark();
-        controller?.abort();
+        disposed = true;
+        dispose();
       };
     }, [form, path.key]);
     return useStageFn(() => form.validators.get(path.key)?.());
   }
 
+  function removeFieldForUnmount(form, path) {
+    const { key } = path;
+    const snapshot = {
+      present: form.values.has(key),
+      value: form.values.get(key),
+      touched: form.touched.has(key),
+      errors: form.errors.get(key)
+    };
+    removeFieldByPath(form, path);
+    return snapshot;
+  }
+  function restoreRemovedField(form, path, snapshot) {
+    const { key } = path;
+    if (snapshot.present) {
+      setValueByPath(form, path, snapshot.value, { shouldDirty: false });
+    } else {
+      form.deleted.delete(key);
+      bumpValuesVersion(form);
+      emit(form.emitter, "change", path);
+    }
+    if (snapshot.touched) setTouchedByPath(form, path);
+    if (snapshot.errors) setErrorByPath(form, path, snapshot.errors);
+  }
+
+  const uncontrolledSyncRegistry = /* @__PURE__ */ new WeakMap();
+  function hasRuleConstraints(rules) {
+    return rules.required !== void 0 || rules.min !== void 0 || rules.max !== void 0 || rules.minLength !== void 0 || rules.maxLength !== void 0 || rules.pattern !== void 0 || rules.validate !== void 0;
+  }
   function combineRulesAndValidate(rules, validate) {
-    if (!rules) return validate;
+    if (!rules || !hasRuleConstraints(rules)) return validate;
     const ruleValidator = rulesToValidator(rules);
     if (!validate) return ruleValidator;
     return (value, meta) => {
@@ -1590,6 +1915,25 @@
     }, [errors, delay, shown]);
     return delay === void 0 ? errors : shown;
   }
+  function useFieldValue(form, path, uncontrolled) {
+    const snapshotRef = React.useRef({
+      has: false,
+      value: void 0
+    });
+    const getter = React.useCallback(() => {
+      if (!uncontrolled) return getValueByPath(form, path);
+      if (!snapshotRef.current.has) {
+        snapshotRef.current = { has: true, value: getValueByPath(form, path) };
+      }
+      return snapshotRef.current.value;
+    }, [uncontrolled, form, path]);
+    const subscribeFactory = React.useCallback(
+      (invalidate) => uncontrolled ? () => {
+      } : onPathEvent(form.emitter, "change", path, "leaf", invalidate),
+      [uncontrolled, form.emitter, path]
+    );
+    return useWatchCore(subscribeFactory, getter);
+  }
   function useFieldCore({
     form: f1,
     name,
@@ -1599,8 +1943,11 @@
     rules,
     validateDebounce,
     validateDeps,
+    validateOnMount,
     delayError,
     disabled,
+    uncontrolled,
+    asyncAlways,
     mode: modeOption
   }, Context) {
     const contextForm = React.useContext(Context);
@@ -1618,35 +1965,41 @@
       seededRef.current = false;
       emitChangeByPath(form, path);
     });
-    const validator = useValidate(
-      combineRulesAndValidate(rules, validate),
-      path,
-      form,
-      {
-        debounce: validateDebounce
-      }
-    );
+    const restRules = rules ? { ...rules, required: void 0 } : void 0;
+    useValidate(combineRulesAndValidate(restRules, validate), path, form, {
+      debounce: validateDebounce,
+      validateOnMount,
+      asyncAlways: asyncAlways ?? form.asyncAlways,
+      sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0
+    });
     const liveErrors = useFieldErrorsByPath(form, path);
     const errors = useDelayedErrors(liveErrors, delayError);
     const errorObject = errors[0];
     const error = errorObject?.message;
-    const value = useValueByPath(form, path);
-    const formDisabled = useWatch(form.emitter, "disabled", () => form.disabled);
-    const mode = modeOption ?? form.mode;
-    const onChange = useStageFn((v) => {
-      setValueByPath(form, path, v);
-      if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || liveErrors.length > 0 && form.reValidateMode === "onChange")
-        validator();
-      revalidateFormOnChange(form, path, mode);
-      revalidateDependentsOnChange(form, path, mode);
-    });
+    const value = useFieldValue(form, path, !!uncontrolled);
+    const isDirty = useWatchCore(
+      React.useCallback(
+        (invalidate) => uncontrolled ? () => {
+        } : onPathEvent(form.emitter, "change", path, "leaf", invalidate),
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- usePath memoizes the Path per key, so key pins the subscription like every path-scoped hook
+        [form.emitter, path.key, uncontrolled]
+      ),
+      () => isFieldDirtyByPath(form, path)
+    );
+    const validating = useWatchCore(
+      React.useCallback(
+        (invalidate) => onKeyEvent(form.emitter, "validating", path.key, invalidate),
+        [form.emitter, path.key]
+      ),
+      () => form.validating.has(path.key)
+    );
+    const formDisabled = useWatch(form, "disabled", () => form.disabled);
+    const onChange = useStageFn((v) => userChangeByPath(form, path, v));
+    const onBlur = useStageFn(() => userBlur(form, path));
     React.useEffect(() => {
-      form.changeHandlers.set(path.key, onChange);
-      return () => {
-        if (form.changeHandlers.get(path.key) === onChange)
-          form.changeHandlers.delete(path.key);
-      };
-    }, [form, path.key, onChange]);
+      const { token, displaced } = registerFieldMode(form, path, modeOption);
+      return () => unregisterFieldMode(form, path, token);
+    }, [form, path.key, modeOption]);
     const depsKey = validateDeps?.length ? validateDeps.join("\n") : void 0;
     React.useEffect(() => {
       if (!depsKey) return;
@@ -1654,29 +2007,77 @@
       registerFieldValidateDeps(form, path.key, depKeys);
       return () => unregisterFieldValidateDeps(form, path.key, depKeys);
     }, [form, path.key, depsKey]);
-    const onBlur = useStageFn(() => {
-      setTouchedByPath(form, path);
-      if (mode === "onBlur" || mode === "onTouched" || mode === "all" || liveErrors.length > 0 && form.reValidateMode === "onBlur")
-        validator();
-    });
+    const elementRef = React.useRef(null);
+    const focusRef = React.useCallback((el) => {
+      elementRef.current = el;
+    }, []);
     React.useEffect(
-      () => () => {
-        if (shouldUnregister !== false) {
-          removeFieldByPath(form, path);
+      () => on(
+        form.emitter,
+        "focusError",
+        (key, options) => {
+          if (key !== path.key) return;
+          const el = elementRef.current;
+          if (!el || typeof el.focus !== "function") return;
+          el.focus();
+          if (options?.shouldSelect && typeof el.select === "function") {
+            el.select();
+          }
         }
-      },
-      [path, form, shouldUnregister]
+      ),
+      [form, path.key]
     );
+    React.useEffect(() => {
+      if (!uncontrolled) return;
+      let entry = uncontrolledSyncRegistry.get(form);
+      if (!entry) {
+        const cells = /* @__PURE__ */ new Map();
+        const off = on(form.emitter, "change", (changed) => {
+          if (changed) return;
+          for (const read of cells.values()) {
+            const { el, path: path2 } = read();
+            if (!el || el.type === "file") continue;
+            const next = getValueByPath(form, path2);
+            const asString = next == null ? "" : String(next);
+            if (el.value !== asString) el.value = asString;
+          }
+        });
+        entry = { cells, off };
+        uncontrolledSyncRegistry.set(form, entry);
+      }
+      entry.cells.set(path.key, () => ({ el: elementRef.current, path }));
+      return () => {
+        entry.cells.delete(path.key);
+        if (entry.cells.size === 0) {
+          entry.off();
+          uncontrolledSyncRegistry.delete(form);
+        }
+      };
+    }, [form, path.key, uncontrolled]);
+    const removalSnapshotRef = React.useRef(null);
+    const teardownOnUnmount = useStageFn(() => {
+      if ((shouldUnregister ?? form.shouldUnregister) === false) return;
+      removalSnapshotRef.current = removeFieldForUnmount(form, path);
+    });
+    const restoreAfterStrictMode = useStageFn(() => {
+      const snapshot = removalSnapshotRef.current;
+      removalSnapshotRef.current = null;
+      if (snapshot) restoreRemovedField(form, path, snapshot);
+    });
+    useUnmountRestore(teardownOnUnmount, restoreAfterStrictMode);
     return {
       form,
       value,
       error,
       errorObject,
       errors,
+      isDirty,
+      validating,
       onChange,
       onBlur,
       name: path.key,
-      disabled: formDisabled || !!disabled
+      disabled: formDisabled || !!disabled,
+      focusRef
     };
   }
   function useField(options) {
@@ -1708,6 +2109,8 @@
     const contextForm = React.useContext(Context);
     const form = options.form || contextForm;
     if (!form) throw new Error("no form provided");
+    const keyName = options.keyName ?? "id";
+    const { rules, shouldUnregister } = options;
     const path = usePath(options.name);
     const idsRef = React.useRef([]);
     const getArray = React.useCallback(
@@ -1728,8 +2131,12 @@
       while (idsRef.current.length > arr.length) {
         idsRef.current.pop();
       }
-      return idsRef.current.map((id, index) => ({ id, index }));
-    }, [getArray, form]);
+      return idsRef.current.map((id, index) => ({
+        id,
+        index,
+        [keyName]: id
+      }));
+    }, [getArray, form, keyName]);
     const [fields, syncFields] = React.useReducer(
       computeFields,
       void 0,
@@ -1747,6 +2154,25 @@
         if (registry?.get(path.key) === idsRef.current) registry.delete(path.key);
       };
     }, [form, path.key]);
+    const removalSnapshotRef = React.useRef(null);
+    const teardownOnUnmount = useStageFn(() => {
+      if ((shouldUnregister ?? form.shouldUnregister) === false) return;
+      removalSnapshotRef.current = removeFieldForUnmount(form, path);
+    });
+    const restoreAfterStrictMode = useStageFn(() => {
+      const snapshot = removalSnapshotRef.current;
+      removalSnapshotRef.current = null;
+      if (snapshot) restoreRemovedField(form, path, snapshot);
+    });
+    useUnmountRestore(teardownOnUnmount, restoreAfterStrictMode);
+    useValidate(
+      rules ? rulesToValidator({ ...rules, required: void 0 }) : void 0,
+      path,
+      form,
+      {
+        sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0
+      }
+    );
     const append = useStageFn((value) => {
       const arr = getArray();
       idsRef.current.push(generateId(form));
@@ -1905,29 +2331,108 @@
     return group;
   }
 
+  function useTransform(form, name, options = {}) {
+    const path = usePath(name);
+    const { toDisplay, fromDisplay } = options;
+    const subscribeFactory = React.useCallback(
+      (invalidate) => onPathEvent(form.emitter, "change", path, "leaf", invalidate),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- usePath memoizes the Path per key, so key pins the subscription like every path-scoped hook
+      [form.emitter, path.key]
+    );
+    const raw = useWatchCore(subscribeFactory, () => getValueByPath(form, path));
+    const value = toDisplay ? toDisplay(raw) : raw;
+    const onChange = React.useCallback(
+      (display) => {
+        userChangeByPath(
+          form,
+          path,
+          fromDisplay ? fromDisplay(display) : display
+        );
+      },
+      [form, path, fromDisplay]
+    );
+    return { value, onChange };
+  }
+
+  function appendFormDataValue(fd, key, value) {
+    if (value == null) return;
+    if (Array.isArray(value)) {
+      for (const item of value) appendFormDataValue(fd, key, item);
+      return;
+    }
+    if (typeof FileList !== "undefined" && value instanceof FileList) {
+      for (let i = 0; i < value.length; i++) fd.append(key, value.item(i));
+      return;
+    }
+    if (typeof File !== "undefined" && value instanceof File) {
+      fd.append(key, value, value.name);
+      return;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+      fd.append(key, value);
+      return;
+    }
+    if (value instanceof Date) {
+      fd.append(key, value.toISOString());
+      return;
+    }
+    fd.append(
+      key,
+      typeof value === "object" ? JSON.stringify(value) : String(value)
+    );
+  }
+  function formDataFromValues(values) {
+    const fd = new FormData();
+    for (const key of Object.keys(values)) {
+      appendFormDataValue(fd, key, values[key]);
+    }
+    return fd;
+  }
+
   function Form({
     form: f1,
     context,
     initialValues,
     values,
+    shouldUnregister,
+    validateOnMount,
+    disabled,
+    asyncAlways,
     onSubmit,
     onValidSubmit,
     onInvalidSubmit,
+    action,
     shouldFocusError,
     ...props
   }) {
-    const f2 = useForm({ initialValues, values });
+    const f2 = useForm({
+      initialValues,
+      values,
+      shouldUnregister,
+      validateOnMount,
+      disabled,
+      asyncAlways
+    });
     const form = f1 || f2;
+    React__namespace.useEffect(() => {
+      if (disabled !== void 0) setDisabled(form, disabled);
+    }, [form, disabled]);
     const submit = handleSubmit(form, {
       onSubmit,
       onValidSubmit,
       onInvalidSubmit,
-      shouldFocusError
+      shouldFocusError,
+      onAction: action ? (values2) => action(formDataFromValues(values2)) : void 0
     });
     const { Provider } = context ?? FormContext;
     return /* @__PURE__ */ React__namespace.createElement(Provider, { value: form }, /* @__PURE__ */ React__namespace.createElement("form", { ...props, noValidate: true, onSubmit: submit }));
   }
 
+  function FormField({ children, ...options }) {
+    const field = useField(options);
+    return children(field);
+  }
+
   function setRef(ref, value) {
     if (typeof ref === "function") {
       ref(value);
@@ -1962,28 +2467,26 @@
       shouldUnregister,
       rules,
       validateDebounce,
+      validateOnMount,
+      valueAsNumber,
+      valueAsDate,
+      asyncAlways,
       disabled,
       delayError,
       mode,
+      uncontrolled,
       ...props
     }, ref) => {
       const innerRef = React__namespace.useRef(null);
       const [nativeInvalidCount, setNativeInvalidCount] = React__namespace.useState(0);
-      const mergedRef = React__namespace.useCallback(
-        (node) => {
-          innerRef.current = node;
-          setRef(ref, node);
-        },
-        [ref]
-      );
       const {
         value,
         onChange,
         onBlur,
         error,
-        form,
         name: fieldKey,
-        disabled: isDisabled
+        disabled: isDisabled,
+        focusRef
       } = useField({
         name,
         form: formProp,
@@ -1991,9 +2494,14 @@
         shouldUnregister,
         rules,
         validateDebounce,
+        validateOnMount,
         delayError,
         disabled,
+        asyncAlways,
         mode,
+        // File inputs cannot be value-controlled at all — force the
+        // uncontrolled path so no `value` prop ever reaches the element.
+        uncontrolled: uncontrolled || props.type === "file",
         validate: (...params) => {
           const el = innerRef.current;
           if (el && typeof el.checkValidity === "function") {
@@ -2006,6 +2514,14 @@
           if (validate) return validate(...params);
         }
       });
+      const mergedRef = React__namespace.useCallback(
+        (node) => {
+          innerRef.current = node;
+          focusRef(node);
+          setRef(ref, node);
+        },
+        [ref, focusRef]
+      );
       const Component = as || "input";
       React__namespace.useEffect(() => {
         const el = innerRef.current;
@@ -2020,32 +2536,20 @@
       React__namespace.useEffect(() => {
         if (nativeInvalidCount > 0) innerRef.current?.reportValidity();
       }, [nativeInvalidCount]);
-      React__namespace.useEffect(
-        () => on(
-          form.emitter,
-          "focusError",
-          (key, options) => {
-            if (key !== fieldKey) return;
-            const el = innerRef.current;
-            if (!el || typeof el.focus !== "function") return;
-            el.focus();
-            if (options?.shouldSelect && typeof el.select === "function") {
-              el.select();
-            }
-          }
-        ),
-        [form, fieldKey]
-      );
-      const toValue = eventToValue ?? ((e) => e.target.value);
+      const isFile = props.type === "file";
+      const toValue = eventToValue ?? (isFile ? (e) => e.target.files : valueAsNumber ? (e) => e.target.valueAsNumber : valueAsDate ? (e) => e.target.valueAsDate : (e) => e.target.value);
+      const valueProps = valueToProps ? valueToProps(value) : isFile ? {} : uncontrolled ? { defaultValue: value } : { value };
       const errorId = errorIdFromKey(fieldKey);
+      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
       return /* @__PURE__ */ React__namespace.createElement(React__namespace.Fragment, null, /* @__PURE__ */ React__namespace.createElement(
         Component,
         {
+          ...constraintAttrs,
           ...props,
           name: fieldKey,
           onBlur,
           ...asProps,
-          ...valueToProps ? valueToProps(value) : { value },
+          ...valueProps,
           ...ariaProps(error, fieldKey, props),
           disabled: isDisabled,
           onChange: (e) => onChange(toValue(e)),
@@ -2063,6 +2567,8 @@
       validate,
       rules,
       validateDebounce,
+      validateOnMount,
+      asyncAlways,
       disabled,
       delayError,
       mode,
@@ -2083,13 +2589,17 @@
         validate,
         rules,
         validateDebounce,
+        validateOnMount,
+        asyncAlways,
         delayError,
         disabled,
         mode
       });
+      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
       return /* @__PURE__ */ React__namespace.createElement(
         "input",
         {
+          ...constraintAttrs,
           ...props,
           name: fieldKey,
           onBlur,
@@ -2118,6 +2628,8 @@
       validate,
       rules,
       validateDebounce,
+      validateOnMount,
+      asyncAlways,
       disabled,
       delayError,
       mode,
@@ -2138,13 +2650,17 @@
         validate,
         rules,
         validateDebounce,
+        validateOnMount,
+        asyncAlways,
         delayError,
         disabled,
         mode
       });
+      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
       return /* @__PURE__ */ React__namespace.createElement(
         "select",
         {
+          ...constraintAttrs,
           ...props,
           name: fieldKey,
           onBlur,
@@ -2165,9 +2681,11 @@
   exports.Checkbox = Checkbox;
   exports.CheckboxGroupContext = CheckboxGroupContext;
   exports.CheckboxGroupProvider = CheckboxGroupProvider;
+  exports.FORM_ERROR = FORM_ERROR;
   exports.Field = Field;
   exports.Form = Form;
   exports.FormContext = FormContext;
+  exports.FormField = FormField;
   exports.FormProvider = FormProvider;
   exports.Select = Select;
   exports.VALIDATION_OUTCOME = VALIDATION_OUTCOME;
@@ -2197,14 +2715,18 @@
   exports.hasTouchedByPath = hasTouchedByPath;
   exports.incrementSubmitCount = incrementSubmitCount;
   exports.isDirty = isDirty;
+  exports.isFieldDirtyByPath = isFieldDirtyByPath;
   exports.isTouched = isTouched;
+  exports.registerFieldMode = registerFieldMode;
   exports.registerFieldValidateDeps = registerFieldValidateDeps;
+  exports.registerValidatorByPath = registerValidatorByPath;
   exports.removeField = removeField;
   exports.removeFieldByPath = removeFieldByPath;
   exports.reset = reset;
   exports.resetField = resetField;
   exports.revalidateDependentsOnChange = revalidateDependentsOnChange;
   exports.revalidateFormOnChange = revalidateFormOnChange;
+  exports.runFormValidate = runFormValidate;
   exports.seedValueByPath = seedValueByPath;
   exports.setDisabled = setDisabled;
   exports.setError = setError;
@@ -2213,6 +2735,7 @@
   exports.setInitialValues = setInitialValues;
   exports.setIsSubmitting = setIsSubmitting;
   exports.setServerErrors = setServerErrors;
+  exports.setStatus = setStatus;
   exports.setSubmitSuccessful = setSubmitSuccessful;
   exports.setTouched = setTouched;
   exports.setTouchedByPath = setTouchedByPath;
@@ -2221,6 +2744,7 @@
   exports.setValueByPath = setValueByPath;
   exports.subscribe = subscribe;
   exports.trigger = trigger;
+  exports.unregisterFieldMode = unregisterFieldMode;
   exports.unregisterFieldValidateDeps = unregisterFieldValidateDeps;
   exports.unsetValidatingByPath = unsetValidatingByPath;
   exports.useCanSubmit = useCanSubmit;
@@ -2235,16 +2759,30 @@
   exports.useFieldErrorsByPath = useFieldErrorsByPath;
   exports.useForm = useForm;
   exports.useFormContext = useFormContext;
+  exports.useFormError = useFormError;
+  exports.useFormErrors = useFormErrors;
+  exports.useFormState = useFormState;
   exports.useHasErrors = useHasErrors;
   exports.useIsDirty = useIsDirty;
+  exports.useIsFieldDirty = useIsFieldDirty;
+  exports.useIsFieldDirtyByPath = useIsFieldDirtyByPath;
+  exports.useIsLoading = useIsLoading;
+  exports.useIsSubmitSuccessful = useIsSubmitSuccessful;
   exports.useIsSubmitting = useIsSubmitting;
+  exports.useIsValid = useIsValid;
+  exports.useIsValidating = useIsValidating;
+  exports.useStatus = useStatus;
   exports.useSubmitCount = useSubmitCount;
   exports.useTouched = useTouched;
   exports.useTouchedByPath = useTouchedByPath;
   exports.useTouchedFields = useTouchedFields;
+  exports.useTransform = useTransform;
   exports.useValue = useValue;
   exports.useValueByPath = useValueByPath;
   exports.useWatch = useWatch;
+  exports.useWatchCore = useWatchCore;
+  exports.userBlur = userBlur;
+  exports.userChangeByPath = userChangeByPath;
   exports.validate = validate;
 
 }));