react-f0rm 1.4.0 → 1.5.0

package/dist/index.umd.js

@@ -266,12 +266,31 @@
     delete copy[prop];
     return copy;
   }
+  function arraySlot(container, prop) {
+    if (typeof prop === "number") return prop;
+    if (Array.isArray(container) && typeof prop === "string" && isIndex(prop)) {
+      return Number(prop);
+    }
+    return void 0;
+  }
+  function copyForProp(container, prop) {
+    if (arraySlot(container, prop) !== void 0) {
+      return Array.isArray(container) ? container.slice() : [];
+    }
+    return { ...container };
+  }
+  function ensureOwned(container, prop, owned) {
+    if (owned.has(container)) return container;
+    const copy = copyForProp(container, prop);
+    owned.add(copy);
+    return copy;
+  }
   function set(values, path, value) {
     if (!path.length) return value;
     const [prop, ...props] = path;
-    const index = typeof prop === "number" ? prop : Array.isArray(values) && typeof prop === "string" && isIndex(prop) ? Number(prop) : void 0;
+    const index = arraySlot(values, prop);
     if (index !== void 0) {
-      const arr = Array.isArray(values) ? values.slice() : [];
+      const arr = copyForProp(values, prop);
       arr[index] = set(arr[index], props, value);
       return arr;
     }
@@ -284,14 +303,8 @@
     let parentProp = "";
     for (let i = 0; i < path.length; i++) {
       const prop = path[i];
-      if (!owned.has(container)) {
-        let copy;
-        if (typeof prop === "number" || Array.isArray(container) && typeof prop === "string" && isIndex(prop)) {
-          copy = Array.isArray(container) ? container.slice() : [];
-        } else {
-          copy = { ...container };
-        }
-        owned.add(copy);
+      const copy = ensureOwned(container, prop, owned);
+      if (copy !== container) {
         if (i === 0) root = copy;
         else parent[parentProp] = copy;
         container = copy;
@@ -318,6 +331,9 @@
     if (options?.valueAsDate) return target.valueAsDate;
     return target.value;
   }
+  function eventToValueOrDefault(eventToValue, options) {
+    return eventToValue ?? ((e) => extractEventValue(e, options));
+  }
   function isEqual(a, b) {
     if (Object.is(a, b)) return true;
     if (a instanceof Date && b instanceof Date)
@@ -364,16 +380,27 @@
     const value = normalizePath(name);
     return { value, key: JSON.stringify(value) };
   }
+  function segmentsFromKey(key) {
+    return JSON.parse(key);
+  }
 
+  function getOrCreate(map, form, create) {
+    if (map.has(form)) return map.get(form);
+    const value = create();
+    map.set(form, value);
+    return value;
+  }
   const valuesCaches = /* @__PURE__ */ new WeakMap();
-  function bumpValuesVersion(form) {
-    const cache = valuesCaches.get(form);
+  function bumpVersion(map, form) {
+    const cache = map.get(form);
     if (cache) cache.version++;
   }
+  function bumpValuesVersion(form) {
+    bumpVersion(valuesCaches, form);
+  }
   const errorsCaches = /* @__PURE__ */ new WeakMap();
   function bumpErrorsVersion(form) {
-    const cache = errorsCaches.get(form);
-    if (cache) cache.version++;
+    bumpVersion(errorsCaches, form);
   }
   const dirtyBaselines = /* @__PURE__ */ new WeakMap();
   function getDirtyBaseline(form, key, segments) {
@@ -382,12 +409,7 @@
     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);
+    getOrCreate(dirtyBaselines, form, () => /* @__PURE__ */ new Map()).set(key, value);
   }
   function pruneDirtyBaselines(form, { key }) {
     const baselines = dirtyBaselines.get(form);
@@ -405,8 +427,7 @@
   }
   const dirtyFieldsCaches = /* @__PURE__ */ new WeakMap();
   function bumpDirtyVersion(form) {
-    const cache = dirtyFieldsCaches.get(form);
-    if (cache) cache.version++;
+    bumpVersion(dirtyFieldsCaches, form);
   }
   function isSegmentsPath(name) {
     return name.some((part) => typeof part === "number");
@@ -439,18 +460,18 @@
   function getErrors({ errors }) {
     const entries = [];
     for (const [key, list] of errors) {
-      const path = JSON.parse(key).join(".");
+      const path = segmentsFromKey(key).join(".");
       for (const { type, message } of list) entries.push({ path, type, message });
     }
     return entries;
   }
   function computeErrorsViews(form) {
     const cached = errorsCaches.get(form);
-    if (cached && cached.version === 0) return;
+    if (cached?.version === 0) return;
     const result = {};
     const tree = {};
     for (const [key, list] of form.errors) {
-      const segments = JSON.parse(key);
+      const segments = segmentsFromKey(key);
       result[segments.join(".")] = list;
       let node = tree;
       for (let i = 0; i < segments.length - 1; i++) {
@@ -546,21 +567,17 @@
     }
   }
   function clearServerErrors(form) {
-    let changed = false;
-    for (const [key, errors] of form.errors) {
-      const kept = errors.filter((error) => error.type !== "server");
-      if (kept.length === 0) {
-        form.errors.delete(key);
-        changed = true;
-      } else if (kept.length !== errors.length) {
-        form.errors.set(key, kept);
-        changed = true;
-      }
-    }
-    if (changed) {
-      bumpErrorsVersion(form);
-      emit(form.emitter, "errors");
+    const affected = Array.from(form.errors).filter(
+      ([, list]) => list.some((error) => error.type === "server")
+    );
+    if (affected.length === 0) return;
+    for (const [key, list] of affected) {
+      const kept = list.filter((error) => error.type !== "server");
+      if (kept.length) form.errors.set(key, kept);
+      else form.errors.delete(key);
     }
+    bumpErrorsVersion(form);
+    emit(form.emitter, "errors");
   }
   function hasErrors({ errors }) {
     return errors.size > 0;
@@ -603,22 +620,18 @@
     };
   }
   function toPathSegments(issue) {
-    const path = issue.path || [];
-    const segments = [];
-    for (const segment of path) {
-      const key = typeof segment === "object" && segment !== null ? segment.key : segment;
-      segments.push(String(key));
-    }
-    return segments;
+    return (issue.path || []).map(
+      (segment) => String(
+        typeof segment === "object" && segment !== null ? segment.key : segment
+      )
+    );
   }
   function assignAtPath(root, segments, error) {
     let node = root;
     for (let i = 0; i < segments.length - 1; i++) {
       const segment = segments[i];
-      let next = node[segment];
-      if (next === void 0) {
-        next = node[segment] = {};
-      }
+      if (node[segment] === void 0) node[segment] = {};
+      const next = node[segment];
       if (!isBranch(next)) return;
       node = next;
     }
@@ -631,21 +644,16 @@
     return !!value && typeof value === "object" && !Array.isArray(value);
   }
   function pruneEmpty(node) {
-    let hasLeaf = false;
     const result = {};
-    Object.entries(node).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(node)) {
       if (isBranch(value)) {
         const pruned = pruneEmpty(value);
-        if (pruned) {
-          result[key] = pruned;
-          hasLeaf = true;
-        }
+        if (pruned) result[key] = pruned;
       } else {
         result[key] = value;
-        hasLeaf = true;
       }
-    });
-    return hasLeaf ? result : void 0;
+    }
+    return Object.keys(result).length ? result : void 0;
   }
 
   function isFieldDirtyByPath(form, path) {
@@ -653,15 +661,15 @@
     return form.values.has(path.key) && getDirtyBaseline(form, path.key, path.value) !== live;
   }
   function isDirty(form) {
-    let dirty = false;
-    forEachDirtyField(form, () => {
-      dirty = true;
-    });
-    return dirty;
+    for (const [key, value] of form.values) {
+      const path = segmentsFromKey(key);
+      if (getDirtyBaseline(form, key, path) !== value) return true;
+    }
+    return false;
   }
   function forEachDirtyField(form, fn) {
     for (const [key, value] of form.values) {
-      const path = JSON.parse(key);
+      const path = segmentsFromKey(key);
       if (getDirtyBaseline(form, key, path) !== value) fn(path.join("."));
     }
   }
@@ -678,11 +686,11 @@
     return aKeys.every((key) => b[key] === true);
   }
   function getDirtyFields(form) {
-    let cache = dirtyFieldsCaches.get(form);
-    if (!cache) {
-      cache = { version: 0, result: computeDirtyFields(form) };
-      dirtyFieldsCaches.set(form, cache);
-    } else if (cache.version > 0) {
+    const cache = getOrCreate(dirtyFieldsCaches, form, () => ({
+      version: 0,
+      result: computeDirtyFields(form)
+    }));
+    if (cache.version > 0) {
       const result = computeDirtyFields(form);
       if (!sameDirtyKeys(cache.result, result)) cache.result = result;
       cache.version = 0;
@@ -705,21 +713,18 @@
     return touched.has(path.key);
   }
   function getTouchedFields({ touched }) {
-    return Array.from(
-      touched,
-      (key) => JSON.parse(key).join(".")
-    );
+    return Array.from(touched, (key) => segmentsFromKey(key).join("."));
   }
   function isTouched({ touched }) {
     return touched.size > 0;
   }
 
   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) {
+    const cache = getOrCreate(valuesCaches, form, () => ({
+      version: 0,
+      result: computeValues(form)
+    }));
+    if (cache.version > 0) {
       cache.result = computeValues(form);
       cache.version = 0;
     }
@@ -730,10 +735,10 @@
     const owned = /* @__PURE__ */ new Set();
     let merged = parsedValues ?? initialValues;
     for (const [key, value] of values) {
-      merged = setOwned(merged, JSON.parse(key), value, owned);
+      merged = setOwned(merged, segmentsFromKey(key), value, owned);
     }
     for (const key of deleted) {
-      merged = unset(merged, JSON.parse(key));
+      merged = unset(merged, segmentsFromKey(key));
     }
     return merged;
   }
@@ -857,9 +862,9 @@
   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);
-        }
+        node.forEach(
+          (item, i) => collectValueLeaves(item, [...segments, i], out)
+        );
         return;
       }
       const keys = Object.keys(node);
