formstand 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,178 @@
 # Changelog
 
+## 0.18.0 — 2026-09-17
+
+### Changed
+
+- **`PersistHandle.restore()` is now `load()`** (breaking). The method's
+  DEFAULT application is `adoptValues` — a rebase that reads clean — and
+  the old name promised the setValues semantics it only has under
+  `apply: "restore"`. The name now describes what it does; the `apply`
+  mode names are unchanged. `usePersistForm`'s handle follows.
+- **Cleared inputs write `emptyValue` whenever the schema accepts it.**
+  `textInputProps`/`selectProps` (and the bound `TextField`/`SelectField`)
+  used to write the empty value only for nullable fields, so clearing
+  `z.string().optional()` left `""` behind — a documented asymmetry that
+  kept the field dirty against an `undefined` initial and made an optional
+  enum select unclearable. Clearing now writes `undefined` for optional
+  and defaulted fields and `null` for nullable ones; a REQUIRED string
+  cleared to `""` still stays `""`, so the schema judges a visible value
+  instead of a hole it rejects. `SelectField`'s empty option is
+  accordingly selectable for every clearable field, not just nullable
+  ones.
+
+### Added
+
+- **`field.clearable`** on `UseFieldReturn`: whether the schema accepts
+  the field's `emptyValue` (optional, nullable, or defaulted),
+  introspected from the zod schema with the same shallow walk as
+  `emptyValue` so the pair can never disagree. Schema-less forms fall
+  back to the null-initial heuristic. **`isClearableSchema(schema)`** is
+  the exported rule behind it, next to `emptyValueForSchema`.
+
+## formstand-cli 0.18.0 — 2026-09-17
+
+### Changed
+
+- **Generated kit adapters clear through `field.clearable`.** The
+  emitted text and select bindings wrote the empty value only for
+  nullable fields, mirroring the library's old rule; they now write
+  `field.emptyValue` whenever `field.clearable` says the schema accepts
+  it, so generated optional fields clear to `undefined` instead of
+  holding `""`. Kit output therefore needs formstand 0.18; regenerate
+  to pick the rule up, or keep the old adapter — both compile.
+
+## formstand-cli 0.17.0 — 2026-09-17
+
+### Added
+
+- **Containers inside array rows generate.** The remaining row-shape
+  TODO matrix is gone (formstand 0.17 types the paths): a tuple as the
+  row item or as a row-object field binds its positions inline at static
+  sub-indices (`points.${index}.0`, `segments.${index}.span.1`); a
+  discriminated union as a row-object FIELD binds on the holed template
+  (`invoices.${p0}.pay`), optional/nullable ones keeping the clearable
+  select; an array-of-arrays item extracts an inner Rows component; and
+  the same shapes under nested arrays work at any depth, union items
+  included (`teams.${p0}.methods.${index}`). Single-file extracts a
+  child component per site that needs hooks (rows render inside
+  rows.map); the module layout binds in the Row component, which already
+  is one. The one shape that still degrades to a TODO is a container
+  inside a union variant — binding it needs variant sub-paths the
+  library does not type.
+
+## 0.17.0 — 2026-09-17
+
+### Added
+
+- **`form.addErrors(errors)`.** The merge-many sibling of `setError`:
+  takes a server response's own runtime-keyed error map as-is and merges
+  it into the server channel — no per-key `FieldPath` cast, no
+  `setErrors` wholesale replacement. An empty array removes its key,
+  like `setError`. The docs' own examples now use it.
+- **`SubmitOptions.onError` and a dev-mode swallowed-failure warning.**
+  A throwing submit handler resolves `{kind: "error"}` writing no state
+  anywhere, so the fire-and-forget `handleSubmit` form could swallow a
+  save failure completely — button re-enables, zero feedback. `onError`
+  is the save-failure hook mirroring `onInvalid`, and dev builds warn
+  when an unobserved handler failure resolves without one.
+- **`useFieldArray` parity with its siblings.** The return gains `path`,
+  `firstError`, and the array-level server channel (`setError` /
+  `clearError`) — a "too many rows" verdict from the API is set and
+  cleared from the hook that owns the array. Custom `FieldArrayFormApi`
+  implementations opt in via the optional `setError`/`clearErrors`
+  members (same contract as the optional `validateField`).
+- **`useIsValidating(form, path?)`.** The boolean-only in-flight flag,
+  form-level (whole-form pass or any field) or scoped to a subtree —
+  previously reachable only through a selector, asymmetric with
+  `useIsSubmitting`.
+- **`usePersistForm(form, options)`.** The React lifecycle wrapper
+  `persistForm` was missing: owns the mount/dispose effect (StrictMode
+  safe), returns a reference-stable handle safe to close over in submit
+  handlers, and reads options when the subscription starts (the
+  `useForm` locked-options rule).
+- **`createFormHooks` binds the newer hooks.** `use{Name}Values`,
+  `use{Name}Fields` (position-typed like the plain `useFields`), and
+  `use{Name}IsValidating` join the factory.
+
+### Fixed
+
+- **`numberInputProps` keeps the value on a partial entry.** The
+  `type="number"` builder wrote `emptyValue` for BOTH empty and invalid
+  text, so a transient "-" or "1e" nulled the field mid-keystroke
+  (error flash, dirty flip) — diverging from `useNumberInput`'s
+  deliberate keep-the-value semantics. Invalid now keeps the stored
+  value; empty still clears. (Browsers report `""` for badInput on
+  number inputs, so `useNumberInput` remains the binding that preserves
+  every keystroke.)
+- **Tuples resolve positionally in the typed paths.** Tuples fell into
+  the generic-array arms of `FieldPath` and `UnionValueAt`, which union
+  every element — so nested paths under heterogeneous tuples were
+  rejected (`"hetero.0.a"` unbindable), out-of-range indices
+  (`"coord.5"`) accepted with a lying element type, and a discriminated
+  union below a tuple position unbindable through `useVariantField`.
+  Both types gained a tuple arm keyed on the literal indices; `"coord.0"`
+  spellings the CLI generates are unchanged.
+- **Platform containers are path leaves.** `File`/`Blob` (matched
+  structurally, so no DOM lib requirement), `Map`, `Set`, `WeakMap`,
+  `WeakSet`, `Promise`, and functions no longer descend as records:
+  bogus sub-paths like `"file.name"` or `"meta.size"` used to
+  type-check, and a `setValue` through one would have spread the
+  instance into a plain object.
+- **Literal dotted keys are no longer offered as paths.** A key named
+  `"a.b"` appeared in `FieldPath` but resolved to `never` (the runtime
+  walk splits on `"."`), so the offer was the lie; it is now excluded
+  where it is offered rather than where it resolves.
+- **`validateField` no longer crashes on prototype-key paths.** The
+  schema walk read the ZodObject shape with a bare index, so a
+  runtime-built path like `"user.constructor.x"` (server error fields
+  mapped onto `validateField`) resolved Object's constructor as a
+  "schema" and threw — and the subschema cache kept the poisoned entry.
+  Both walks now do own-key reads, like every other walk in the library.
+- **Persist discards version-downgrade drafts instead of adopting the
+  wrapper.** A draft written with `version: n` is a `{__v, values}`
+  wrapper; if the app later shipped without the `version` option, the
+  wrapper's keys evaded the shape guard and the wrapper OBJECT became
+  the form's values, then re-persisted. A versioned draft under a
+  version-less config is now discarded like any other draft the config
+  cannot vouch for.
+- **Debounced validation no longer survives `reset()`.** A pending
+  debounce timer fired after `reset()`/`adoptValues()` and re-committed
+  errors onto the pristine form. The fire now bails when the form is
+  pristine (values is the initialValues reference) or when the path's
+  value changed since scheduling; an unrelated field's edit inside the
+  window still lets the pending validation run.
+- **Array ops accept a null-valued nullable array.** `arrayPush` on a
+  `.nullable()` array field holding `null` warned and silently no-op'd,
+  while `undefined` created the array — even though the op item types
+  are built on `NonNullable<...>` precisely so nullable arrays accept
+  ops. Both empties now start the op from `[]`.
+
+### Changed
+
+- **Awaited async validation is typed settled.** `validateAsync` and
+  `validateFieldAsync` (and `useField`'s `validateAsync`) resolved a
+  union carrying a `"pending"` arm that can never occur — the promise IS
+  the pending state — forcing every exhaustive `switch` to carry a dead
+  case. All three now resolve the `Settled*` result types
+  `validateFieldsAsync` always had. A `switch` that handled `"pending"`
+  on an awaited result will now fail to compile; delete the dead arm.
+
+## formstand-cli 0.16.0 — 2026-09-16
+
+### Added
+
+- **Union array rows generate.** A discriminated union that is an
+  array's row item — the shape the airfield-maps trial hand-wrote — now
+  compiles to a `{Stem}Row` component per row instead of a TODO, in
+  both layouts: the discriminant and common fields bind with the field
+  hook, variant-only fields with the variant hook, all on the
+  row-indexed path (`methods.${index}`), with the same conditional
+  variant blocks, fragment elision, and hoisted number-props hooks a
+  static union gets. Needs formstand 0.16 for the row-indexed variant
+  path types. A union or tuple nested as a FIELD inside a row object,
+  and a tuple row item, keep their TODOs.
+
 ## 0.16.0 — 2026-09-16
 
 ### Added

package/dist/{createForm-jlzK2lCG.d.cts → createForm-B73p1TgL.d.cts}

@@ -1,9 +1,15 @@
 import { z } from 'zod';
 import { StoreApi } from 'zustand/vanilla';
 
-type LeafType = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp;
+type BlobLike = Readonly<{
+    size: number;
+    type: string;
+    arrayBuffer: () => Promise<unknown>;
+}>;
+type LeafType = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown> | ((...args: never[]) => unknown) | BlobLike;
 type IsRecord<T> = T extends LeafType ? false : T extends readonly unknown[] ? false : T extends object ? true : false;
 type IsArray<T> = T extends readonly unknown[] ? true : false;
+type IsTuple<T> = T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
 type Prev = [
     never,
     0,
@@ -37,8 +43,10 @@ type PathDepth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14
 type IsUnion<T, U = T> = [T] extends [never] ? false : T extends unknown ? [U] extends [T] ? false : true : never;
 type NormalizeDepth<D extends number> = number extends D ? DefaultPathDepth : [D] extends [PathDepth] ? IsUnion<D> extends true ? DefaultPathDepth : D : DefaultPathDepth;
 type FieldPath<T, D extends number = DefaultPathDepth> = FieldPathRec<T, NormalizeDepth<D>>;
-type FieldPathRec<T, D extends number> = [D] extends [0] ? never : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
-    [K in keyof T & string]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
+type FieldPathRec<T, D extends number> = [D] extends [0] ? never : IsTuple<T> extends true ? {
+    [K in keyof T & `${number}`]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
+}[keyof T & `${number}`] : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
+    [K in keyof T & string]: K extends `${string}.${string}` ? never : K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
 }[keyof T & string] : never;
 type StepValue<T, K extends string> = T extends readonly (infer U)[] ? K extends keyof T ? T[K] : K extends `${number}` ? U : never : T extends object ? K extends keyof T ? T[K] : never : never;
 type FieldValue<T, P extends string> = [T] extends [NonNullable<T>] ? P extends `${infer Head}.${infer Tail}` ? FieldValue<StepValue<T, Head>, Tail> : StepValue<T, P> : FieldValue<NonNullable<T>, P> | undefined;
@@ -100,6 +108,7 @@ declare const validateSync: <TSchema extends z.ZodType>(schema: TSchema, values:
 declare const validateAsync: <TSchema extends z.ZodType>(schema: TSchema, values: z.input<TSchema>) => Promise<SettledValidationResult<z.output<TSchema>>>;
 declare const isAsyncRequiredError: (e: unknown) => boolean;
 declare const emptyValueForSchema: (schema: z.ZodType) => null | undefined;
+declare const isClearableSchema: (schema: z.ZodType) => boolean;
 
 type ReadonlyStoreApi<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
 type CreateFormOptions<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
@@ -114,6 +123,7 @@ type SubmitHandler<TSchema extends z.ZodType> = (data: z.output<TSchema>) => voi
 type InvalidSubmitHandler = (errors: ErrorMap) => void;
 type SubmitOptions = Readonly<{
     force?: boolean;
+    onError?: (error: unknown) => void;
 }>;
 type SubmitResult<TOutput> = Readonly<{
     kind: "valid";
@@ -159,6 +169,7 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
     setReValidateMode: (mode: ValidationMode) => void;
     setError: (path: ErrorPath<z.input<TSchema>, D>, errors: string | readonly string[]) => void;
     setErrors: (errors: ErrorMap) => void;
+    addErrors: (errors: ErrorMap) => void;
     clearErrors: (path?: ErrorPath<z.input<TSchema>, D>) => void;
     updateState: (updater: (state: FormState<z.input<TSchema>>) => Partial<Omit<FormState<z.input<TSchema>>, "errors">>) => void;
     reset: (nextInitial?: Partial<z.input<TSchema>>, options?: ResetOptions) => void;
@@ -168,8 +179,8 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
     validate: () => ValidationResult<z.output<TSchema>>;
     validateField: (path: ErrorPath<z.input<TSchema>, D>) => FieldValidationResult;
     validateFields: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => FieldsValidationResult;
-    validateAsync: () => Promise<ValidationResult<z.output<TSchema>>>;
-    validateFieldAsync: (path: ErrorPath<z.input<TSchema>, D>) => Promise<FieldValidationResult>;
+    validateAsync: () => Promise<SettledValidationResult<z.output<TSchema>>>;
+    validateFieldAsync: (path: ErrorPath<z.input<TSchema>, D>) => Promise<SettledFieldValidationResult>;
     validateFieldsAsync: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => Promise<SettledFieldsValidationResult>;
     submit: (onValid: SubmitHandler<TSchema>, onInvalid?: InvalidSubmitHandler, options?: SubmitOptions) => Promise<SubmitResult<z.output<TSchema>>>;
     arrayPush: <P extends FieldPath<z.input<TSchema>, D>>(path: P, item: ArrayItemOf<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
@@ -187,4 +198,4 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
 }>;
 declare const createForm: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>(schema: TSchema, options: CreateFormOptions<TSchema, D>) => Form<TSchema, D>;
 
-export { type BoolMap as B, type CreateFormOptions as C, type DefaultPathDepth as D, type ErrorMap as E, type Form as F, type InvalidSubmitHandler as I, type PathDepth as P, type ReadonlyStoreApi as R, type SettledFieldValidationResult as S, type ValidationMode as V, type FieldValidationResult as a, type FormState as b, type FieldPath as c, type FieldValue as d, type FieldSnapshot as e, type FieldsValidationResult as f, type ResetOptions as g, type SettledFieldsValidationResult as h, type SettledValidationResult as i, type SubmitHandler as j, type SubmitOptions as k, type SubmitResult as l, type ValidationResult as m, type ValidationTrigger as n, createForm as o, emptyValueForSchema as p, flattenIssues as q, isAsyncRequiredError as r, shouldValidateOn as s, validateSync as t, validateAsync as v };
+export { type BoolMap as B, type CreateFormOptions as C, type DefaultPathDepth as D, type ErrorMap as E, type Form as F, type InvalidSubmitHandler as I, type PathDepth as P, type ReadonlyStoreApi as R, type SettledFieldValidationResult as S, type ValidationMode as V, type FieldValidationResult as a, type FormState as b, type FieldPath as c, type FieldValue as d, type FieldSnapshot as e, type FieldsValidationResult as f, type ResetOptions as g, type SettledFieldsValidationResult as h, type SettledValidationResult as i, type SubmitHandler as j, type SubmitOptions as k, type SubmitResult as l, type ValidationResult as m, type ValidationTrigger as n, createForm as o, emptyValueForSchema as p, flattenIssues as q, isAsyncRequiredError as r, isClearableSchema as s, shouldValidateOn as t, validateSync as u, validateAsync as v };

package/dist/{createForm-jlzK2lCG.d.ts → createForm-B73p1TgL.d.ts}

@@ -1,9 +1,15 @@
 import { z } from 'zod';
 import { StoreApi } from 'zustand/vanilla';
 
-type LeafType = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp;
+type BlobLike = Readonly<{
+    size: number;
+    type: string;
+    arrayBuffer: () => Promise<unknown>;
+}>;
+type LeafType = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown> | ((...args: never[]) => unknown) | BlobLike;
 type IsRecord<T> = T extends LeafType ? false : T extends readonly unknown[] ? false : T extends object ? true : false;
 type IsArray<T> = T extends readonly unknown[] ? true : false;
+type IsTuple<T> = T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
 type Prev = [
     never,
     0,
@@ -37,8 +43,10 @@ type PathDepth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14
 type IsUnion<T, U = T> = [T] extends [never] ? false : T extends unknown ? [U] extends [T] ? false : true : never;
 type NormalizeDepth<D extends number> = number extends D ? DefaultPathDepth : [D] extends [PathDepth] ? IsUnion<D> extends true ? DefaultPathDepth : D : DefaultPathDepth;
 type FieldPath<T, D extends number = DefaultPathDepth> = FieldPathRec<T, NormalizeDepth<D>>;
-type FieldPathRec<T, D extends number> = [D] extends [0] ? never : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
-    [K in keyof T & string]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
+type FieldPathRec<T, D extends number> = [D] extends [0] ? never : IsTuple<T> extends true ? {
+    [K in keyof T & `${number}`]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
+}[keyof T & `${number}`] : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
+    [K in keyof T & string]: K extends `${string}.${string}` ? never : K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
 }[keyof T & string] : never;
 type StepValue<T, K extends string> = T extends readonly (infer U)[] ? K extends keyof T ? T[K] : K extends `${number}` ? U : never : T extends object ? K extends keyof T ? T[K] : never : never;
 type FieldValue<T, P extends string> = [T] extends [NonNullable<T>] ? P extends `${infer Head}.${infer Tail}` ? FieldValue<StepValue<T, Head>, Tail> : StepValue<T, P> : FieldValue<NonNullable<T>, P> | undefined;
@@ -100,6 +108,7 @@ declare const validateSync: <TSchema extends z.ZodType>(schema: TSchema, values:
 declare const validateAsync: <TSchema extends z.ZodType>(schema: TSchema, values: z.input<TSchema>) => Promise<SettledValidationResult<z.output<TSchema>>>;
 declare const isAsyncRequiredError: (e: unknown) => boolean;
 declare const emptyValueForSchema: (schema: z.ZodType) => null | undefined;
+declare const isClearableSchema: (schema: z.ZodType) => boolean;
 
 type ReadonlyStoreApi<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
 type CreateFormOptions<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
@@ -114,6 +123,7 @@ type SubmitHandler<TSchema extends z.ZodType> = (data: z.output<TSchema>) => voi
 type InvalidSubmitHandler = (errors: ErrorMap) => void;
 type SubmitOptions = Readonly<{
     force?: boolean;
+    onError?: (error: unknown) => void;
 }>;
 type SubmitResult<TOutput> = Readonly<{
     kind: "valid";
@@ -159,6 +169,7 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
     setReValidateMode: (mode: ValidationMode) => void;
     setError: (path: ErrorPath<z.input<TSchema>, D>, errors: string | readonly string[]) => void;
     setErrors: (errors: ErrorMap) => void;
+    addErrors: (errors: ErrorMap) => void;
     clearErrors: (path?: ErrorPath<z.input<TSchema>, D>) => void;
     updateState: (updater: (state: FormState<z.input<TSchema>>) => Partial<Omit<FormState<z.input<TSchema>>, "errors">>) => void;
     reset: (nextInitial?: Partial<z.input<TSchema>>, options?: ResetOptions) => void;
@@ -168,8 +179,8 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
     validate: () => ValidationResult<z.output<TSchema>>;
     validateField: (path: ErrorPath<z.input<TSchema>, D>) => FieldValidationResult;
     validateFields: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => FieldsValidationResult;
-    validateAsync: () => Promise<ValidationResult<z.output<TSchema>>>;
-    validateFieldAsync: (path: ErrorPath<z.input<TSchema>, D>) => Promise<FieldValidationResult>;
+    validateAsync: () => Promise<SettledValidationResult<z.output<TSchema>>>;
+    validateFieldAsync: (path: ErrorPath<z.input<TSchema>, D>) => Promise<SettledFieldValidationResult>;
     validateFieldsAsync: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => Promise<SettledFieldsValidationResult>;
     submit: (onValid: SubmitHandler<TSchema>, onInvalid?: InvalidSubmitHandler, options?: SubmitOptions) => Promise<SubmitResult<z.output<TSchema>>>;
     arrayPush: <P extends FieldPath<z.input<TSchema>, D>>(path: P, item: ArrayItemOf<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
@@ -187,4 +198,4 @@ type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = R
 }>;
 declare const createForm: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>(schema: TSchema, options: CreateFormOptions<TSchema, D>) => Form<TSchema, D>;
 
-export { type BoolMap as B, type CreateFormOptions as C, type DefaultPathDepth as D, type ErrorMap as E, type Form as F, type InvalidSubmitHandler as I, type PathDepth as P, type ReadonlyStoreApi as R, type SettledFieldValidationResult as S, type ValidationMode as V, type FieldValidationResult as a, type FormState as b, type FieldPath as c, type FieldValue as d, type FieldSnapshot as e, type FieldsValidationResult as f, type ResetOptions as g, type SettledFieldsValidationResult as h, type SettledValidationResult as i, type SubmitHandler as j, type SubmitOptions as k, type SubmitResult as l, type ValidationResult as m, type ValidationTrigger as n, createForm as o, emptyValueForSchema as p, flattenIssues as q, isAsyncRequiredError as r, shouldValidateOn as s, validateSync as t, validateAsync as v };
+export { type BoolMap as B, type CreateFormOptions as C, type DefaultPathDepth as D, type ErrorMap as E, type Form as F, type InvalidSubmitHandler as I, type PathDepth as P, type ReadonlyStoreApi as R, type SettledFieldValidationResult as S, type ValidationMode as V, type FieldValidationResult as a, type FormState as b, type FieldPath as c, type FieldValue as d, type FieldSnapshot as e, type FieldsValidationResult as f, type ResetOptions as g, type SettledFieldsValidationResult as h, type SettledValidationResult as i, type SubmitHandler as j, type SubmitOptions as k, type SubmitResult as l, type ValidationResult as m, type ValidationTrigger as n, createForm as o, emptyValueForSchema as p, flattenIssues as q, isAsyncRequiredError as r, isClearableSchema as s, shouldValidateOn as t, validateSync as u, validateAsync as v };

package/dist/devtools/index.d.cts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { z } from 'zod';
-import { F as Form } from '../createForm-jlzK2lCG.cjs';
+import { F as Form } from '../createForm-B73p1TgL.cjs';
 import 'zustand/vanilla';
 
 type DevtoolsPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";

package/dist/devtools/index.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { z } from 'zod';
-import { F as Form } from '../createForm-jlzK2lCG.js';
+import { F as Form } from '../createForm-B73p1TgL.js';
 import 'zustand/vanilla';
 
 type DevtoolsPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";