formstand 0.15.2 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,292 @@
 # Changelog
 
+## 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
+
+- **`useFields`: composite fields.** One control backed by several schema
+  paths (a coordinate pair behind a DMS input, a range, a date span)
+  binds them in one call: `useFields(form, ["latitude", "longitude"])`
+  returns the position-typed tuple of full field bindings plus the
+  combined view — `error` merged in path order and deduped (a
+  cross-field `superRefine` stamping both paths reads once),
+  `firstError`, any-of-them `touched`/`dirty`/`isValidating`, and one
+  `onBlur` covering every path. The paths tuple must be render-stable;
+  React itself throws its hooks-count error otherwise, at the exact
+  render that broke the contract.
+- **`field.firstError`.** The first error message or `undefined`, derived
+  on `UseFieldReturn` — the display shorthand every consumer (and every
+  generated kit adapter) re-derived by hand as `error?.[0]` with an
+  empty-array guard. `{field.firstError}` is now the whole helper line;
+  the full `field.error` array is unchanged beside it. The CLI keeps
+  emitting its own helper for now so generated code stays runnable on
+  older formstand; a future major of the generated adapters can lean on
+  this instead.
+
+### Fixed
+
+- **`useVariantField` accepts row-indexed union paths.** A discriminated
+  union that is an array's row item was unbindable: `UnionValueAt`
+  resolved paths through `keyof` only, so any array-index segment (a
+  template `` `pavements.${number}` `` or a literal `"pavements.0"`)
+  collapsed the variant-key set to `never` and the `field` argument
+  rejected everything. The type machinery now resolves the array element
+  through numeric segments, so a row component binds
+  `useVariantField(form, `` `pavements.${index}` ``, "designator")` fully
+  typed, in both the plain and the `createFormHooks`-bound flavors.
+  Runtime behavior was always correct; only the types refused. Found by
+  the airfield-maps trial, whose generated TODO pointed at exactly this
+  call.
+
+## formstand-cli 0.15.0 — 2026-09-16
+
+### Changed
+
+- **`--form-prop` is single-file only.** With `--layout module` the
+  fields are pre-wired to the module's own singleton, so the `form`
+  prop was decorative when it told the truth and silently split state
+  when it lied (the dev-mode guard existed to catch the lie). The CLI
+  now rejects the combination with the fix in the message: the page
+  already owns the module's form by importing the exported instance and
+  driving it directly. The wizard stops asking the question under the
+  module layout, and the playground's command builder disables the
+  checkbox. The programmatic `emitModuleForm` surface keeps the option
+  for callers who accept the singleton contract knowingly.
+
+### Fixed
+
+- **The array-row union TODO gives honest advice.** The single-file
+  spelling claimed the union was "not supported"; the module spelling
+  recommended a `useVariantField` call that did not typecheck before the
+  library fix above. Both now describe the working binding and name the
+  formstand 0.16+ floor for row-indexed union paths.
+
+## formstand-cli 0.14.0 — 2026-09-10
+
+### Added
+
+- **`component: "textarea"` in the config `fields` block.** The second
+  override flavor: a multi-line control for string fields, the binding
+  unchanged. Each kit renders its own control (mui `TextField multiline`,
+  mantine/chakra/shadcn `Textarea`, antd `Input.TextArea`, plain a native
+  `<textarea>`), and it composes with `span` in one entry, so a
+  `span: "full"` cover letter can finally look like one. `optionsProp`
+  and enum targets are rejected loudly.
+- **JSON Schema defaults and string formats reach the generated
+  validator.** A document `default` now emits `.default(value)` in the
+  generated zod schema beside the `initialValues` seed it already fed,
+  and `format: email`/`uri`/`uuid` emits `z.email()`/`z.url()`/
+  `z.uuid()` while the control stays a text field. The emitted schema is
+  the runtime source of truth, so it no longer drops contracts the
+  source document carried. Note zod's `.default()` makes the input
+  optional by design.
+
+### Fixed
+
+- **An optional union starts empty and its select can clear it.** An
+  optional/nullable discriminated union was seeded with its first
+  variant, so an untouched form submitted a variant the user never
+  chose, and the discriminant select offered no way back. The union now
+  starts `undefined`/`null`, and its select reads the discriminant but
+  writes the whole union: the empty choice clears it, a tag starts that
+  variant blank. mui's select gains an explicit None item; shadcn's
+  Radix select cannot hold an empty item, so there the fixed seed alone
+  closes the phantom-submit bug. Required unions are unchanged.
+- **Array add buttons read as the action they perform.** "Add
+  references" becomes "Add reference": a conservative singularizer on
+  the label's last word, with irregulars passing through unchanged.
+- **A union variant with one field no longer wraps it in a fragment.**
+
+## formstand-cli 0.13.0 — 2026-09-03
+
+### Added
+
+- **JSON Schema and OpenAPI inputs.** A `.json` input file is read as a
+  bare JSON Schema (2020-12) or an OpenAPI 3.x document: a third
+  front-end into the same IR, following type mode's path, so the CLI
+  generates the zod schema beside the component (`--schema-out` places
+  it; `--layout module` makes it the module's `schema.ts`). The new
+  `--schema` flag selects inside the document: a component schema name,
+  or a full `#/...` JSON pointer that can reach an operation's request
+  body. What translates: `properties`/`required`, `enum`/`const`,
+  `oneOf` string consts, discriminated `oneOf` into `useVariantField`
+  unions, `allOf` object merging, `$ref` chains, `prefixItems` tuples,
+  `format: date`/`date-time` as date fields, primitive `default`s into
+  `initialValues`, `description` as helper text, `title` as the label,
+  and every nullable dialect (3.1 type arrays, 3.0 `nullable: true`,
+  `oneOf` with a null branch). Everything else degrades to the loud TODO
+  fallback; Swagger 2.0 and YAML are refused with conversion hints. The
+  wizard understands `.json` inputs too, asking `--schema` in place of
+  the zod-or-type question.
+
+### Fixed
+
+- **A PascalCase schema export no longer collides with its module type
+  alias.** `export const MySchema` derives the form name MyForm, whose
+  schema type alias was also named MySchema, so the module barrel
+  exported two different MySchemas (the value from `schema.ts`, the type
+  from `types.ts`) and the generated `index.ts` failed to compile with
+  TS2308. The alias now yields the colliding name to the user's value
+  and becomes `MySchemaType`, both in `types.ts` and in the
+  `--form-prop` component that consumes it.
+
+## formstand-cli 0.12.0 — 2026-08-18
+
+### Added
+
+- **`--wizard`: the flag questions asked one at a time.** Which file, zod
+  export or TS type, which kit, layout, section chrome, columns, name, and
+  where to write — Enter accepts the default on every question, invalid
+  answers re-ask, and an existing output target offers `--force` on the
+  spot. The interview ends by printing the composed `formstand-gen`
+  command before running it, so the run is reproducible without the wizard
+  from then on. Strictly opt-in (never a TTY sniff, and the flag runs
+  alone), prompts on stderr so stdout output stays pipeable, answers
+  pipeable on stdin, and zero new dependencies: numbered readline lists,
+  not a prompts library.
+- **Per-field layout placement: `span` in the config `fields` block.** With
+  `--columns 2|3`, `"employment.notes": { span: "full" }` gives a field the
+  whole row and `{ span: 2 }` two of three columns; it composes with an
+  autocomplete override in the same entry. Each backend emits the span in
+  the dialect its section grids already use (mui `Grid` size objects, with
+  the legacy `item xs/sm` spelling on mui@5/6; mantine `Grid.Col` span
+  objects; antd `Col` `xs`/`sm`; shadcn `md:col-span-N`; chakra a `Box`
+  with responsive `gridColumn`), so every spelling still collapses to one
+  column on a phone. Plain is the one exception, for partial spans only:
+  inline styles cannot carry a media query, so a numeric span widens to the
+  full row with a comment saying so at the site. A span with no grid to act
+  on (a root-level field, array rows, a container, a 1-column form, or a
+  module-layout field below a section's direct children) is a loud
+  generation-time error, never a silent no-op.
+
+### Fixed
+
+- **Generated bodies indent under their real container.** Panel and
+  collapsible chrome nests the body's container deeper than the section tag
+  (Card > CardContent > Grid), but cells were emitted shallower than the
+  container holding them and array row stacks sat beside their wrapper
+  cells instead of inside them. Both layouts now shift bodies to the
+  chrome's true depth, so generated files survive a host Prettier pass
+  without reflowing. Cosmetic only; the demos regenerate with a
+  whitespace-only diff.
+- **A union riding a grid cell keeps its vertical rhythm.** Inside an
+  object section at `--columns 2|3`, a discriminated union's controls are
+  bare siblings in one full-row cell and had lost the spacing the 1-column
+  chrome provides; mui and mantine now wrap them in the kit's Stack. antd
+  needs no wrapper, since each of its controls is already a vertical Flex.
+
 ## 0.15.2 — 2026-08-11
 
 Identical to 0.15.1, republished under a fresh tag. The v0.15.1 tag was

package/dist/{createForm-jlzK2lCG.d.cts → createForm-D0xLZH-Q.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;
@@ -114,6 +122,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 +168,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 +178,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;

package/dist/{createForm-jlzK2lCG.d.ts → createForm-D0xLZH-Q.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;
@@ -114,6 +122,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 +168,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 +178,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;

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-D0xLZH-Q.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-D0xLZH-Q.js';
 import 'zustand/vanilla';
 
 type DevtoolsPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";