formstand 0.25.0 → 0.26.1

package/dist/index.cjs

@@ -212,10 +212,12 @@ var hasOwnSlot = (obj, path) => parsePath(path).reduce(
 ).ok;
 var writeIntoArray = (arr, index, rest, value, kindAt, prefix) => {
   const length = Math.max(arr.length, index + 1);
-  return Array.from(
-    { length },
-    (_, i) => i === index ? writeSegments(arr[i], rest, value, kindAt, [...prefix, index]) : arr[i]
-  );
+  const child = writeSegments(arr[index], rest, value, kindAt, [
+    ...prefix,
+    index
+  ]);
+  if (index < arr.length && child === arr[index]) return arr;
+  return Array.from({ length }, (_, i) => i === index ? child : arr[i]);
 };
 var refusesHugeIndex = (index) => {
   if (index > MAX_ARRAY_INDEX) {
@@ -247,10 +249,12 @@ var writeSegments = (obj, segments, value, kindAt, prefix) => {
       return obj;
     }
     const key2 = String(head);
-    return {
-      ...obj,
-      [key2]: writeSegments(obj[key2], rest, value, kindAt, [...prefix, key2])
-    };
+    const child = writeSegments(obj[key2], rest, value, kindAt, [
+      ...prefix,
+      key2
+    ]);
+    if (child === obj[key2] && Object.hasOwn(obj, key2)) return obj;
+    return { ...obj, [key2]: child };
   }
   const kind = kindAt?.(prefix.map(String).join(".")) ?? (typeof head === "number" ? "array" : "record");
   if (kind === "array") {
@@ -298,6 +302,12 @@ var validateAsync = async (schema, values) => {
   return result.success ? { kind: "valid", data: result.data } : { kind: "invalid", errors: flattenIssues(result.error.issues) };
 };
 var isAsyncRequiredError = (e) => e instanceof zod.z.core.$ZodAsyncError || e instanceof Error && /Encountered Promise during synchronous parse/i.test(e.message);
+var reportBackgroundFailure = (error) => {
+  console.error(
+    "[formstand] a background validation pass threw (an async refinement rejected). Its in-flight flags were released. The error:",
+    error
+  );
+};
 var isPathOrChild = (key, path) => key === path || key.startsWith(`${path}.`);
 var prefixErrorKeys = (errors, path) => path === "" ? errors : Object.fromEntries(
   Object.entries(errors).map(([k, v]) => [
@@ -323,7 +333,11 @@ var unwrapForWalk = (s) => {
   if (s instanceof zod.z.ZodDefault || s instanceof zod.z.ZodPrefault || s instanceof zod.z.ZodCatch || s instanceof zod.z.ZodReadonly || s instanceof zod.z.ZodNonOptional) {
     return s.def.innerType;
   }
-  if (s instanceof zod.z.ZodPipe) return s.def.in;
+  if (s instanceof zod.z.ZodPipe) {
+    const input = s.def.in;
+    return input instanceof zod.z.ZodTransform ? s.def.out : input;
+  }
+  if (s instanceof zod.z.ZodLazy) return s.def.getter();
   return null;
 };
 var isLeafSchema = (s) => s instanceof zod.z.ZodString || s instanceof zod.z.ZodNumber || s instanceof zod.z.ZodBoolean || s instanceof zod.z.ZodBigInt || s instanceof zod.z.ZodDate || s instanceof zod.z.ZodEnum || s instanceof zod.z.ZodLiteral || s instanceof zod.z.ZodNull || s instanceof zod.z.ZodUndefined || s instanceof zod.z.ZodVoid || s instanceof zod.z.ZodNaN || s instanceof zod.z.ZodSymbol;
@@ -349,14 +363,71 @@ var schemaHasPath = (schema, path) => {
   };
   return walk(schema, parsePath(path), SCHEMA_WALK_BUDGET);
 };
+var schemaAllowsKindChangeAt = (schema, path) => {
+  const flexible = (s) => s instanceof zod.z.ZodUnion || s instanceof zod.z.ZodDiscriminatedUnion || s instanceof zod.z.ZodPipe || s instanceof zod.z.ZodAny || s instanceof zod.z.ZodUnknown || s instanceof zod.z.ZodLazy || s instanceof zod.z.ZodCatch || s.def.coerce === true;
+  const strip = (s) => {
+    if (s instanceof zod.z.ZodOptional || s instanceof zod.z.ZodNullable) {
+      return strip(s.unwrap());
+    }
+    if (s instanceof zod.z.ZodDefault || s instanceof zod.z.ZodPrefault || s instanceof zod.z.ZodReadonly || s instanceof zod.z.ZodNonOptional) {
+      return strip(s.def.innerType);
+    }
+    return s;
+  };
+  const walk = (s, segments, budget) => {
+    if (budget <= 0) return true;
+    const node = strip(s);
+    if (flexible(node)) return true;
+    const [head, ...rest] = segments;
+    if (head === void 0) return false;
+    if (node instanceof zod.z.ZodObject) {
+      const shape = node.shape;
+      const child = Object.hasOwn(shape, String(head)) ? shape[String(head)] : void 0;
+      return child === void 0 ? true : walk(child, rest, budget - 1);
+    }
+    if (node instanceof zod.z.ZodArray) {
+      return typeof head === "number" ? walk(node.element, rest, budget - 1) : true;
+    }
+    if (node instanceof zod.z.ZodTuple && typeof head === "number") {
+      const item = node.def.items[head];
+      return item === void 0 ? true : walk(item, rest, budget - 1);
+    }
+    if (node instanceof zod.z.ZodRecord) {
+      return walk(node.valueType, rest, budget - 1);
+    }
+    return true;
+  };
+  return walk(schema, parsePath(path), SCHEMA_WALK_BUDGET);
+};
 var hasChecks = (s) => {
   const checks = s.def.checks;
   return checks !== void 0 && checks.length > 0;
 };
-var fieldSchemaForIntrospection = (schema, path) => {
-  const childOf = (s, segment) => {
+var optionClaims = (option, discriminator, tag) => {
+  const strip = (s) => {
     const inner = unwrapForWalk(s);
-    if (inner !== null) return childOf(inner, segment);
+    return inner === null ? s : strip(inner);
+  };
+  const node = strip(option);
+  if (!(node instanceof zod.z.ZodObject)) return false;
+  const shape = node.shape;
+  const at = Object.hasOwn(shape, discriminator) ? shape[discriminator] : void 0;
+  if (at === void 0) return false;
+  const leaf = strip(at);
+  if (leaf instanceof zod.z.ZodLiteral) {
+    return leaf.def.values.includes(tag);
+  }
+  if (leaf instanceof zod.z.ZodEnum) {
+    return Object.values(leaf.def.entries).includes(
+      tag
+    );
+  }
+  return false;
+};
+var fieldSchemaForIntrospection = (schema, path, values) => {
+  const childOf = (s, segment, holder) => {
+    const inner = unwrapForWalk(s);
+    if (inner !== null) return childOf(inner, segment, holder);
     if (s instanceof zod.z.ZodObject && typeof segment === "string") {
       const shape = s.shape;
       return Object.hasOwn(shape, segment) ? shape[segment] ?? null : null;
@@ -370,19 +441,45 @@ var fieldSchemaForIntrospection = (schema, path) => {
     if (s instanceof zod.z.ZodRecord) {
       return s.valueType;
     }
+    if (s instanceof zod.z.ZodIntersection) {
+      return childOf(s.def.left, segment, holder) ?? childOf(s.def.right, segment, holder);
+    }
     if (s instanceof zod.z.ZodDiscriminatedUnion || s instanceof zod.z.ZodUnion) {
       const options = s.def.options;
-      return options.reduce(
-        (found, option) => found ?? childOf(option, segment),
+      const discriminator = s instanceof zod.z.ZodDiscriminatedUnion ? s.def.discriminator : null;
+      const tag = discriminator !== null && typeof holder === "object" && holder !== null ? holder[discriminator] : void 0;
+      const live = discriminator === null || tag === void 0 ? void 0 : options.find((option) => optionClaims(option, discriminator, tag));
+      const candidates = live === void 0 ? options : [live];
+      return candidates.reduce(
+        (found, option) => found ?? childOf(option, segment, holder),
         null
       );
     }
     return null;
   };
-  return parsePath(path).reduce(
-    (current, segment) => current === null ? null : childOf(current, segment),
-    schema
-  );
+  const segments = parsePath(path);
+  return segments.reduce(
+    (acc, segment) => acc.s === null ? acc : {
+      s: childOf(
+        acc.s,
+        segment,
+        values === void 0 ? void 0 : getAtPath(values, acc.prefix)
+      ),
+      prefix: acc.prefix === "" ? String(segment) : `${acc.prefix}.${String(segment)}`
+    },
+    { s: schema, prefix: "" }
+  ).s;
+};
+var schemaAcceptsUndefined = (schema) => schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodDefault || schema instanceof zod.z.ZodPrefault || schema instanceof zod.z.ZodNullable && schemaAcceptsUndefined(schema.unwrap());
+var isObjectSchemaAt = (schema, path) => {
+  const sub = fieldSchemaForIntrospection(schema, path);
+  if (sub === null) return true;
+  const strip = (s) => {
+    const inner = unwrapForWalk(s);
+    return inner === null ? s : strip(inner);
+  };
+  const node = strip(sub);
+  return !(node instanceof zod.z.ZodUnion || node instanceof zod.z.ZodDiscriminatedUnion || node instanceof zod.z.ZodRecord || node instanceof zod.z.ZodMap || node instanceof zod.z.ZodSet || node instanceof zod.z.ZodArray || node instanceof zod.z.ZodTuple || isLeafSchema(node));
 };
 var containerKindAt = (schema) => (prefix) => {
   const unwrapAll = (s) => {
@@ -433,7 +530,7 @@ var fieldSchemaAtPath = (schema, path) => parsePath(path).reduce((current, segme
 }, schema);
 
 // src/core/createForm.ts
-var shallowFieldEqual = (a, b) => Object.is(a.value, b.value) && a.error === b.error && a.touched === b.touched && a.dirty === b.dirty && a.isValidating === b.isValidating;
+var shallowFieldEqual = (a, b) => Object.is(a.value, b.value) && Object.is(a.initialValue, b.initialValue) && a.error === b.error && a.touched === b.touched && a.dirty === b.dirty && a.isValidating === b.isValidating;
 var emptyErrors = {};
 var emptyBools = {};
 var identityMapper = (n) => n;
@@ -491,7 +588,27 @@ var reuseErrorRefs = (next, prev) => {
   const sameShape = entries.length === Object.keys(prev).length && entries.every(([k, v]) => entryAt(prev, k) === v);
   return sameShape ? prev : Object.fromEntries(entries);
 };
-var scopeSettledResult = (result, path, viaSubschema) => result.kind !== "invalid" ? emptyErrors : viaSubschema ? prefixErrorKeys(result.errors, path) : path === "" ? result.errors : pickScope(result.errors, [path]);
+var noScopeErrors = { scoped: emptyErrors, full: null };
+var scopeParse = (result, path, viaSubschema) => {
+  const errors = result.kind === "invalid" ? result.errors : emptyErrors;
+  return viaSubschema ? { scoped: prefixErrorKeys(errors, path), full: null } : {
+    scoped: path === "" ? errors : pickScope(errors, [path]),
+    full: errors
+  };
+};
+var pruneUnreported = (prev, full) => {
+  const entries = Object.entries(prev);
+  const kept = entries.filter(([k]) => Object.hasOwn(full, k));
+  const unchanged = kept.length === entries.length && kept.every(([k, list]) => full[k] === list);
+  return unchanged ? prev : Object.fromEntries(kept.map(([k, list]) => [k, full[k] ?? list]));
+};
+var dropEmptyLists = (map) => {
+  const entries = Object.entries(map);
+  const kept = entries.filter(
+    ([, list]) => list !== void 0 && list.length > 0
+  );
+  return kept.length === entries.length ? map : Object.fromEntries(kept);
+};
 var mergeErrorChannels = (schema, server) => {
   const extra = Object.entries(server).filter(
     ([k]) => !Object.hasOwn(schema, k)
@@ -601,17 +718,17 @@ var createForm = (schema, options) => {
         const merged = scopes.reduce(
           (acc, { path, scope }) => scope.kind === "skip" ? acc : {
             ...acc,
-            ...scopeSettledResult(
+            ...scopeParse(
               validateSyncLatched(path, scope.schema, scope.value),
               path,
               true
-            )
+            ).scoped
           },
           {}
         );
         store.setState((state) => ({
           ...state,
-          ...commitScopedErrors(state, merged, paths)
+          ...commitScopedErrors(state, merged, paths, null)
         }));
         return settledFields(merged);
       }
@@ -620,7 +737,7 @@ var createForm = (schema, options) => {
       const requestedErrors = pickScope(fullErrors, paths);
       store.setState((state) => ({
         ...state,
-        ...commitScopedErrors(state, requestedErrors, paths)
+        ...commitScopedErrors(state, requestedErrors, paths, fullErrors)
       }));
       return settledFields(requestedErrors);
     } catch (e) {
@@ -665,7 +782,7 @@ var createForm = (schema, options) => {
     const slot = slotAtPath(values, path);
     return slot.exists ? { kind: "parse", schema: sub, value: slot.value, viaSubschema: true } : { kind: "skip" };
   };
-  const parseScopeAsync = async (path, scope) => scope.kind === "skip" ? emptyErrors : scopeSettledResult(
+  const parseScopeAsync = async (path, scope) => scope.kind === "skip" ? noScopeErrors : scopeParse(
     await validateAsync(scope.schema, scope.value),
     path,
     scope.viaSubschema
@@ -685,14 +802,18 @@ var createForm = (schema, options) => {
   };
   const settledFields = (scoped) => Object.keys(scoped).length === 0 ? { kind: "valid" } : { kind: "invalid", errors: scoped };
   const settledFormResult = (result) => settledFields(result.kind === "invalid" ? result.errors : emptyErrors);
-  const commitScopedErrors = (state, scoped, paths) => errorChannels(state, {
+  const commitScopedErrors = (state, scoped, paths, full) => errorChannels(state, {
     schemaErrors: reuseErrorRefs(
-      mergeScopedErrors(state.schemaErrors, scoped, paths),
+      mergeScopedErrors(
+        full === null ? state.schemaErrors : pruneUnreported(state.schemaErrors, full),
+        scoped,
+        paths
+      ),
       state.schemaErrors
     ),
     serverErrors: omitScope(state.serverErrors, paths)
   });
-  const commitFieldErrors = (state, scoped, path) => path === "" ? commitFullPass(state, scoped) : commitScopedErrors(state, scoped, [path]);
+  const commitFieldErrors = (state, parse, path) => path === "" ? commitFullPass(state, parse.scoped) : commitScopedErrors(state, parse.scoped, [path], parse.full);
   const validateField = (path) => {
     warnMissingSchemaPath("validateField", path);
     const scope = fieldScopeFor(path, store.getState().values);
@@ -700,7 +821,7 @@ var createForm = (schema, options) => {
       return { kind: "pending", promise: validateFieldAsync(path) };
     }
     try {
-      const scoped = scope.kind === "skip" ? emptyErrors : scopeSettledResult(
+      const parse = scope.kind === "skip" ? noScopeErrors : scopeParse(
         validateSyncLatched(
           scope.viaSubschema ? path : "",
           scope.schema,
@@ -711,9 +832,9 @@ var createForm = (schema, options) => {
       );
       store.setState((state) => ({
         ...state,
-        ...commitFieldErrors(state, scoped, path)
+        ...commitFieldErrors(state, parse, path)
       }));
-      return fieldResult(scoped);
+      return fieldResult(parse.scoped);
     } catch (e) {
       if (isAsyncRequiredError(e)) {
         return { kind: "pending", promise: validateFieldAsync(path) };
@@ -723,11 +844,15 @@ var createForm = (schema, options) => {
   };
   const snapshotField = (state, path) => {
     const value = getAtPath(state.values, path);
+    const initialValue = getAtPath(state.initialValues, path);
+    const error = entryAt(state.errors, path);
     return {
       value,
-      error: entryAt(state.errors, path),
+      initialValue,
+      error,
+      firstError: error?.[0],
       touched: flagAt(state.touched, path),
-      dirty: isFieldDirty(value, getAtPath(state.initialValues, path)),
+      dirty: isFieldDirty(value, initialValue),
       isValidating: flagAt(state.isValidating, path)
     };
   };
@@ -741,7 +866,14 @@ var createForm = (schema, options) => {
     const pass = claimPass(FORM_SEQ_KEY);
     const valuesAtStart = store.getState().values;
     store.setState((state) => ({ ...state, isValidatingForm: true }));
-    const result = await validateAsync(schema, valuesAtStart);
+    const result = await validateAsync(schema, valuesAtStart).catch(
+      (error) => {
+        if (sequences.get(FORM_SEQ_KEY) === pass) {
+          store.setState((state) => ({ ...state, isValidatingForm: false }));
+        }
+        throw error;
+      }
+    );
     const live = store.getState();
     const stillOwns = sequences.get(FORM_SEQ_KEY) === pass;
     if (!stillOwns || live.values !== valuesAtStart) {
@@ -781,12 +913,15 @@ var createForm = (schema, options) => {
         ...Object.fromEntries(paths.map((p) => [p, true]))
       }
     }));
-    const parsed = allViaSubschema ? {
+    const parseBatch = async () => allViaSubschema ? {
       kind: "slots",
       byPath: new Map(
         await Promise.all(
           scopes.map(
-            async ({ path, scope }) => [path, await parseScopeAsync(path, scope)]
+            async ({ path, scope }) => [
+              path,
+              (await parseScopeAsync(path, scope)).scoped
+            ]
           )
         )
       )
@@ -796,6 +931,18 @@ var createForm = (schema, options) => {
         (result) => result.kind === "invalid" ? result.errors : emptyErrors
       )
     };
+    const parsed = await parseBatch().catch((error) => {
+      const stillOwned = new Set(
+        paths.filter((p) => sequences.get(p) === passes.get(p))
+      );
+      if (stillOwned.size > 0) {
+        store.setState((state) => ({
+          ...state,
+          isValidating: omitKeys(state.isValidating, stillOwned)
+        }));
+      }
+      throw error;
+    });
     const errorsFor = (path) => {
       switch (parsed.kind) {
         case "slots":
@@ -824,7 +971,15 @@ var createForm = (schema, options) => {
         Object.fromEntries(
           fresh.flatMap((path) => Object.entries(errorsFor(path)))
         ),
-        fresh
+        fresh,
+        // The prune map describes the values the batch STARTED with.
+        // A skip scope (an index into an empty array) still reads as
+        // fresh after an unrelated change, so a batch can commit under
+        // changed values; pruning with the stale map then dropped
+        // errors committed elsewhere in flight (an email error landing
+        // while a wizard step with such a path validated). The prune
+        // rides only while the whole values reference held.
+        parsed.kind === "full" && live.values === valuesAtStart ? parsed.errors : null
       ),
       isValidating: omitKeys(state.isValidating, ownedKeys)
     }));
@@ -845,24 +1000,32 @@ var createForm = (schema, options) => {
       ...state,
       isValidating: { ...state.isValidating, [path]: true }
     }));
-    const scoped = await parseScopeAsync(path, scope);
-    const live = store.getState();
-    const stillOwns = sequences.get(path) === pass;
-    if (!stillOwns || scopeStale(scope, path, valuesAtStart, live.values)) {
-      if (stillOwns) {
+    const releaseOwnFlag = () => {
+      if (sequences.get(path) === pass) {
         store.setState((state) => ({
           ...state,
           isValidating: omitKey(state.isValidating, path)
         }));
       }
-      return fieldResult(scoped);
+    };
+    const parse = await parseScopeAsync(path, scope).catch(
+      (error) => {
+        releaseOwnFlag();
+        throw error;
+      }
+    );
+    const live = store.getState();
+    const stillOwns = sequences.get(path) === pass;
+    if (!stillOwns || scopeStale(scope, path, valuesAtStart, live.values)) {
+      releaseOwnFlag();
+      return fieldResult(parse.scoped);
     }
     store.setState((state) => ({
       ...state,
-      ...commitFieldErrors(state, scoped, path),
+      ...commitFieldErrors(state, parse, path),
       isValidating: omitKey(state.isValidating, path)
     }));
-    return fieldResult(scoped);
+    return fieldResult(parse.scoped);
   };
   const applyArrayOp = (path, nextArray, mapper, indexInBounds) => {
     const current = getAtPath(store.getState().values, path);
@@ -921,7 +1084,9 @@ var createForm = (schema, options) => {
     count: 0,
     baseline: false
   };
-  const submit = async (onValid, onInvalid, submitOptions) => {
+  const submit = async (onValid, onInvalidOrOptions, positionalOptions) => {
+    const submitOptions = typeof onInvalidOrOptions === "object" ? onInvalidOrOptions : positionalOptions;
+    const onInvalid = typeof onInvalidOrOptions === "function" ? onInvalidOrOptions : submitOptions?.onInvalid;
     if (inFlight.count > 0 && submitOptions?.force !== true) {
       return { kind: "skipped" };
     }
@@ -962,6 +1127,7 @@ var createForm = (schema, options) => {
         try {
           onInvalid?.(merged);
         } catch (error) {
+          submitOptions?.onError?.(error);
           return { kind: "error", error };
         }
         return { kind: "invalid", errors: merged };
@@ -987,9 +1153,14 @@ var createForm = (schema, options) => {
       }
     }
   };
-  if (options.validateOnMount === true) {
-    validate();
-  }
+  const judgeBaseline = () => {
+    if (options.validateOnMount !== true) return;
+    const result = validate();
+    if (result.kind === "pending") {
+      void result.promise.catch(reportBackgroundFailure);
+    }
+  };
+  judgeBaseline();
   return Object.freeze({
     schema,
     store,
@@ -1004,8 +1175,12 @@ var createForm = (schema, options) => {
       return store.subscribe((state) => {
         const next = snapshotField(state, path);
         if (!shallowFieldEqual(ref.current, next)) {
+          const prev = ref.current;
           ref.current = next;
-          listener(next);
+          listener(
+            next,
+            prev
+          );
         }
       });
     },
@@ -1040,10 +1215,12 @@ var createForm = (schema, options) => {
       if (Object.is(getAtPath(currentValues, path), value) && (value !== void 0 || hasOwnSlot(currentValues, path))) {
         return;
       }
+      const next = setAtPath(currentValues, path, value, kindAt);
+      if (next === currentValues) return;
       clearArrayOpsUnder(store, path);
       store.setState((state) => ({
         ...state,
-        values: setAtPath(state.values, path, value, kindAt),
+        values: next,
         ...errorChannels(state, {
           serverErrors: releaseSpine(state.serverErrors, path)
         })
@@ -1081,7 +1258,7 @@ var createForm = (schema, options) => {
     },
     setErrors: (errors) => store.setState((state) => ({
       ...state,
-      ...errorChannels(state, { serverErrors: errors })
+      ...errorChannels(state, { serverErrors: dropEmptyLists(errors) })
     })),
     addErrors: (errors) => store.setState((state) => {
       const entries = Object.entries(errors);
@@ -1124,11 +1301,11 @@ var createForm = (schema, options) => {
       if (next.values !== state.values) {
         clearArrayOpsUnder(store, "");
       }
-      const serverErrors = patch.serverErrors !== void 0 ? patch.serverErrors : next.values !== state.values ? releaseChangedSlices(state.serverErrors, state.values, next.values) : state.serverErrors;
+      const serverErrors = patch.serverErrors !== void 0 ? dropEmptyLists(patch.serverErrors) : next.values !== state.values ? releaseChangedSlices(state.serverErrors, state.values, next.values) : state.serverErrors;
       store.setState(() => ({
         ...next,
         ...errorChannels(state, {
-          schemaErrors: next.schemaErrors,
+          schemaErrors: patch.schemaErrors === void 0 ? state.schemaErrors : dropEmptyLists(patch.schemaErrors),
           serverErrors
         })
       }));
@@ -1150,6 +1327,7 @@ var createForm = (schema, options) => {
         isValidating: emptyBools,
         isValidatingForm: false
       }));
+      judgeBaseline();
     },
     reset: (nextInitial, resetOptions) => {
       sequences.clear();
@@ -1174,6 +1352,7 @@ var createForm = (schema, options) => {
           isValidatingForm: false
         };
       });
+      if (resetOptions?.keepErrors !== true) judgeBaseline();
     },
     resetField: (path) => {
       const initialSlot = slotAtPath(
@@ -1237,9 +1416,14 @@ var createForm = (schema, options) => {
       swapIndices(a, b),
       (len) => Number.isInteger(a) && Number.isInteger(b) && a >= 0 && a < len && b >= 0 && b < len
     ),
-    handleSubmit: (onValid, onInvalid, opts) => async (event) => {
+    handleSubmit: (onValid, onInvalidOrOptions, positionalOptions) => async (event) => {
       event?.preventDefault();
-      const result = await submit(onValid, onInvalid, opts);
+      const opts = typeof onInvalidOrOptions === "object" ? onInvalidOrOptions : positionalOptions;
+      const result = await submit(
+        onValid,
+        onInvalidOrOptions,
+        positionalOptions
+      );
       if (result.kind === "error" && opts?.onError === void 0 && isDevBuild()) {
         console.warn(
           "[formstand] submit handler threw and nothing observed it \u2014 the form shows no feedback. Pass { onError } to handleSubmit (or setError inside your handler):",
@@ -1263,10 +1447,11 @@ var createForm = (schema, options) => {
     },
     snapshot: () => store.getState(),
     restore: (snap) => {
+      sequences.clear();
       clearArrayOpsUnder(store, "");
       store.setState(() => {
-        const schemaErrors = snap.schemaErrors ?? emptyErrors;
-        const serverErrors = snap.serverErrors ?? emptyErrors;
+        const schemaErrors = dropEmptyLists(snap.schemaErrors ?? emptyErrors);
+        const serverErrors = dropEmptyLists(snap.serverErrors ?? emptyErrors);
         return {
           ...snap,
           schemaErrors,
@@ -1313,11 +1498,13 @@ var createDebouncer = (ms) => {
   const timer = {
     current: null
   };
+  const scheduled = { current: null };
   const cancel = () => {
     if (timer.current !== null) {
       clearTimeout(timer.current);
       timer.current = null;
     }
+    scheduled.current = null;
   };
   const schedule = (run) => {
     cancel();
@@ -1325,37 +1512,50 @@ var createDebouncer = (ms) => {
       run();
       return;
     }
+    scheduled.current = run;
     timer.current = setTimeout(() => {
       timer.current = null;
+      scheduled.current = null;
       run();
     }, ms);
   };
+  const flush = () => {
+    const run = scheduled.current;
+    if (run === null) return;
+    cancel();
+    run();
+  };
   return Object.freeze({
     schedule,
     cancel,
+    flush,
     pending: () => timer.current !== null
   });
 };
 
 // src/core/persist.ts
 var kindOf = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
-var conflictsWith = (draft, reference) => {
-  if (draft === void 0 || draft === null) return false;
-  if (reference === void 0 || reference === null) return false;
+var joinPath = (base, key) => base === "" ? String(key) : `${base}.${String(key)}`;
+var conflictPath = (draft, reference, path, flexibleAt) => {
+  if (draft === void 0 || draft === null) return null;
+  if (reference === void 0 || reference === null) return null;
   const draftKind = kindOf(draft);
   const referenceKind = kindOf(reference);
-  if (draftKind !== referenceKind) return true;
+  if (draftKind !== referenceKind) return flexibleAt(path) ? null : path;
   if (draftKind === "array") {
     const [d] = draft;
     const [r] = reference;
-    return conflictsWith(d, r);
+    return conflictPath(d, r, joinPath(path, 0), flexibleAt);
   }
   if (draftKind === "object") {
     const d = draft;
     const r = reference;
-    return Object.keys(d).some((key) => conflictsWith(d[key], r[key]));
+    return Object.keys(d).reduce(
+      (found, key) => found ?? conflictPath(d[key], r[key], joinPath(path, key), flexibleAt),
+      null
+    );
   }
-  return false;
+  return null;
 };
 var defaultStorage = () => {
   try {
@@ -1368,7 +1568,49 @@ var persistForm = (form, options) => {
   const storage = options.storage ?? defaultStorage();
   const debounceMs = options.debounceMs ?? 300;
   const apply = options.apply ?? "adopt";
-  const applyDraft = (values) => apply === "edit" || apply === "restore" ? form.setValues(values) : form.adoptValues(values);
+  const schema = form.schema;
+  const fillRequiredGaps = (draft, initial, path) => {
+    if (!isPlainObject(draft) || !isPlainObject(initial)) return draft;
+    if (!isObjectSchemaAt(schema, path)) return draft;
+    return Object.keys(initial).reduce(
+      (acc, key) => {
+        const childPath = joinPath(path, key);
+        if (Object.hasOwn(draft, key)) {
+          const next = fillRequiredGaps(draft[key], initial[key], childPath);
+          return Object.is(next, draft[key]) ? acc : { ...acc, [key]: next };
+        }
+        if (initial[key] === void 0) return acc;
+        const sub = fieldSchemaForIntrospection(schema, childPath);
+        return sub !== null && schemaAcceptsUndefined(sub) ? acc : { ...acc, [key]: initial[key] };
+      },
+      draft
+    );
+  };
+  const applying = { current: false };
+  const applyDraft = (values) => {
+    const filled = fillRequiredGaps(
+      values,
+      form.getState().initialValues,
+      ""
+    );
+    applying.current = true;
+    try {
+      if (apply === "edit" || apply === "restore") {
+        form.setValues(filled);
+      } else {
+        form.adoptValues(filled);
+      }
+    } finally {
+      applying.current = false;
+    }
+  };
+  const isCurrent = (values) => {
+    try {
+      return JSON.stringify(values) === JSON.stringify(form.getState().values);
+    } catch {
+      return false;
+    }
+  };
   const referenceShape = () => {
     try {
       return JSON.parse(JSON.stringify(form.getState().initialValues));
@@ -1376,31 +1618,70 @@ var persistForm = (form, options) => {
       return void 0;
     }
   };
-  const load = () => {
+  const flexibleAt = (path) => schemaAllowsKindChangeAt(schema, path);
+  const inspect = (skipWhenCurrent) => {
+    const raw = (() => {
+      try {
+        return storage === null ? null : storage.getItem(options.key);
+      } catch {
+        return null;
+      }
+    })();
+    if (raw === null) return { kind: "absent" };
     try {
-      const raw = storage === null ? null : storage.getItem(options.key);
-      if (raw === null) return false;
       const parsed = JSON.parse(raw);
       const versioned = options.version !== void 0 && typeof parsed === "object" && parsed !== null && "__v" in parsed;
-      if (options.version !== void 0 && !versioned) return false;
+      if (options.version !== void 0 && !versioned) {
+        return {
+          kind: "ignored",
+          reason: `it carries no version and this configuration expects version ${String(options.version)}`
+        };
+      }
       if (options.version === void 0 && typeof parsed === "object" && parsed !== null && Object.hasOwn(parsed, "__v") && Object.hasOwn(parsed, "values")) {
-        return false;
+        return {
+          kind: "ignored",
+          reason: "it was written with a version and this configuration has none"
+        };
       }
       const wrapper = parsed;
-      if (versioned && wrapper.__v !== options.version) return false;
-      if (versioned && wrapper.values === void 0) return false;
+      if (versioned && wrapper.__v !== options.version) {
+        return {
+          kind: "ignored",
+          reason: `its version (${String(wrapper.__v)}) is not the configured version (${String(options.version)})`
+        };
+      }
+      if (versioned && wrapper.values === void 0) {
+        return { kind: "ignored", reason: "its version wrapper holds no values" };
+      }
       const values = versioned ? wrapper.values : parsed;
-      if (values === null || values === void 0) return false;
+      if (values === null || values === void 0) {
+        return { kind: "ignored", reason: "it holds no values" };
+      }
       const reference = referenceShape();
-      if (reference !== void 0 && conflictsWith(values, reference)) {
-        return false;
+      const conflict = reference === void 0 ? null : conflictPath(values, reference, "", flexibleAt);
+      if (conflict !== null) {
+        return {
+          kind: "ignored",
+          reason: `its shape conflicts with the form's initial values at "${conflict}" (set the version option when the schema changes)`
+        };
       }
+      if (skipWhenCurrent && isCurrent(values)) return { kind: "applied" };
       applyDraft(values);
-      return true;
+      return { kind: "applied" };
     } catch {
-      return false;
+      return { kind: "ignored", reason: "it is not valid JSON" };
+    }
+  };
+  const loadWith = (skipWhenCurrent) => {
+    const outcome = inspect(skipWhenCurrent);
+    if (outcome.kind === "ignored" && isDevBuild()) {
+      console.warn(
+        `[formstand] persistForm: ignored the draft under "${options.key}": ${outcome.reason}. The next edit overwrites it.`
+      );
     }
+    return outcome.kind === "applied";
   };
+  const load = () => loadWith(false);
   const writeDraft = (values) => {
     try {
       storage?.setItem(
@@ -1413,24 +1694,29 @@ var persistForm = (form, options) => {
     }
   };
   const writes = createDebouncer(debounceMs);
-  const cancelPending = () => writes.cancel();
   if (apply !== "manual") {
-    load();
+    loadWith(true);
   }
+  const cleared = { current: false };
   const unsubscribe = form.watchValues((values) => {
+    if (applying.current) return;
+    if (cleared.current && values === form.getState().initialValues) return;
+    cleared.current = false;
     writes.schedule(() => writeDraft(values));
   });
   return Object.freeze({
     load,
+    flush: () => writes.flush(),
     clear: () => {
-      cancelPending();
+      writes.cancel();
+      cleared.current = true;
       try {
         storage?.removeItem(options.key);
       } catch {
       }
     },
     dispose: () => {
-      cancelPending();
+      writes.flush();
       unsubscribe();
     }
   });
@@ -1442,17 +1728,31 @@ var usePersistForm = (form, options) => {
     latestOptions.current = options;
   });
   const key = options.key;
+  const hasStorage = options.storage !== void 0;
+  const storageProxy = react.useMemo(
+    () => ({
+      getItem: (k) => latestOptions.current.storage?.getItem(k) ?? null,
+      setItem: (k, v) => latestOptions.current.storage?.setItem(k, v),
+      removeItem: (k) => latestOptions.current.storage?.removeItem(k)
+    }),
+    []
+  );
   react.useEffect(() => {
-    const handle = persistForm(form, latestOptions.current);
+    const options2 = latestOptions.current;
+    const handle = persistForm(form, {
+      ...options2,
+      ...options2.storage === void 0 ? {} : { storage: storageProxy }
+    });
     inner.current = handle;
     return () => {
       inner.current = null;
       handle.dispose();
     };
-  }, [form, key]);
+  }, [form, key, hasStorage, storageProxy]);
   return react.useMemo(
     () => ({
       load: () => inner.current?.load() ?? false,
+      flush: () => inner.current?.flush(),
       clear: () => inner.current?.clear(),
       // dispose stops THIS component's watching early; the effect cleanup
       // still runs its own dispose harmlessly (persistForm's dispose is
@@ -1486,9 +1786,12 @@ var useForm = (schema, options) => {
 var hasFieldError = (error) => error !== void 0 && error.length > 0;
 var ariaInvalid = (field) => hasFieldError(field.error) ? true : void 0;
 var numberToInputText = (value) => value === void 0 || value === null || Number.isNaN(value) ? "" : String(value);
+var DECIMAL_TEXT = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
 var parseNumberText = (text) => {
-  if (text.trim() === "") return { kind: "empty" };
-  const parsed = Number(text);
+  const trimmed = text.trim();
+  if (trimmed === "") return { kind: "empty" };
+  if (!DECIMAL_TEXT.test(trimmed)) return { kind: "invalid" };
+  const parsed = Number(trimmed);
   return Number.isFinite(parsed) ? { kind: "number", value: parsed } : { kind: "invalid" };
 };
 var textInputProps = (field) => ({
@@ -1516,11 +1819,17 @@ var numberInputProps = (field) => ({
   onBlur: field.onBlur
 });
 var dateToInputText = (value) => {
-  if (value === void 0 || value === null || Number.isNaN(value.getTime())) {
-    return "";
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") {
+    const text = value;
+    const parsed = parseDateText(text);
+    if (parsed.kind === "date") return dateToInputText(parsed.value);
+    if (/^\d{4}-\d{2}-\d{2}$/.test(text.trim())) return "";
   }
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
   const pad = (part) => String(part).padStart(2, "0");
-  return `${String(value.getFullYear()).padStart(4, "0")}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+  return `${String(date.getFullYear()).padStart(4, "0")}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 };
 var parseDateText = (text) => {
   if (text.trim() === "") return { kind: "empty" };
@@ -1600,7 +1909,8 @@ var useMaskedInput = (field, options) => {
           field.setValue(parsed.value);
           return;
         case "empty": {
-          const empty = field.clearable || typeof field.initialValue !== "string" ? field.emptyValue : "";
+          const isStringField = typeof field.initialValue === "string" || typeof field.value === "string";
+          const empty = field.clearable || !isStringField ? field.emptyValue : "";
           setEdit({ raw: text, pushed: empty });
           field.setValue(empty);
           return;
@@ -1624,6 +1934,15 @@ function useFormSelectorShallow(form, selector) {
 }
 
 // src/react/useFormSteps.ts
+var settleOnLiveValues = async (form, fields, round = 0) => {
+  const before = fields.map((path) => form.getField(path));
+  const result = await form.validateFieldsAsync(fields);
+  const changed = fields.some(
+    (path, i) => !Object.is(form.getField(path), before[i])
+  );
+  if (!changed) return result;
+  return round < 3 ? settleOnLiveValues(form, fields, round + 1) : null;
+};
 var useFormSteps = (form, steps) => {
   const [step, setStep] = react.useState(0);
   const [visited, setVisited] = react.useState(
@@ -1637,7 +1956,8 @@ var useFormSteps = (form, steps) => {
     async (index) => {
       const definition = latest.current[index];
       if (definition === void 0) return true;
-      const result = await form.validateFieldsAsync(definition.fields);
+      const result = await settleOnLiveValues(form, definition.fields);
+      if (result === null) return false;
       if (result.kind === "invalid") {
         Object.keys(result.errors).forEach((key) => {
           form.setTouched(key, true);
@@ -1649,45 +1969,49 @@ var useFormSteps = (form, steps) => {
     [form]
   );
   const currentStep = react.useRef(step);
-  react.useEffect(() => {
-    currentStep.current = step;
-  });
+  const navigate = react.useCallback((target) => {
+    currentStep.current = target;
+    setStep(target);
+  }, []);
   const next = react.useCallback(async () => {
-    const ok = await validateStep(step);
+    const from = currentStep.current;
+    const ok = await validateStep(from);
     if (!ok) return false;
-    if (currentStep.current !== step) return false;
-    const target = Math.min(step + 1, latest.current.length - 1);
-    setStep(target);
+    if (currentStep.current !== from) return false;
+    const target = Math.max(0, Math.min(from + 1, latest.current.length - 1));
+    navigate(target);
     setVisited((prev) => /* @__PURE__ */ new Set([...prev, target]));
     return true;
-  }, [validateStep, step]);
+  }, [validateStep, navigate]);
   const back = react.useCallback(() => {
-    setStep((prev) => Math.max(prev - 1, 0));
-  }, []);
+    navigate(Math.max(currentStep.current - 1, 0));
+  }, [navigate]);
   const goTo = react.useCallback(
     async (target) => {
       const count = latest.current.length;
-      const clamped = Math.max(0, Math.min(target, count - 1));
-      if (clamped <= step) {
-        setStep(clamped);
+      if (!Number.isFinite(target)) return currentStep.current;
+      const from = currentStep.current;
+      const clamped = Math.max(0, Math.min(Math.trunc(target), count - 1));
+      if (clamped <= from) {
+        navigate(clamped);
         return clamped;
       }
-      const walk = async (from) => {
-        if (from >= clamped) return clamped;
-        return await validateStep(from) ? walk(from + 1) : from;
+      const walk = async (at) => {
+        if (at >= clamped) return clamped;
+        return await validateStep(at) ? walk(at + 1) : at;
       };
-      const landed = await walk(step);
-      if (currentStep.current !== step) return currentStep.current;
-      setStep(landed);
+      const landed = await walk(from);
+      if (currentStep.current !== from) return currentStep.current;
+      navigate(landed);
       setVisited(
         (prev) => /* @__PURE__ */ new Set([
           ...prev,
-          ...Array.from({ length: landed - step + 1 }, (_, i) => step + i)
+          ...Array.from({ length: landed - from + 1 }, (_, i) => from + i)
         ])
       );
       return landed;
     },
-    [validateStep, step]
+    [validateStep, navigate]
   );
   const errorFlags = useFormSelectorShallow(
     form,
@@ -1740,8 +2064,7 @@ var useFormAction = (form, onValid, options) => {
       const { onValid: handler, options: opts } = latest.current;
       const result = await form.submit(
         (data) => handler(data, formData),
-        opts?.onInvalid,
-        opts?.onError === void 0 ? void 0 : { onError: opts.onError }
+        opts ?? {}
       );
       warnUnobserved(result, opts, "useFormAction");
     },
@@ -1757,8 +2080,7 @@ var useFormActionState = (form, action, initialState, options) => {
         async (data) => {
           nextRef.current = await action(prev, data, formData);
         },
-        options?.onInvalid,
-        options?.onError === void 0 ? void 0 : { onError: options.onError }
+        options ?? {}
       );
       warnUnobserved(result, options, "useFormActionState");
       return nextRef.current;
@@ -1782,6 +2104,7 @@ var createFormContext = () => {
   return { Provider, useFormContext };
 };
 function useField(form, pathArg, options) {
+  const formSchema = form.schema;
   const slice = react$1.useStore(
     form.store,
     shallow.useShallow((state) => {
@@ -1797,25 +2120,26 @@ function useField(form, pathArg, options) {
         error: entryAt(state.errors, p),
         touched: flagAt(state.touched, p),
         dirty: isFieldDirty(value, initialValue2),
-        isValidating: flagAt(state.isValidating, p)
+        isValidating: flagAt(state.isValidating, p),
+        // Resolved inside the selector so a discriminant change re-reads
+        // the ACTIVE variant's wrapper for a key the variants share; the
+        // schema node is a stable reference, so the shallow compare holds.
+        schema: formSchema === void 0 ? null : fieldSchemaForIntrospection(formSchema, p, state.values)
       };
     })
   );
   const path = slice.path;
-  const formSchema = form.schema;
+  const sub = slice.schema;
   const initialValue = slice.initialValue;
   const { emptyValue, clearable } = react.useMemo(() => {
-    if (formSchema !== void 0) {
-      const sub = fieldSchemaForIntrospection(formSchema, path);
-      if (sub !== null) {
-        return {
-          emptyValue: emptyValueForSchema(sub),
-          clearable: isClearableSchema(sub)
-        };
-      }
+    if (sub !== null) {
+      return {
+        emptyValue: emptyValueForSchema(sub),
+        clearable: isClearableSchema(sub)
+      };
     }
     return initialValue === null ? { emptyValue: null, clearable: true } : { emptyValue: void 0, clearable: false };
-  }, [formSchema, path, initialValue]);
+  }, [sub, initialValue]);
   const debounceMs = options?.debounceMs;
   const debouncerRef = react.useRef(null);
   react.useEffect(() => {
@@ -1824,6 +2148,12 @@ function useField(form, pathArg, options) {
       debouncerRef.current = null;
     };
   }, [form, path, debounceMs]);
+  const validateNow = react.useCallback(() => {
+    const result = form.validateField(path);
+    if (result.kind === "pending") {
+      void result.promise.catch(reportBackgroundFailure);
+    }
+  }, [form, path]);
   const triggerValidate = react.useCallback(() => {
     if (debounceMs !== void 0 && debounceMs > 0) {
       const debouncer = debouncerRef.current ?? createDebouncer(debounceMs);
@@ -1835,12 +2165,12 @@ function useField(form, pathArg, options) {
         const rebased = state.values !== scheduledValues && state.values === state.initialValues;
         if (rebased) return;
         if (!Object.is(getAtPath(state.values, path), scheduled)) return;
-        void form.validateFieldAsync(path);
+        void form.validateFieldAsync(path).catch(reportBackgroundFailure);
       });
       return;
     }
-    form.validateField(path);
-  }, [form, path, debounceMs]);
+    validateNow();
+  }, [form, path, debounceMs, validateNow]);
   const setValue = react.useCallback(
     (value) => {
       const before = form.store.getState();
@@ -1889,9 +2219,10 @@ function useField(form, pathArg, options) {
       state.submitCount > 0,
       true
     )) {
-      triggerValidate();
+      debouncerRef.current?.cancel();
+      validateNow();
     }
-  }, [form, path, triggerValidate]);
+  }, [form, path, validateNow]);
   return react.useMemo(
     () => ({
       path: slice.path,
@@ -1918,10 +2249,11 @@ function useField(form, pathArg, options) {
 }
 
 // src/react/useVariantField.ts
-function useVariantField(form, unionPath, field) {
+function useVariantField(form, unionPath, field, options) {
   return useField(
     form,
-    `${unionPath}.${field}`
+    `${unionPath}.${field}`,
+    options
   );
 }
 var EMPTY_ITEMS = [];
@@ -2084,6 +2416,12 @@ function useFieldArray(form, pathArg) {
   const items = slice.items;
   const error = slice.error;
   const ids = deriveIds(form.store, path, items).ids;
+  const validateNow = react.useCallback(() => {
+    const result = form.validateField?.(path);
+    if (result?.kind === "pending") {
+      void result.promise.catch(reportBackgroundFailure);
+    }
+  }, [form, path]);
   const revalidate = react.useCallback(() => {
     const state = form.store.getState();
     if (shouldValidateOn(
@@ -2093,9 +2431,9 @@ function useFieldArray(form, pathArg) {
       state.submitCount > 0,
       flagAt(state.touched, path)
     )) {
-      form.validateField?.(path);
+      validateNow();
     }
-  }, [form, path]);
+  }, [form, path, validateNow]);
   const push = react.useCallback(
     (item) => {
       form.arrayPush(path, item);
@@ -2160,13 +2498,17 @@ function useFieldArray(form, pathArg) {
       state.submitCount > 0,
       true
     )) {
-      form.validateField?.(path);
+      validateNow();
     }
-  }, [form, path]);
+  }, [form, path, validateNow]);
   const validate = react.useCallback(
     () => form.validateField?.(path) ?? { kind: "valid" },
     [form, path]
   );
+  const validateAsync2 = react.useCallback(
+    () => form.validateFieldAsync?.(path) ?? Promise.resolve({ kind: "valid" }),
+    [form, path]
+  );
   const replace = react.useCallback(
     (next) => {
       form.setValue?.(path, next);
@@ -2176,7 +2518,15 @@ function useFieldArray(form, pathArg) {
   );
   const update = react.useCallback(
     (index, item) => {
-      form.setValue?.(`${path}.${index}`, item);
+      const current = getAtPath(form.store.getState().values, path);
+      const length = Array.isArray(current) ? current.length : 0;
+      if (!Number.isInteger(index) || index < 0 || index >= length) {
+        console.warn(
+          `[formstand] array op on "${path}" with an out-of-range or non-integer index (length ${String(length)}). Operation skipped.`
+        );
+        return;
+      }
+      form.setValue?.(`${path}.${String(index)}`, item);
       revalidate();
     },
     [form, path, revalidate]
@@ -2208,6 +2558,7 @@ function useFieldArray(form, pathArg) {
       setTouched,
       onBlur,
       validate,
+      validateAsync: validateAsync2,
       push,
       remove,
       insert,
@@ -2231,6 +2582,7 @@ function useFieldArray(form, pathArg) {
       setTouched,
       onBlur,
       validate,
+      validateAsync2,
       push,
       remove,
       insert,
@@ -2258,29 +2610,41 @@ var useFormError = (form) => react$1.useStore(
 function useFormValues(form) {
   return react$1.useStore(form.store, (state) => state.values);
 }
-
-// src/react/useFields.ts
-function useFields(form, paths) {
+function useFields(form, paths, options) {
+  const [arity] = react.useState(paths.length);
+  if (paths.length !== arity) {
+    throw new Error(
+      `[formstand] useFields: the paths tuple changed length (${String(arity)} to ${String(paths.length)}); its length and order must be stable across renders, so pass a literal or a module-level constant.`
+    );
+  }
   const fields = paths.map(
     (path) => (
       // eslint-disable-next-line react-hooks/rules-of-hooks -- a fixed hook count by the stable-arity contract above; each element must be a REAL UseFieldReturn so it spreads into the prop builders
-      useField(form, path)
+      useField(
+        form,
+        path,
+        options
+      )
     )
   );
-  const merged = [...new Set(fields.flatMap((field) => field.error ?? []))];
-  return {
-    fields,
-    error: merged.length > 0 ? merged : void 0,
-    firstError: merged[0],
-    touched: fields.some((field) => field.touched),
-    dirty: fields.some((field) => field.dirty),
-    isValidating: fields.some((field) => field.isValidating),
-    onBlur: () => {
-      fields.forEach((field) => {
-        field.onBlur();
-      });
-    }
-  };
+  return react.useMemo(() => {
+    const merged = [
+      ...new Set(fields.flatMap((field) => field.error ?? []))
+    ];
+    return {
+      fields,
+      error: merged.length > 0 ? merged : void 0,
+      firstError: merged[0],
+      touched: fields.some((field) => field.touched),
+      dirty: fields.some((field) => field.dirty),
+      isValidating: fields.some((field) => field.isValidating),
+      onBlur: () => {
+        fields.forEach((field) => {
+          field.onBlur();
+        });
+      }
+    };
+  }, fields);
 }
 function useIsDirty(form, path) {
   return react$1.useStore(
@@ -2323,10 +2687,11 @@ var capitalize = (name) => name.length === 0 ? name : name.charAt(0).toUpperCase
 var createFormHooks = (form, name) => {
   const structural = form;
   const useBoundField = (path, options) => useField(structural, path, options);
-  const useBoundVariantField = (unionPath, field) => useVariantField(
+  const useBoundVariantField = (unionPath, field, options) => useVariantField(
     structural,
     unionPath,
-    field
+    field,
+    options
   );
   const useBoundFieldArray = (path) => useFieldArray(structural, path);
   const useBoundVariantFieldArray = (unionPath, field) => useVariantFieldArray(
@@ -2342,12 +2707,16 @@ var createFormHooks = (form, name) => {
   const useBoundIsValidating = (path) => useIsValidating(structural, path);
   const useBoundIsSubmitting = () => useIsSubmitting(structural);
   const useBoundValues = () => useFormValues(structural);
-  const useBoundFields = (paths) => useFields(
+  const useBoundFields = (paths, options) => useFields(
     structural,
-    paths
+    paths,
+    options
   );
   const useBoundSubmitCount = () => useSubmitCount(structural);
   const useBoundSteps = (steps) => useFormSteps(form, steps);
+  const useBoundAction = (onValid, options) => useFormAction(form, onValid, options);
+  const useBoundActionState = (action, initialState, options) => useFormActionState(form, action, initialState, options);
+  const useBoundPersist = (options) => usePersistForm(form, options);
   const prefix = capitalize(name ?? "");
   return {
     [`use${prefix}Field`]: useBoundField,
@@ -2364,7 +2733,10 @@ var createFormHooks = (form, name) => {
     [`use${prefix}SubmitCount`]: useBoundSubmitCount,
     [`use${prefix}Values`]: useBoundValues,
     [`use${prefix}Fields`]: useBoundFields,
-    [`use${prefix}Steps`]: useBoundSteps
+    [`use${prefix}Steps`]: useBoundSteps,
+    [`use${prefix}Action`]: useBoundAction,
+    [`use${prefix}ActionState`]: useBoundActionState,
+    [`use${prefix}Persist`]: useBoundPersist
   };
 };
 var useFieldA11y = (error) => {
@@ -2388,7 +2760,7 @@ var FieldShell = ({
   wrapLabel,
   children
 }) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
-  wrapLabel === true ? /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "zf-label", children: [
+  wrapLabel === true && label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "zf-label", children: [
     children,
     " ",
     label