@@ -872,18 +877,22 @@
     }
     out.push({ segments, value: node });
   }
-  function reset(form, initialValues, options) {
-    const keptValues = [];
+  function collectKeptValues(form, options) {
+    const kept = [];
     if (options?.keepValues) {
-      collectValueLeaves(getValues(form), [], keptValues);
+      collectValueLeaves(getValues(form), [], kept);
     } else if (options?.keepDirtyValues) {
       for (const [key, value] of form.values) {
-        const segments = JSON.parse(key);
+        const segments = segmentsFromKey(key);
         if (getDirtyBaseline(form, key, segments) !== value) {
-          keptValues.push({ segments, value });
+          kept.push({ segments, value });
         }
       }
     }
+    return kept;
+  }
+  function reset(form, initialValues, options) {
+    const keptValues = collectKeptValues(form, options);
     form.initialValues = options?.keepDefaultValues ? form.initialValues : initialValues ?? form.initialValues;
     form.parsedValues = void 0;
     if (!options?.keepErrors) clearErrors(form);
@@ -944,13 +953,17 @@
     validating.add(path.key);
     emit(emitter, "validating", path);
   }
+  function asErrorList(output) {
+    if (output === void 0) return null;
+    const list = Array.isArray(output) ? output : [output];
+    return list.length ? list : null;
+  }
   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;
@@ -964,44 +977,42 @@
     const runSync = () => {
       const sync = registration.sync();
       if (!sync) return false;
-      const errors = sync(getValueByPath(form, path), { form, path });
-      if (!hasErrors2(errors)) {
+      const gate = asErrorList(sync(getValueByPath(form, path), { form, path }));
+      if (!gate) {
         if (!registration.validate() || errorSource === "sync") {
           setErrorByPath(form, path, void 0);
           errorSource = null;
         }
         return false;
       }
-      setErrorByPath(form, path, errors);
+      setErrorByPath(form, path, gate);
       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;
+      return asErrorList(sync(getValueByPath(form, path), { form, path }));
     };
     const land = (result) => {
       if (registration.asyncAlways?.()) {
         const gate = collectSyncErrors();
-        const own = result === void 0 ? [] : Array.isArray(result) ? result : [result];
+        const own = asErrorList(result) ?? [];
         setErrorByPath(form, path, [...gate ?? [], ...own]);
-        errorSource = hasErrors2(result) ? "validator" : gate ? "sync" : null;
+        errorSource = own.length ? "validator" : gate ? "sync" : null;
       } else {
         setErrorByPath(form, path, result);
-        errorSource = hasErrors2(result) ? "validator" : null;
+        errorSource = asErrorList(result) ? "validator" : null;
       }
     };
-    const supersede = () => {
+    const cancel = () => {
       if (timer !== null) {
         clearTimeout(timer);
         timer = null;
       }
       controller?.abort();
       lock = {};
+      unmark();
     };
     const runValidator = () => {
       const fn = registration.validate();
@@ -1029,13 +1040,11 @@
         return;
       }
       mark();
-      result.then(
-        (error) => {
-          if (lock === round) {
-            land(error);
-          }
+      result.then((error) => {
+        if (lock === round) {
+          land(error);
         }
-      ).catch(() => {
+      }).catch(() => {
       }).finally(() => {
         if (lock === round) {
           unmark();
@@ -1043,21 +1052,18 @@
         }
       });
     };
+    const gateOwnsKick = () => {
+      if (!(runSync() && !registration.asyncAlways?.())) return false;
+      cancel();
+      return true;
+    };
     const run = () => {
       timer = null;
-      if (runSync() && !registration.asyncAlways?.()) {
-        supersede();
-        unmark();
-        return;
-      }
+      if (gateOwnsKick()) return;
       runValidator();
     };
     const kick = () => {
-      if (runSync() && !registration.asyncAlways?.()) {
-        supersede();
-        unmark();
-        return;
-      }
+      if (gateOwnsKick()) return;
       if (!registration.validate()) return;
       const debounce = registration.debounce();
       if (debounce > 0) {
@@ -1071,12 +1077,7 @@
     form.validators.set(path.key, kick);
     return () => {
       form.validators.delete(path.key);
-      if (timer !== null) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      unmark();
-      controller?.abort();
+      cancel();
     };
   }
   async function trigger(form, name, options) {
@@ -1086,29 +1087,27 @@
       () => keys2 === void 0 ? fieldsSettled(form) : keys2.every((key) => !form.validating.has(key)),
       () => false
     );
+    const focusFirstError = (keys2) => {
+      const firstKey = keys2 === void 0 ? form.errors.keys().next().value : keys2.find((key) => form.errors.has(key));
+      if (firstKey !== void 0) emit(form.emitter, "focusError", firstKey);
+    };
     if (name === void 0) {
       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);
-      }
+      if (options?.shouldFocus) focusFirstError();
       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);
-    }
+    if (options?.shouldFocus) focusFirstError(keys);
     return keys.every((key) => !form.errors.has(key));
   }
   function touchKeys(form, keys) {
-    keys.forEach((key) => setTouchedByPath(form, create$1(JSON.parse(key))));
+    keys.forEach((key) => setTouchedByPath(form, create$1(segmentsFromKey(key))));
   }
   function setFormErrors(form, result, segments = [], footprint) {
     Object.entries(result).forEach(([key, value]) => {
@@ -1117,16 +1116,9 @@
         ...isIndex(key) ? [key] : normalizePath(key)
       ];
       if (typeof value === "string") {
-        if (value) {
-          setError(form, path, value);
-          recordFootprint(form, path, footprint);
-        }
-      } else if (Array.isArray(value)) {
-        setError(form, path, value);
-        recordFootprint(form, path, footprint);
-      } else if (isFieldError(value)) {
-        setError(form, path, value);
-        recordFootprint(form, path, footprint);
+        if (value) landLeafError(form, path, value, footprint);
+      } else if (Array.isArray(value) || isFieldError(value)) {
+        landLeafError(form, path, value, footprint);
       } else if (value && typeof value === "object") {
         setFormErrors(form, value, path, footprint);
       }
@@ -1138,6 +1130,10 @@
     const stored = form.errors.get(path.key);
     if (stored) footprint.set(path.key, stored);
   }
+  function landLeafError(form, path, error, footprint) {
+    setError(form, path, error);
+    recordFootprint(form, path, footprint);
+  }
   function applyValidateResult(form, result) {
     const footprint = form.validateDeps || form.validateMode !== "onSubmit" ? getFormErrorFootprint(form) : void 0;
     if (footprint) {
@@ -1155,12 +1151,7 @@
   }
   const formErrorFootprints = /* @__PURE__ */ new WeakMap();
   function getFormErrorFootprint(form) {
-    let footprint = formErrorFootprints.get(form);
-    if (!footprint) {
-      footprint = /* @__PURE__ */ new Map();
-      formErrorFootprints.set(form, footprint);
-    }
-    return footprint;
+    return getOrCreate(formErrorFootprints, form, () => /* @__PURE__ */ new Map());
   }
   function hasFormValidateErrors(form) {
     const footprint = formErrorFootprints.get(form);
@@ -1176,7 +1167,7 @@
       if (stored !== written) continue;
       form.errors.delete(key);
       bumpErrorsVersion(form);
-      emit(form.emitter, "errors", create$1(JSON.parse(key)));
+      emit(form.emitter, "errors", create$1(segmentsFromKey(key)));
     }
   }
   const FORM_VALIDATING_KEY = "__form_validate__";
@@ -1189,18 +1180,13 @@
   const SETTLED = /* @__PURE__ */ Symbol("form-validate-settled");
   const formValidateStates = /* @__PURE__ */ new WeakMap();
   function getFormValidateState(form) {
-    let state = formValidateStates.get(form);
-    if (!state) {
-      state = {
-        timer: null,
-        controller: null,
-        round: null,
-        marked: false,
-        waiters: []
-      };
-      formValidateStates.set(form, state);
-    }
-    return state;
+    return getOrCreate(formValidateStates, form, () => ({
+      timer: null,
+      controller: null,
+      round: null,
+      marked: false,
+      waiters: []
+    }));
   }
   function runFormValidate(form) {
     const validate2 = form.validate;
@@ -1238,14 +1224,9 @@
     if (!validate2) return Promise.resolve();
     state.controller?.abort();
     const controller = state.controller = new AbortController();
-    let outcome;
-    try {
-      outcome = Promise.resolve(
-        validate2(getValues(form), { form, signal: controller.signal })
-      );
-    } catch (error) {
-      outcome = Promise.reject(error);
-    }
+    const outcome = new Promise(
+      (resolve) => resolve(validate2(getValues(form), { form, signal: controller.signal }))
+    );
     return outcome.then(
       (result) => {
         if (state.round === round) applyValidateResult(form, result);
@@ -1271,27 +1252,29 @@
       else waiter.reject(outcome);
     }
   }
+  function shouldKick(mode, cadence, touched, hasError, reValidateMode) {
+    return mode === cadence || mode === "all" || mode === "onTouched" && touched || reValidateMode === cadence && hasError();
+  }
   function revalidateFormOnChange(form, path, mode) {
     if (!form.validateDeps?.has(path.key) || !form.validate) return;
-    if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || form.reValidateMode === "onChange" && hasFormValidateErrors(form)) {
+    if (shouldKick(
+      mode,
+      "onChange",
+      hasTouchedByPath(form, path),
+      () => hasFormValidateErrors(form),
+      form.reValidateMode
+    )) {
       runFormValidate(form).catch(() => {
       });
     }
   }
   const fieldValidateDeps = /* @__PURE__ */ new WeakMap();
   function registerFieldValidateDeps(form, key, depKeys) {
-    let deps = fieldValidateDeps.get(form);
-    if (!deps) {
-      deps = /* @__PURE__ */ new Map();
-      fieldValidateDeps.set(form, deps);
-    }
+    const deps = getOrCreate(fieldValidateDeps, form, () => /* @__PURE__ */ new Map());
     for (const depKey of depKeys) {
-      let dependents = deps.get(depKey);
-      if (!dependents) {
-        dependents = /* @__PURE__ */ new Set();
-        deps.set(depKey, dependents);
-      }
+      const dependents = deps.get(depKey) ?? /* @__PURE__ */ new Set();
       dependents.add(key);
+      deps.set(depKey, dependents);
     }
   }
   function unregisterFieldValidateDeps(form, key, depKeys) {
@@ -1308,7 +1291,13 @@
     if (!dependents?.size) return;
     for (const dependent of dependents) {
       if (dependent === path.key) continue;
-      if (mode === "onChange" || mode === "all" || mode === "onTouched" && hasTouchedByPath(form, path) || form.reValidateMode === "onChange" && form.errors.has(dependent)) {
+      if (shouldKick(
+        mode,
+        "onChange",
+        hasTouchedByPath(form, path),
+        () => form.errors.has(dependent),
+        form.reValidateMode
+      )) {
         form.validators.get(dependent)?.();
       }
     }
@@ -1350,11 +1339,7 @@
     }
   }
   function registerFieldMode(form, path, mode) {
-    let modes = fieldModes.get(form);
-    if (!modes) {
-      modes = /* @__PURE__ */ new Map();
-      fieldModes.set(form, modes);
-    }
+    const modes = getOrCreate(fieldModes, form, () => /* @__PURE__ */ new Map());
     const displaced = modes.has(path.key);
     const token = {};
     modes.set(path.key, { mode, token });
@@ -1365,14 +1350,38 @@
     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")
+  function firstMountedDescendantKey(form, ancestor) {
+    const prefix = `${ancestor.key.slice(0, -1)},`;
+    for (const key of fieldModes.get(form)?.keys() ?? []) {
+      if (key.startsWith(prefix)) return key;
+    }
+    return void 0;
+  }
+  function fireFormValidate(form, cadence) {
+    if (form.validateMode !== cadence || !form.validate) return;
+    runFormValidate(form).catch(() => {
+    });
+  }
+  function kickFieldValidator(form, path, mode, cadence, touched) {
+    if (shouldKick(
+      mode,
+      cadence,
+      touched,
+      () => getFieldErrorsByPath(form, path).length > 0,
+      form.reValidateMode
+    ))
       form.validators.get(path.key)?.();
+  }
+  function runUserChangeGate(form, path, mode) {
+    kickFieldValidator(
+      form,
+      path,
+      mode,
+      "onChange",
+      hasTouchedByPath(form, path)
+    );
     revalidateFormOnChange(form, path, mode);
-    if (form.validateMode === "onChange" && form.validate) {
-      runFormValidate(form).catch(() => {
-      });
-    }
+    fireFormValidate(form, "onChange");
     revalidateDependentsOnChange(form, path, mode);
   }
   function userChangeByPath(form, path, value) {
@@ -1384,13 +1393,8 @@
     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)?.();
-    if (form.validateMode === "onBlur" && form.validate) {
-      runFormValidate(form).catch(() => {
-      });
-    }
+    kickFieldValidator(form, path, entry.mode ?? form.mode, "onBlur", true);
+    fireFormValidate(form, "onBlur");
   }
 
   function removeFieldForUnmount(form, path) {
@@ -1438,50 +1442,49 @@
         return "Invalid value";
     }
   }
-  function rulesToValidator(rules) {
+  function resolveMessage(entry, bound) {
+    return typeof entry === "function" ? entry(bound) : entry?.replace("{bound}", String(bound));
+  }
+  function numericMetric(value) {
+    const n = Number(value);
+    return Number.isNaN(n) ? void 0 : n;
+  }
+  function sizedMetric(value) {
+    return typeof value === "string" || Array.isArray(value) ? value.length : void 0;
+  }
+  const BOUND_CHECKS = [
+    ["min", numericMetric, (metric, bound) => metric < bound],
+    ["max", numericMetric, (metric, bound) => metric > bound],
+    ["minLength", sizedMetric, (metric, bound) => metric < bound],
+    ["maxLength", sizedMetric, (metric, bound) => metric > bound]
+  ];
+  function rulesToValidator(rules, formMessages) {
     return (value, meta) => {
       if (rules.required) {
         if (value === "" || value === void 0 || value === null || Array.isArray(value) && value.length === 0) {
           return [
             {
               type: "required",
-              message: typeof rules.required === "string" ? rules.required : defaultMessage("required")
+              message: typeof rules.required === "string" ? rules.required : resolveMessage(formMessages?.required) ?? defaultMessage("required")
             }
           ];
         }
       }
       const errors = [];
-      const message = (type, bound) => rules.messages?.[type] ?? defaultMessage(type, bound);
-      if (rules.min !== void 0) {
-        const n = Number(value);
-        if (!Number.isNaN(n) && n < rules.min) {
-          errors.push({ type: "min", message: message("min", rules.min) });
-        }
-      }
-      if (rules.max !== void 0) {
-        const n = Number(value);
-        if (!Number.isNaN(n) && n > rules.max) {
-          errors.push({ type: "max", message: message("max", rules.max) });
+      const message = (type, bound) => rules.messages?.[type] ?? resolveMessage(formMessages?.[type], bound) ?? defaultMessage(type, bound);
+      for (const [type, measure, fails] of BOUND_CHECKS) {
+        const bound = rules[type];
+        if (bound === void 0) continue;
+        const metric = measure(value);
+        if (metric !== void 0 && fails(metric, bound)) {
+          errors.push({ type, message: message(type, bound) });
         }
       }
-      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 && isSized && value.length > rules.maxLength) {
-        errors.push({
-          type: "maxLength",
-          message: message("maxLength", rules.maxLength)
-        });
-      }
       if (rules.pattern && !rules.pattern.value.test(value)) {
         errors.push({
           type: "pattern",
           // pattern.message is type-required but JS consumers may omit it.
-          message: rules.messages?.pattern ?? rules.pattern.message ?? defaultMessage("pattern")
+          message: rules.messages?.pattern ?? rules.pattern.message ?? resolveMessage(formMessages?.pattern) ?? defaultMessage("pattern")
         });
       }
       if (rules.validate !== void 0) {
@@ -1502,10 +1505,9 @@
   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;
+    for (const key of ["min", "max", "minLength", "maxLength"]) {
+      if (rules[key] !== void 0) attrs[key] = rules[key];
+    }
     if (rules.pattern) attrs.pattern = rules.pattern.value.source;
     return attrs;
   }
@@ -1557,12 +1559,12 @@
       }
       modeToken = registerFieldMode(form, path, mode).token;
       if (rules && hasRuleConstraints(rules)) {
-        const sync = rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0;
-        const rest = rules.required !== void 0 ? { ...rules, required: void 0 } : rules;
+        const { required, ...rest } = rules;
+        const requiredGate = required !== void 0 ? rulesToValidator({ required }, form.messages) : void 0;
         disposeValidator = registerValidatorByPath(form, path, {
-          validate: () => hasRuleConstraints(rest) ? rulesToValidator(rest) : void 0,
+          validate: () => hasRuleConstraints(rest) ? rulesToValidator(rest, form.messages) : void 0,
           debounce: () => 0,
-          sync: () => sync
+          sync: () => requiredGate
         });
       }
       offFocus = on(
@@ -1742,9 +1744,7 @@
   }
   function getNativeErrors(formEl) {
     const errors = [];
-    const { elements } = formEl;
-    for (let i = 0; i < elements.length; i++) {
-      const el = elements[i];
+    for (const el of formEl.elements) {
       if (el.name && typeof el.checkValidity === "function" && !el.checkValidity()) {
         errors.push({
           path: nameToPath(el.name),
@@ -1769,6 +1769,7 @@
         e.preventDefault();
       }
       const formEl = e?.currentTarget;
+      if (form.isSubmitting) return;
       clearServerErrors(form);
       form.isSubmitted = true;
       setIsSubmitting(form, true);
@@ -1823,11 +1824,30 @@
     else emit(form.emitter, "focusError", key);
   }
 
+  function seedInitialValues(form, emitter, source) {
+    if (!isPromise(source)) {
+      form.initialValues = source;
+      return;
+    }
+    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");
+      }
+    );
+  }
   function create(options) {
     const emitter = create$2();
     _setMaxListeners(emitter, 0);
-    let source = options?.initialValues ?? {};
-    if (typeof source === "function") source = source();
+    const initialSource = options?.initialValues ?? {};
+    const source = typeof initialSource === "function" ? initialSource() : initialSource;
     const validateOption = options?.validate;
     const wrappedValidate = validateOption && hasStandardProps(validateOption) ? schemaToFormValidator(
       validateOption
@@ -1860,23 +1880,7 @@
       status: void 0,
       register: (name, registerOptions) => registerField(form, name, registerOptions)
     };
-    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;
-    }
+    seedInitialValues(form, emitter, source);
     return form;
   }
 
@@ -1891,11 +1895,7 @@
   const fieldDisabledRegistry = /* @__PURE__ */ new WeakMap();
   function registerFieldDisabled(form, path, disabled) {
     if (disabled === void 0) return null;
-    let registry = fieldDisabledRegistry.get(form);
-    if (!registry) {
-      registry = /* @__PURE__ */ new Map();
-      fieldDisabledRegistry.set(form, registry);
-    }
+    const registry = getOrCreate(fieldDisabledRegistry, form, () => /* @__PURE__ */ new Map());
     const token = {};
     registry.set(path.key, { disabled, token });
     emit(form.emitter, "disabled", path);
@@ -1985,6 +1985,26 @@
     };
   }
 
+  function pathFromKey(key) {
+    return create$1(segmentsFromKey(key));
+  }
+  function usePath(name) {
+    const key = React.useMemo(() => create$1(normalizePath(name)).key, [name]);
+    return React.useMemo(() => pathFromKey(key), [key]);
+  }
+
+  function seedIfChanged(form, seeded, source, resetOptions) {
+    if (seeded.done && (seeded.source === source || isEqual(seeded.source, source))) {
+      return;
+    }
+    seeded.done = true;
+    seeded.source = source;
+    if (resetOptions !== void 0) {
+      reset(form, source, resetOptions);
+    } else {
+      setInitialValues(form, source);
+    }
+  }
   function useForm(options) {
     const [form] = React.useState(() => {
       const created = create(options);
@@ -1995,6 +2015,7 @@
     });
     const initialValues = options && options.initialValues;
     const values = options && options.values;
+    const resetOptions = options && options.resetOptions;
     const seededRef = React.useRef(null);
     if (seededRef.current === null)
       seededRef.current = { done: false, source: void 0 };
@@ -2003,28 +2024,15 @@
       if (typeof initialValues === "function" || isPromise(initialValues)) {
         return;
       }
-      const seeded = seededRef.current;
-      if (seeded.done && (seeded.source === initialValues || isEqual(seeded.source, initialValues))) {
-        return;
-      }
-      seeded.done = true;
-      seeded.source = initialValues;
-      setInitialValues(form, initialValues);
+      seedIfChanged(form, seededRef.current, initialValues);
     }, [form, initialValues]);
     const controlledRef = React.useRef(null);
-    if (controlledRef.current === null) {
+    if (controlledRef.current === null)
       controlledRef.current = { done: false, source: void 0 };
-    }
     React.useEffect(() => {
       if (values === void 0) return;
-      const seeded = controlledRef.current;
-      if (seeded.done && (seeded.source === values || isEqual(seeded.source, values))) {
-        return;
-      }
-      seeded.done = true;
-      seeded.source = values;
-      setInitialValues(form, values);
-    }, [form, values]);
+      seedIfChanged(form, controlledRef.current, values, resetOptions);
+    }, [form, values, resetOptions]);
     React.useEffect(() => {
       if (!form.validateOnMount || !form.validate) return;
       const run = () => {
@@ -2092,13 +2100,7 @@
     const { key } = path;
     const scope = options?.exact === false ? "branch" : "leaf";
     const subscribeFactory = React.useCallback(
-      (invalidate) => onPathEvent(
-        emitter,
-        "change",
-        create$1(JSON.parse(key)),
-        scope,
-        invalidate
-      ),
+      (invalidate) => onPathEvent(emitter, "change", pathFromKey(key), scope, invalidate),
       [emitter, key, scope]
     );
     return useWatchCore(subscribeFactory, () => {
@@ -2115,15 +2117,20 @@
   function useTouched(form, name) {
     return useTouchedByPath(form, create$1(name));
   }
-  function useTouchedByPath(form, path) {
+  function useKeyWatch(form, path, event, getter) {
     const { emitter } = form;
     const { key } = path;
     const subscribeFactory = React.useCallback(
-      (invalidate) => onKeyEvent(emitter, "touched", key, invalidate),
-      [emitter, key]
+      (invalidate) => onKeyEvent(emitter, event, key, invalidate),
+      [emitter, event, key]
     );
-    return useWatchCore(
-      subscribeFactory,
+    return useWatchCore(subscribeFactory, getter);
+  }
+  function useTouchedByPath(form, path) {
+    return useKeyWatch(
+      form,
+      path,
+      "touched",
       hasTouchedByPath.bind(null, form, path)
     );
   }
@@ -2131,26 +2138,21 @@
     return useErrorByPath(form, create$1(name))?.message;
   }
   function useErrorByPath(form, path) {
-    const { emitter } = form;
-    const { key } = path;
-    const subscribeFactory = React.useCallback(
-      (invalidate) => onKeyEvent(emitter, "errors", key, invalidate),
-      [emitter, key]
+    return useKeyWatch(
+      form,
+      path,
+      "errors",
+      getErrorByPath.bind(null, form, path)
     );
-    return useWatchCore(subscribeFactory, getErrorByPath.bind(null, form, path));
   }
   function useFieldErrors(form, name) {
     return useFieldErrorsByPath(form, create$1(name));
   }
   function useFieldErrorsByPath(form, path) {
-    const { emitter } = form;
-    const { key } = path;
-    const subscribeFactory = React.useCallback(
-      (invalidate) => onKeyEvent(emitter, "errors", key, invalidate),
-      [emitter, key]
-    );
-    return useWatchCore(
-      subscribeFactory,
+    return useKeyWatch(
+      form,
+      path,
+      "errors",
       getFieldErrorsByPath.bind(null, form, path)
     );
   }
@@ -2164,13 +2166,7 @@
     const { emitter } = form;
     const { key } = path;
     const subscribeFactory = React.useCallback(
-      (invalidate) => onPathEvent(
-        emitter,
-        "change",
-        create$1(JSON.parse(key)),
-        "leaf",
-        invalidate
-      ),
+      (invalidate) => onPathEvent(emitter, "change", pathFromKey(key), "leaf", invalidate),
       [emitter, key]
     );
     return useWatchCore(subscribeFactory, () => isFieldDirtyByPath(form, path));
@@ -2192,14 +2188,21 @@
     "disabled",
     "loading"
   ];
+  function subscribeFormStateEvents(emitter, invalidate) {
+    const offs = FORM_STATE_EVENTS.map((event) => on(emitter, event, invalidate));
+    return () => {
+      for (const off of offs) off();
+    };
+  }
   function getFormState(form) {
+    const anyErrors = hasErrors(form);
     return {
       isDirty: isDirty(form),
       dirtyFields: getDirtyFields(form),
       isTouched: form.touched.size > 0,
       touchedFields: getTouchedFields(form),
-      hasErrors: hasErrors(form),
-      isValid: !hasErrors(form),
+      hasErrors: anyErrors,
+      isValid: !anyErrors,
       errors: getErrorsRecord(form),
       isSubmitting: form.isSubmitting,
       isSubmitted: form.isSubmitted,
@@ -2217,28 +2220,14 @@
   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();
-        };
-      },
+      (invalidate) => subscribeFormStateEvents(form.emitter, invalidate),
       [form.emitter]
     );
     return useWatchCore(subscribeFactory, getter, isSameFormState);
   }
   function useStore(form, selector, isEqual2) {
     const subscribeFactory = React.useCallback(
-      (invalidate) => {
-        const offs = FORM_STATE_EVENTS.map(
-          (event) => on(form.emitter, event, invalidate)
-        );
-        return () => {
-          for (const off of offs) off();
-        };
-      },
+      (invalidate) => subscribeFormStateEvents(form.emitter, invalidate),
       [form.emitter]
     );
     return useWatchCore(subscribeFactory, selector, isEqual2);
@@ -2302,11 +2291,6 @@
     return useFieldErrorsByPath(form, create$1(FORM_ERROR));
   }
 
-  function usePath(name) {
-    const key = React.useMemo(() => create$1(normalizePath(name)).key, [name]);
-    return React.useMemo(() => create$1(JSON.parse(key)), [key]);
-  }
-
   function useStage(value) {
     const ref = React.useRef(value);
     ref.current = value;
@@ -2336,24 +2320,34 @@
       };
     }, [removedRef, teardownRef, restoreRef]);
   }
+  function useUnmountFieldRemoval(form, path, shouldUnregister) {
+    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);
+  }
 
+  function schemaAsValidator(validate) {
+    return validate && hasStandardProps(validate) ? schemaToFieldValidator(validate) : validate;
+  }
   function useValidate(validate, path, formProp, options) {
     const contextForm = React.useContext(FormContext);
     const form = formProp || contextForm;
     if (!form) throw new Error("no form provided");
-    const validateOption = validate;
-    const validateRef = React.useRef(void 0);
-    validateRef.current = validateOption && hasStandardProps(validateOption) ? schemaToFieldValidator(validateOption) : validateOption;
-    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;
-    const validateOnMountRef = React.useRef(options?.validateOnMount);
-    validateOnMountRef.current = options?.validateOnMount;
+    const validateRef = useStage(schemaAsValidator(validate));
+    const debounceRef = useStage(options?.debounce ?? 0);
+    const syncRef = useStage(options?.sync);
+    const asyncAlwaysRef = useStage(options?.asyncAlways ?? false);
+    const validateOnMountRef = useStage(options?.validateOnMount);
     React.useEffect(() => {
-      const spath = create$1(JSON.parse(path.key));
+      const spath = pathFromKey(path.key);
       const dispose = registerValidatorByPath(form, spath, {
         validate: () => validateRef.current,
         debounce: () => debounceRef.current,
@@ -2381,14 +2375,40 @@
         disposed = true;
         dispose();
       };
-    }, [form, path.key]);
+    }, [
+      form,
+      path.key,
+      debounceRef,
+      syncRef,
+      asyncAlwaysRef,
+      validateRef,
+      validateOnMountRef
+    ]);
     return useStageFn(() => form.validators.get(path.key)?.());
   }
 
   const uncontrolledSyncRegistry = /* @__PURE__ */ new WeakMap();
-  function combineRulesAndValidate(rules, validate) {
+  function getUncontrolledSyncEntry(form) {
+    const existing = uncontrolledSyncRegistry.get(form);
+    if (existing) return existing;
+    const cells = /* @__PURE__ */ new Map();
+    const off = on(form.emitter, "change", (changed) => {
+      if (changed) return;
+      for (const read of cells.values()) {
+        const { el, path } = read();
+        if (!el || el.type === "file") continue;
+        const next = getValueByPath(form, path);
+        const asString = next == null ? "" : String(next);
+        if (el.value !== asString) el.value = asString;
+      }
+    });
+    const entry = { cells, off };
+    uncontrolledSyncRegistry.set(form, entry);
+    return entry;
+  }
+  function combineRulesAndValidate(rules, validate, formMessages) {
     if (!rules || !hasRuleConstraints(rules)) return validate;
-    const ruleValidator = rulesToValidator(rules);
+    const ruleValidator = rulesToValidator(rules, formMessages);
     if (!validate) return ruleValidator;
     return (value, meta) => {
       const ruleErrors = ruleValidator(value, meta);
@@ -2409,7 +2429,7 @@
     const timerRef = React.useRef(null);
     const subscribeFactory = React.useCallback(
       (invalidate) => {
-        const spath = create$1(JSON.parse(path.key));
+        const spath = pathFromKey(path.key);
         const clearTimer = () => {
           if (timerRef.current !== null) {
             clearTimeout(timerRef.current);
@@ -2511,14 +2531,18 @@
       emitChangeByPath(form, path);
     });
     const restRules = rules ? { ...rules, required: void 0 } : void 0;
-    const validateOption = validate;
-    const validateWrapped = validateOption && hasStandardProps(validateOption) ? schemaToFieldValidator(validateOption) : validateOption;
-    useValidate(combineRulesAndValidate(restRules, validateWrapped), path, form, {
-      debounce: validateDebounce,
-      validateOnMount,
-      asyncAlways: asyncAlways ?? form.asyncAlways,
-      sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0
-    });
+    const validateWrapped = schemaAsValidator(validate);
+    useValidate(
+      combineRulesAndValidate(restRules, validateWrapped, form.messages),
+      path,
+      form,
+      {
+        debounce: validateDebounce,
+        validateOnMount,
+        asyncAlways: asyncAlways ?? form.asyncAlways,
+        sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }, form.messages) : void 0
+      }
+    );
     const errors = useDelayedErrors(form, path, delayError);
     const errorObject = errors[0];
     const error = errorObject?.message;
@@ -2529,7 +2553,7 @@
         } : onPathEvent(
           form.emitter,
           "change",
-          create$1(JSON.parse(path.key)),
+          pathFromKey(path.key),
           "leaf",
           invalidate
         ),
@@ -2549,7 +2573,7 @@
         (invalidate) => onPathEvent(
           form.emitter,
           "disabled",
-          create$1(JSON.parse(path.key)),
+          pathFromKey(path.key),
           "branch",
           invalidate
         ),
@@ -2559,7 +2583,7 @@
     );
     const disabledTokenRef = React.useRef(null);
     React.useEffect(() => {
-      const spath = create$1(JSON.parse(path.key));
+      const spath = pathFromKey(path.key);
       const registration = registerFieldDisabled(form, spath, disabled);
       if (registration) disabledTokenRef.current = registration.token;
       return () => {
@@ -2572,7 +2596,7 @@
     const onChange = useStageFn((v) => userChangeByPath(form, path, v));
     const onBlur = useStageFn(() => userBlur(form, path));
     React.useEffect(() => {
-      const spath = create$1(JSON.parse(path.key));
+      const spath = pathFromKey(path.key);
       const { token, displaced } = registerFieldMode(form, spath, modeOption);
       return () => unregisterFieldMode(form, spath, token);
     }, [form, path.key, modeOption]);
@@ -2605,23 +2629,8 @@
       [form, path.key]
     );
     React.useEffect(() => {
-      const spath = create$1(JSON.parse(path.key));
-      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);
-      }
+      const spath = pathFromKey(path.key);
+      const entry = getUncontrolledSyncEntry(form);
       entry.cells.set(path.key, () => ({ el: elementRef.current, path: spath }));
       return () => {
         entry.cells.delete(path.key);
@@ -2631,27 +2640,28 @@
         }
       };
     }, [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);
+    useUnmountFieldRemoval(form, path, shouldUnregister);
+    const extract = eventToValueOrDefault(eventToValue, {
+      valueAsNumber,
+      valueAsDate
     });
-    useUnmountRestore(teardownOnUnmount, restoreAfterStrictMode);
-    const extract = eventToValue ?? ((e) => extractEventValue(e, { valueAsNumber, valueAsDate }));
     const inputProps = {
       name: path.key,
       ref: focusRef,
       onChange: (e) => onChange(extract(e)),
       onBlur,
-      disabled: mergedDisabled,
-      ...type === "checkbox" ? { checked: !!value } : type === "file" ? {} : uncontrolled ? { defaultValue: value } : { value: value ?? "" },
-      ...error ? { "aria-invalid": true, "aria-describedby": errorIdFromKey(path.key) } : {}
+      disabled: mergedDisabled
     };
+    if (type === "checkbox") {
+      inputProps.checked = !!value;
+    } else if (type !== "file") {
+      if (uncontrolled) inputProps.defaultValue = value;
+      else inputProps.value = value ?? "";
+    }
+    if (error) {
+      inputProps["aria-invalid"] = true;
+      inputProps["aria-describedby"] = errorIdFromKey(path.key);
+    }
     return {
       form,
       value,
@@ -2683,12 +2693,18 @@
     return arrayIdsRegistry.get(form)?.get(key);
   }
   function registerArrayIds(form, key, ids) {
-    let registry = arrayIdsRegistry.get(form);
-    if (!registry) {
-      registry = /* @__PURE__ */ new Map();
-      arrayIdsRegistry.set(form, registry);
-    }
+    const registry = arrayIdsRegistry.get(form) ?? /* @__PURE__ */ new Map();
     registry.set(key, ids);
+    arrayIdsRegistry.set(form, registry);
+  }
+  function scheduleArrayRowFocus(form, path, index, options) {
+    const { focus } = options ?? {};
+    if (focus === void 0) return;
+    setTimeout(() => {
+      const segments = [...path.value, index];
+      const key = typeof focus === "string" ? create$1([...segments, focus]).key : firstMountedDescendantKey(form, create$1(segments));
+      if (key !== void 0) emit(form.emitter, "focusError", key);
+    }, 0);
   }
   function bumpReducer(count) {
     return count + 1;
@@ -2701,12 +2717,8 @@
     const { rules, shouldUnregister } = options;
     const path = usePath(options.name);
     const idsRef = React.useRef([]);
-    const getArray = React.useCallback(
-      () => getValueByPath(form, path) || [],
-      [form, path]
-    );
     const computeFields = React.useCallback(() => {
-      const arr = getArray();
+      const arr = getValueByPath(form, path) || [];
       while (idsRef.current.length < arr.length) {
         idsRef.current.push(generateId(form));
       }
@@ -2718,7 +2730,7 @@
         index,
         [keyName]: id
       }));
-    }, [getArray, form, keyName]);
+    }, [form, path, keyName]);
     const [fields, syncFields] = React.useReducer(
       computeFields,
       void 0,
@@ -2730,43 +2742,43 @@
     );
     registerArrayIds(form, path.key, idsRef.current);
     React.useEffect(() => {
-      registerArrayIds(form, path.key, idsRef.current);
+      const ids = idsRef.current;
+      registerArrayIds(form, path.key, ids);
       return () => {
         const registry = arrayIdsRegistry.get(form);
-        if (registry?.get(path.key) === idsRef.current) registry.delete(path.key);
+        if (registry?.get(path.key) === ids) 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);
+    useUnmountFieldRemoval(form, path, shouldUnregister);
     useValidate(
-      rules ? rulesToValidator({ ...rules, required: void 0 }) : void 0,
+      rules ? rulesToValidator({ ...rules, required: void 0 }, form.messages) : void 0,
       path,
       form,
       {
-        sync: rules && rules.required !== void 0 ? rulesToValidator({ required: rules.required }) : void 0
+        sync: rules?.required !== void 0 ? rulesToValidator({ required: rules.required }, form.messages) : void 0
+      }
+    );
+    const append = useStageFn(
+      (value, options2) => {
+        idsRef.current.push(generateId(form));
+        appendValueByPath(form, path, value);
+        scheduleArrayRowFocus(form, path, idsRef.current.length - 1, options2);
+      }
+    );
+    const prepend = useStageFn(
+      (value, options2) => {
+        idsRef.current.unshift(generateId(form));
+        prependValueByPath(form, path, value);
+        scheduleArrayRowFocus(form, path, 0, options2);
+      }
+    );
+    const insert = useStageFn(
+      (index, value, options2) => {
+        if (!insertValueByPath(form, path, index, value)) return;
+        idsRef.current.splice(index, 0, generateId(form));
+        scheduleArrayRowFocus(form, path, index, options2);
       }
     );
-    const append = useStageFn((value) => {
-      idsRef.current.push(generateId(form));
-      appendValueByPath(form, path, value);
-    });
-    const prepend = useStageFn((value) => {
-      idsRef.current.unshift(generateId(form));
-      prependValueByPath(form, path, value);
-    });
-    const insert = useStageFn((index, value) => {
-      if (!insertValueByPath(form, path, index, value)) return;
-      idsRef.current.splice(index, 0, generateId(form));
-    });
     const remove = useStageFn((indices) => {
       const dropped = removeValueByPath(form, path, indices);
       for (const index of dropped) idsRef.current.splice(index, 1);
@@ -2906,7 +2918,7 @@
       (invalidate) => onPathEvent(
         form.emitter,
         "change",
-        create$1(JSON.parse(path.key)),
+        pathFromKey(path.key),
         "leaf",
         invalidate
       ),
@@ -2916,10 +2928,8 @@
     const value = toDisplay ? toDisplay(raw) : raw;
     const timerRef = React.useRef(null);
     const seqRef = React.useRef(0);
-    const fromDisplayRef = React.useRef(fromDisplay);
-    fromDisplayRef.current = fromDisplay;
-    const debounceRef = React.useRef(asyncDebounceMs ?? 0);
-    debounceRef.current = asyncDebounceMs ?? 0;
+    const fromDisplayRef = useStage(fromDisplay);
+    const debounceRef = useStage(asyncDebounceMs ?? 0);
     React.useEffect(
       () => () => {
         if (timerRef.current !== null) clearTimeout(timerRef.current);
@@ -2953,7 +2963,7 @@
           run();
         }
       },
-      [form, path]
+      [form, path, fromDisplayRef, debounceRef]
     );
     return { value, onChange };
   }
@@ -3054,6 +3064,9 @@
       "aria-describedby": error ? [props["aria-describedby"], errorIdFromKey(fieldKey)].filter(Boolean).join(" ") : props["aria-describedby"]
     };
   }
+  function toConstraintAttrs(rules) {
+    return rules ? rulesToConstraintAttrs(rules) : void 0;
+  }
   const Field = React__namespace.forwardRef(
     ({
       validate,
@@ -3082,8 +3095,8 @@
       const [nativeInvalidCount, setNativeInvalidCount] = React__namespace.useState(0);
       const contextForm = React__namespace.useContext(FormContext);
       const resolvedForm = formProp ?? contextForm;
-      const validateOption = validate;
-      const validateWrapped = validateOption && hasStandardProps(validateOption) ? schemaToFieldValidator(validateOption) : validateOption;
+      const isFile = props.type === "file";
+      const validateWrapped = validate && hasStandardProps(validate) ? schemaToFieldValidator(validate) : validate;
       const {
         value,
         onChange,
@@ -3091,7 +3104,8 @@
         error,
         name: fieldKey,
         disabled: isDisabled,
-        focusRef
+        focusRef,
+        validating
       } = useField({
         name,
         form: formProp,
@@ -3104,9 +3118,8 @@
         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",
+        // File inputs can't be value-controlled — force the uncontrolled path.
+        uncontrolled: uncontrolled || isFile,
         validate: (...params) => {
           if (resolvedForm?.shouldUseNativeValidation !== false) {
             const el = innerRef.current;
@@ -3129,7 +3142,6 @@
         },
         [ref, focusRef]
       );
-      const Component = as || "input";
       React__namespace.useEffect(() => {
         const el = innerRef.current;
         if (!el || typeof el.setCustomValidity !== "function") return;
@@ -3143,11 +3155,14 @@
       React__namespace.useEffect(() => {
         if (nativeInvalidCount > 0) innerRef.current?.reportValidity();
       }, [nativeInvalidCount]);
-      const isFile = props.type === "file";
-      const toValue = eventToValue ?? ((e) => extractEventValue(e, { valueAsNumber, valueAsDate }));
+      const Component = as || "input";
+      const toValue = eventToValueOrDefault(eventToValue, {
+        valueAsNumber,
+        valueAsDate
+      });
       const valueProps = valueToProps ? valueToProps(value) : isFile ? {} : uncontrolled ? { defaultValue: value } : { value };
       const errorId = errorIdFromKey(fieldKey);
-      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
+      const constraintAttrs = toConstraintAttrs(rules);
       return /* @__PURE__ */ React__namespace.createElement(React__namespace.Fragment, null, /* @__PURE__ */ React__namespace.createElement(
         Component,
         {
@@ -3159,6 +3174,7 @@
           ...valueProps,
           ...ariaProps(error, fieldKey, props),
           disabled: isDisabled,
+          "aria-busy": validating || void 0,
           onChange: (e) => onChange(toValue(e)),
           ref: mergedRef
         }
@@ -3187,7 +3203,8 @@
         onBlur,
         error,
         name: fieldKey,
-        disabled: isDisabled
+        disabled: isDisabled,
+        validating
       } = useField({
         name,
         form,
@@ -3202,7 +3219,7 @@
         disabled,
         mode
       });
-      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
+      const constraintAttrs = toConstraintAttrs(rules);
       return /* @__PURE__ */ React__namespace.createElement(
         "input",
         {
@@ -3214,6 +3231,7 @@
           checked: !!value,
           ...ariaProps(error, fieldKey, props),
           disabled: isDisabled,
+          "aria-busy": validating || void 0,
           onChange: (e) => onChange(e.target.checked),
           ref
         }
@@ -3248,7 +3266,8 @@
         onBlur,
         error,
         name: fieldKey,
-        disabled: isDisabled
+        disabled: isDisabled,
+        validating
       } = useField({
         name,
         form,
@@ -3263,7 +3282,7 @@
         disabled,
         mode
       });
-      const constraintAttrs = rules ? rulesToConstraintAttrs(rules) : void 0;
+      const constraintAttrs = toConstraintAttrs(rules);
       return /* @__PURE__ */ React__namespace.createElement(
         "select",
         {
@@ -3275,6 +3294,7 @@
           value: toSelectValue(multiple, value),
           ...ariaProps(error, fieldKey, props),
           disabled: isDisabled,
+          "aria-busy": validating || void 0,
           onChange: (e) => onChange(
             multiple ? Array.from(e.target.selectedOptions, (option) => option.value) : e.target.value
           ),
@@ -3285,9 +3305,74 @@
     }
   );
 
+  function ErrorSummary({
+    form: formProp,
+    context,
+    heading
+  }) {
+    const contextForm = React__namespace.useContext(context ?? FormContext);
+    const form = formProp ?? contextForm;
+    if (!form) throw new Error("no form provided");
+    const containerRef = React__namespace.useRef(null);
+    const wasSubmittingRef = React__namespace.useRef(false);
+    const headingId = React__namespace.useId();
+    const errors = useErrors(form);
+    const subscribeFactory = React__namespace.useCallback(
+      (invalidate) => {
+        const check = () => {
+          const wasSubmitting = wasSubmittingRef.current;
+          wasSubmittingRef.current = form.isSubmitting;
+          if (wasSubmitting && !form.isSubmitting && hasErrors(form)) {
+            containerRef.current?.focus();
+          }
+          invalidate();
+        };
+        const offErrors = on(form.emitter, "errors", check);
+        const offSubmitting = on(form.emitter, "submitting", check);
+        return () => {
+          offErrors();
+          offSubmitting();
+        };
+      },
+      [form]
+    );
+    useWatchCore(subscribeFactory, () => null);
+    const entries = Object.entries(errors);
+    if (entries.length === 0) return null;
+    return /* @__PURE__ */ React__namespace.createElement(
+      "div",
+      {
+        role: "alert",
+        tabIndex: -1,
+        ref: containerRef,
+        "aria-labelledby": headingId
+      },
+      /* @__PURE__ */ React__namespace.createElement("h2", { id: headingId }, heading ?? "There is a problem"),
+      /* @__PURE__ */ React__namespace.createElement("ul", null, entries.map(([dottedKey, list]) => {
+        const message = list[0]?.message;
+        if (dottedKey === FORM_ERROR) {
+          return /* @__PURE__ */ React__namespace.createElement("li", { key: dottedKey }, /* @__PURE__ */ React__namespace.createElement("p", null, message));
+        }
+        const path = dottedKeyToFieldPath(dottedKey);
+        return /* @__PURE__ */ React__namespace.createElement("li", { key: dottedKey }, /* @__PURE__ */ React__namespace.createElement(
+          "a",
+          {
+            href: `#${fieldErrorId(path)}`,
+            onClick: (e) => {
+              e.preventDefault();
+              setFocus(form, path);
+            }
+          },
+          message
+        ));
+      }))
+    );
+  }
+
   exports.Checkbox = Checkbox;
   exports.CheckboxGroupContext = CheckboxGroupContext;
   exports.CheckboxGroupProvider = CheckboxGroupProvider;
+  exports.ErrorSummary = ErrorSummary;
   exports.FORM_ERROR = FORM_ERROR;
   exports.Field = Field;
   exports.Form = Form;
@@ -3309,6 +3394,7 @@
   exports.ensureValidate = ensureValidate;
   exports.fieldErrorId = fieldErrorId;
   exports.fieldPathToDottedKey = fieldPathToDottedKey;
+  exports.firstMountedDescendantKey = firstMountedDescendantKey;
   exports.getDirtyFields = getDirtyFields;
   exports.getError = getError;
   exports.getErrorByPath = getErrorByPath;
@@ -3367,6 +3453,7 @@
   exports.setValidatingByPath = setValidatingByPath;
   exports.setValue = setValue;
   exports.setValueByPath = setValueByPath;
+  exports.shouldKick = shouldKick;
   exports.subscribe = subscribe;
   exports.swapValues = swapValues;
   exports.swapValuesByPath = swapValuesByPath;