react-f0rm 1.3.0 → 1.5.0

package/dist/index.d.ts

@@ -1,127 +1,74 @@
-import { a as FieldError, F as Form$1, P as Path, b as FieldPath, c as PathSegments, d as PathValueOf, N as Name, V as ValidationMode, e as FieldErrorEntry, O as Options, f as FormEvents } from './form-CeKSBs31.js';
-export { g as FORM_ERROR, h as FormValidateFn, i as FormValidateMeta, j as PathValue, R as ReValidateMode, S as SetErrorOptions, k as SetFocusOptions, l as SetServerErrorsOptions, m as VALIDATION_OUTCOME, n as ValidateResult, o as ValidationOutcome, p as clearErrors, q as createForm, r as getError, s as getErrorByPath, t as getErrors, u as getFieldErrors, v as getFieldErrorsByPath, w as getFirstError, x as hasErrors, y as setError, z as setErrorByPath, A as setFocus, B as setServerErrors } from './form-CeKSBs31.js';
+import { a as FieldRules, f as FieldError, F as Form$1, P as Path, A as AnyPath, g as PathValueOf, N as Name, h as ValidationMode, R as RegisterOptions, i as RegisterProps, b as FieldErrorEntry, V as Validator, S as StandardSchemaV1, j as FieldPath, k as FieldErrors, l as FieldErrorsTree, O as Options, m as FormEvents } from './standard-schema-BAaTmAHh.js';
+export { e as ArrayItemOf, D as DottedPath, n as FORM_ERROR, o as FormMessages, p as FormValidateFn, q as FormValidateMeta, r as FormValidateMode, s as FormValidationError, I as InferSchemaValues, t as OpaqueTypes, u as PathSegments, v as PathValue, w as ReValidateMode, x as SetErrorOptions, y as SetFocusOptions, z as SetServerErrorsOptions, B as SyncValidator, T as TriggerOptions, c as VALIDATION_OUTCOME, C as ValidateResult, d as ValidationOutcome, E as ValidatorOutput, G as ValidatorRegistration, H as clearErrors, J as clearServerErrors, K as createForm, L as dottedKeyToFieldPath, M as ensureValidate, Q as fieldPathToDottedKey, U as getError, W as getErrorByPath, X as getErrors, Y as getErrorsRecord, Z as getErrorsTree, _ as getFieldErrors, $ as getFieldErrorsByPath, a0 as getFirstError, a1 as hasErrors, a2 as registerFieldValidateDeps, a3 as registerValidatorByPath, a4 as revalidateDependentsOnChange, a5 as revalidateFormOnChange, a6 as runFormValidate, a7 as setError, a8 as setErrorByPath, a9 as setFocus, aa as setServerErrors, ab as setValidatingByPath, ac as shouldKick, ad as trigger, ae as unregisterFieldValidateDeps, af as unsetValidatingByPath, ag as validate } from './standard-schema-BAaTmAHh.js';
 import { EventEmitter } from '@for-fun/event-emitter';
 export { EventEmitter } from '@for-fun/event-emitter';
 import * as React from 'react';
-import { ReactNode } from 'react';
-import { S as SyncValidator, V as Validator } from './validate-nksgv1pR.js';
-export { F as FormValidationError, T as TriggerOptions, a as ValidatorRegistration, e as ensureValidate, r as registerFieldValidateDeps, b as registerValidatorByPath, c as revalidateDependentsOnChange, d as revalidateFormOnChange, f as runFormValidate, s as setValidatingByPath, t as trigger, u as unregisterFieldValidateDeps, g as unsetValidatingByPath, v as validate } from './validate-nksgv1pR.js';
+import { Context, Provider, ReactNode } from 'react';
+export { a as appendValue, c as appendValueByPath, i as insertValue, d as insertValueByPath, m as moveValue, e as moveValueByPath, p as prependValue, f as prependValueByPath, r as removeValue, g as removeValueByPath, b as replaceValues, h as replaceValuesByPath, s as swapValues, j as swapValuesByPath, u as updateValue, k as updateValueByPath } from './array-Bu7W8BSz.js';
 
-/**
- * Get form values: the values Map layered over parsedValues (when a schema
- * validation produced them) layered over initialValues.
- *
- * Merged with copy-on-write ownership tracking ({@link setOwned}): every
- * distinct container on a written path is allocated once and shared by all
- * paths through it, instead of re-copying the whole branch for every key.
- * One owned set spans the whole merge, so containers borrowed from the
- * parsedValues tree are copied before mutation exactly like initialValues
- * ones. The result is a freshly merged tree per mutation, with untouched
- * branches sharing references with the baseline exactly like chained
- * `set` did.
- *
- * Memoized per form like {@link getDirtyFields}: every value write bumps a
- * `version` counter ({@link bumpValuesVersion}) while reads reset it, so
- * consecutive reads hand back the same reference (submit, changeValue and
- * form-level validate all read the whole tree, often several times per
- * interaction). Treat the result as read-only — the next read after a
- * write returns a fresh tree, but between writes the cached one is shared
- * with every other reader.
- *
- * parsedValues is the schema's complete output tree: once validation
- * succeeds it replaces the initialValues baseline (fields the schema
- * dropped disappear), while live edits in the values Map still win over
- * both. It never affects dirty state — {@link isDirty} and
- * {@link getDirtyFields} compare live edits against initialValues only,
- * because parsing is not a user edit.
- *
- * @param form
- */
+/** Option spellings shared across the field, field-array and validator
+ * hooks — private to the hooks slice, never part of the public facade. */
+type FieldOptionBase = {
+    /** Declarative rules compiled into a sync validator. */
+    rules?: FieldRules;
+    /** Whether unmounting removes the branch; defaults to the form-level
+     * `shouldUnregister` (tombstone). `false` keeps the values. */
+    shouldUnregister?: boolean;
+    /** Keep the debounced validator running when the sync gate failed
+     * (TanStack `asyncAlways`): gate errors land immediately, the
+     * validator's result lands alongside them per-source. */
+    asyncAlways?: boolean;
+    /** Validate once on mount (overrides the form-level flag in either
+     * direction). Deferred while async `initialValues` is pending. */
+    validateOnMount?: boolean;
+};
+
+/** Get form values: the values Map layered over parsedValues (when a
+ * schema validation produced them) over initialValues. Merged with
+ * copy-on-write ownership tracking ({@link setOwned}), so untouched
+ * branches share references with the baseline. Memoized per form via a
+ * version-bump/read counter ({@link bumpValuesVersion}): consecutive reads
+ * hand back the same reference; treat it as read-only. parsedValues never
+ * affects dirty state — dirty compares live edits against initialValues. */
 declare function getValues<T extends Record<string, any> = any>(form: Form$1<T>): T;
-/**
- * Get field value
- * @param form
- * @param name
- */
-declare function getValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): PathValueOf<T, P>;
-/**
- * Get field value by path
- * @param form
- * @param path
- */
+/** Get a field's value. */
+declare function getValue<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): PathValueOf<T, P>;
+/** Get a field's value by path. */
 declare function getValueByPath({ initialValues, parsedValues, values, deleted }: Form$1, path: Path): any;
 /** Options accepted by {@link setValue} / {@link setValueByPath} / {@link
  * changeValue} / {@link changeValueByPath}. `shouldValidate`/`shouldTouch`
- * default to `false`; omitting the options object entirely keeps the plain
- * set-value behavior (no validation, no touched marking, dirty stays
- * derived). */
+ * default to `false`. */
 type SetFieldOptions = {
-    /** Run the field's registered validator (if any) after the value lands,
-     * same as triggering that single field. Defaults to `false`. */
+    /** Run the field's registered validator (if any) after the value lands.
+     * Defaults to `false`. */
     shouldValidate?: boolean;
     /** Mark the field as touched. Defaults to `false`. */
     shouldTouch?: boolean;
-    /** Land the value as a commit instead of an edit: the value becomes the
-     * field's dirty-comparison baseline, so `getDirtyFields`/`isDirty`/
-     * `getFieldState().isDirty` read the field as clean, and a later write
-     * dirties it only by differing from the new baseline. `true` (or
-     * omitting the flag) keeps the default derived behavior — dirty while
-     * the live value differs from initialValues. */
+    /** Land the value as a commit instead of an edit: it becomes the field's
+     * dirty-comparison baseline. `true` (or omitting) keeps the default
+     * derived behavior — dirty while the live value differs from
+     * initialValues. */
     shouldDirty?: boolean;
 };
-/**
- * Set field value. The value may also be an updater function receiving
- * the field's current value and returning the next one (TanStack Form's
- * `setFieldValue` contract) — handy for increments and array transforms:
- * `setValue(form, 'count', c => c + 1)`. The tradeoff: a function can
- * never itself be stored as a field value through this function.
- * @param form
- * @param name
- * @param value
- * @param options
- */
-declare function setValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, value: PathValueOf<T, P> | ((prev: PathValueOf<T, P>) => PathValueOf<T, P>), options?: SetFieldOptions): void;
-/**
- * Set field value. The value may also be an updater function receiving
- * the field's current value and returning the next one (TanStack Form's
- * `setFieldValue` contract) — note that a function can therefore never
- * itself be stored as a field value through this function.
- * @param form
- * @param path
- * @param value
- * @param options
- */
+/** Set a field's value. `value` may be an updater function receiving the
+ * current value and returning the next (TanStack Form's `setFieldValue`
+ * contract) — so a function can never itself be stored as a value. */
+declare function setValue<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P, value: PathValueOf<T, P> | ((prev: PathValueOf<T, P>) => PathValueOf<T, P>), options?: SetFieldOptions): void;
+/** Set a field's value by path. `value` may be an updater function (see
+ * {@link setValue}). */
 declare function setValueByPath(form: Form$1, path: Path, value: any | ((prev: any) => any), options?: SetFieldOptions): void;
-/**
- * The write of {@link setValueByPath} minus the `'change'` emit: the
- * render-time {@link useField} `initialValue` seed. The field's first
- * paint (SSR included — effects never run on the server) must already
- * carry the value, so the write happens during render where emitting is
- * illegal; the seeding field announces it from its post-commit effect
- * through {@link emitChangeByPath} instead.
- *
- * Everything else matches a plain write: descendant keys of the seeded
- * path are pruned, the branch's tombstones and committed baselines are
- * revived/dropped, and both memo caches are invalidated. Like the effect
- * seed it replaces, the caller guards it to paths with no value yet.
- */
+/** The write of {@link setValueByPath} minus the `'change'` emit: the
+ * render-time `useField` `initialValue` seed. The field's first paint
+ * (SSR included) must already carry the value, so the write happens during
+ * render where emitting is illegal; the field announces it post-commit via
+ * {@link emitChangeByPath}. */
 declare function seedValueByPath(form: Form$1, path: Path, value: any): void;
 /** Announce a {@link seedValueByPath} that happened during render: the
  * payload-carrying `'change'` emit {@link setValueByPath} would have
- * fired, split out so it can run post-commit where emitting is safe.
- * Subscribers that rendered after the seed re-read an unchanged snapshot
- * and bail; subscribers from earlier commits resync. */
+ * fired, split out so it runs post-commit where emitting is safe. */
 declare function emitChangeByPath({ emitter }: Form$1, path: Path): void;
-/** Per-form registry of mounted fields' validation-mode overrides: path
- * key -> the field's `mode` option (undefined = follow {@link Form.mode})
- * plus an owner token so competing mounts at one path clean up safely.
- * Presence of an entry is the "a field is mounted at this path" signal
- * that routes {@link changeValueByPath} into the gated user-change
- * pipeline ({@link userChangeByPath}). Held in a WeakMap so the Form
- * shape carries only plain state fields. */
-/** Snapshot of one field's aggregated state, as {@link getFieldState}
- * returns it. `errors` is the stored array shared with the form — treat it
- * as read-only, like every {@link getFieldErrors} result. */
+/** One field's aggregated state, as {@link getFieldState} returns it.
+ * `errors` is the stored array shared with the form — treat it read-only. */
 type FieldState<T = any> = {
     value: T;
     error: FieldError | undefined;
@@ -130,42 +77,18 @@ type FieldState<T = any> = {
     isTouched: boolean;
     isValidating: boolean;
 };
-/**
- * Get one field's aggregated state: the layered value ({@link getValue}),
- * the first error ({@link getError}) and every error ({@link
- * getFieldErrors}), dirtiness, the touched flag, and whether a validator
- * is in flight. `isDirty` applies the same per-field rule as {@link
- * getDirtyFields}: a live value exists and differs from initialValues at
- * that path (parsedValues never counts — parsing is not an edit).
- *
- * @param form
- * @param name
- */
-declare function getFieldState<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): FieldState<PathValueOf<T, P>>;
-/**
- * Remove a field: by default its live value drops out of reads and
- * `getValues()` (the path is tombstoned, so it never falls back to
- * initialValues), its dirty baseline, touched flag and errors are cleared.
- * The keep-flags preserve slices of that state instead.
- *
- * @param form
- * @param name
- */
-/**
- * Options accepted by {@link removeField}. All flags default to `false` —
+/** Get one field's aggregated state: layered value, first/every error,
+ * dirtiness, touched flag, and validating flag. `isDirty` applies the same
+ * per-field rule as {@link getDirtyFields}. */
+declare function getFieldState<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): FieldState<PathValueOf<T, P>>;
+/** Options accepted by {@link removeField}. All flags default to `false` —
  * the historical remove semantics (value dropped, path tombstoned, dirty
- * baseline/touched/errors cleared). Names mirror react-hook-form's
- * `unregister` options to ease migration; RHF's `shouldValidate` and
- * `keepDefaultValue` have no counterparts (removal never validates, and
- * the tombstone is exactly the "do not revive from initialValues" choice).
- */
+ * baseline/touched/errors cleared). */
 type RemoveFieldOptions = {
     /** Keep the field's live value and dirty baseline instead of
-     * tombstoning: reads and `getValues()` keep returning the value, submit
-     * includes it, and dirtiness against initialValues is preserved. */
+     * tombstoning: reads, `getValues()`, and submit keep the value. */
     keepValue?: boolean;
-    /** Keep the field's dirty baseline. Implies `keepValue` — a removed
-     * value has nothing to be dirty about. */
+    /** Keep the field's dirty baseline. Implies `keepValue`. */
     keepDirty?: boolean;
     /** Keep the field's touched flag instead of clearing it. */
     keepTouched?: boolean;
@@ -173,384 +96,213 @@ type RemoveFieldOptions = {
     keepError?: boolean;
 };
 declare function removeField(form: Form$1, name: Name, options?: RemoveFieldOptions): void;
-/**
- * Remove field
- * @param form
- * @param path
- * @param options keep-flags to preserve slices of state through the removal
- */
+/** Remove a field by path; the keep-flags preserve slices of state. */
 declare function removeFieldByPath(form: Form$1, path: Path, options?: RemoveFieldOptions): void;
-/**
- * Set form initialValues
- *
- * Content-based early return: a new reference with equal content (the
- * re-rendered inline literal) is a no-op, so committed edits survive, while
- * genuinely changed content swaps the baseline and re-seeds — live values
- * and tombstones are cleared, touched flags and errors survive.
- * @param form
- * @param initialValues
- */
+/** Set form initialValues. Content-based early return: a new reference with
+ * equal content is a no-op (committed edits survive); genuinely changed
+ * content swaps the baseline and re-seeds — live values and tombstones are
+ * cleared, touched flags and errors survive. */
 declare function setInitialValues(form: Form$1, initialValues: any): void;
-/** Options accepted by {@link reset}. Every flag defaults to `false` —
- * omitting the object (or any flag) keeps the plain full-reset behavior.
- * Names mirror react-hook-form's reset options to ease migration. */
+/** Options accepted by {@link reset}. Every flag defaults to `false`. */
 type ResetOptions = {
     /** Keep the current values of fields that are dirty — differ from the
-     * pre-reset initialValues (the same rule {@link getDirtyFields} applies).
-     * Clean fields fall back to the new initialValues as usual. */
+     * pre-reset initialValues (the same rule {@link getDirtyFields} applies). */
     keepDirtyValues?: boolean;
     /** Keep every field's current live value instead of returning to the
-     * baseline (react-hook-form's `keepValues` — a strict superset of
-     * `keepDirtyValues`, which only preserves dirty fields' values).
-     * Dirtiness is recomputed against the post-reset baseline, so kept
-     * values that differ from a newly provided baseline count as dirty. */
+     * baseline (a superset of `keepDirtyValues`). Dirtiness is recomputed
+     * against the post-reset baseline. */
     keepValues?: boolean;
-    /** Ignore a newly provided `initialValues` argument and keep the current
-     * baseline — fields still return to it (react-hook-form's
-     * `keepDefaultValues`). */
+    /** Ignore a newly provided `initialValues` and keep the current baseline. */
     keepDefaultValues?: boolean;
     /** Keep the touched set instead of clearing it. */
     keepTouched?: boolean;
     /** Keep field errors instead of clearing them. */
     keepErrors?: boolean;
-    /** Keep the submitted flag (`isSubmitted`) instead of clearing it —
-     * react-hook-form's `keepIsSubmitted`. */
+    /** Keep the submitted flag (`isSubmitted`) instead of clearing it. */
     keepIsSubmitted?: boolean;
-    /** Keep the last submit's success flag (`isSubmitSuccessful`) instead of
-     * clearing it. */
+    /** Keep the last submit's success flag (`isSubmitSuccessful`). */
     keepIsSubmitSuccessful?: boolean;
     /** Keep `submitCount` instead of resetting it to 0. */
     keepSubmitCount?: boolean;
     /** Keep `isSubmitting` instead of resetting it to false. */
     keepIsSubmitting?: boolean;
 };
-/**
- * Reset form
- * @param form
- * @param initialValues new baseline — omitted (or undefined), the form
- *        keeps its current initialValues and fields simply return to them
- *        (react-hook-form's reset-without-values semantics)
- * @param options keep-flags to preserve slices of state through the reset
- */
+/** Reset the form. Omitted (or undefined) `initialValues` keeps the current
+ * baseline — fields simply return to it (react-hook-form's
+ * reset-without-values semantics). */
 declare function reset(form: Form$1, initialValues?: any, options?: ResetOptions): void;
-/** Options accepted by {@link resetField}. The flags default to `false`;
- * `value` has no default — omitted, the field falls back to initialValues;
- * provided, the explicit value becomes the live value with no fallback at
- * all. Mirrors react-hook-form's resetField options (`value` plays their
- * `defaultValue`'s role) to ease migration. */
+/** Options accepted by {@link resetField}. Flags default to `false`;
+ * `value` has no default — omitted, the field falls back to initialValues. */
 type ResetFieldOptions = {
     /** Keep the field's touched flag instead of clearing it. */
     keepTouched?: boolean;
     /** Keep the field's errors instead of clearing them. */
     keepErrors?: boolean;
-    /** Explicit post-reset value for the field — never falls back to
-     * initialValues. */
+    /** Explicit post-reset value — never falls back to initialValues. */
     value?: any;
 };
-/**
- * Reset a single field: drop its live value (reads fall back to the
- * baseline — initialValues, or the schema's parsed output when one
- * exists, in which case the path is removed from parsedValues and the
- * initial value pinned back so the field reads initialValues again),
- * clear its touched flag and errors, and revive the path's removal
- * tombstones — the inverse of {@link removeFieldByPath}. Other fields
- * and the submission flags are untouched; see {@link reset} for the
- * form-wide counterpart.
- *
- * @param form
- * @param name
- * @param options
- */
-declare function resetField<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, options?: ResetFieldOptions): void;
+/** Reset a single field: drop its live value (reads fall back to the
+ * baseline), clear touched/errors, and revive the path's tombstones — the
+ * inverse of {@link removeFieldByPath}. Other fields are untouched. */
+declare function resetField<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P, options?: ResetFieldOptions): void;
 
-/**
- * Set field touched state
- * @param form
- * @param name
- */
+/** Set a field's touched state. */
 declare function setTouched(form: Form$1, name: Name): void;
-/**
- * Set field touched state
- * @param form
- * @param path
- */
+/** Set a field's touched state by path. */
 declare function setTouchedByPath({ emitter, touched }: Form$1, path: Path): void;
-/**
- * Check if field has been touched
- * @param form
- * @param name
- */
-declare function hasTouched<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
-/**
- * Check if field has been touched
- * @param form
- * @param path
- */
+/** Check if a field has been touched. */
+declare function hasTouched<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): boolean;
+/** Check if a field has been touched by path. */
 declare function hasTouchedByPath({ touched }: Form$1, path: Path): boolean;
-/**
- * Is dirty -- any value differs from initialValues
- * @param form
- */
-/**
- * Get touched fields as user-facing dotted paths ('a.b', 'a.0.c'), unlike
- * the JSON array keys stored in the touched Set.
- * @param form
- * @return array of touched fields' dotted paths
- */
+/** Get touched fields as user-facing dotted paths ('a.b', 'a.0.c'). */
 declare function getTouchedFields({ touched }: Form$1): string[];
-/**
- * Is touched -- any field has been touched
- * @param form
- */
+/** Is touched — any field has been touched. */
 declare function isTouched({ touched }: Form$1): boolean;
 
-/**
- * Is one field dirty — the per-field rule behind `getFieldState`'s
- * `isDirty` and {@link useIsFieldDirty}: a live value exists at the path
- * and differs from the field's effective baseline (committed
- * `shouldDirty: false` baselines included). A leaf under a wholesale
- * ancestor write reports clean — dirtiness belongs to the branch that
- * actually diverged, the same attribution {@link getDirtyFields} applies.
- */
+/** Is one field dirty — the per-field rule behind `getFieldState`'s
+ * `isDirty`: a live value exists at the path and differs from the field's
+ * effective baseline (committed `shouldDirty: false` baselines included).
+ * A leaf under a wholesale ancestor write reports clean — dirtiness
+ * belongs to the branch that actually diverged. */
 declare function isFieldDirtyByPath(form: Form$1, path: Path): boolean;
-/**
- * Is dirty -- any value differs from initialValues
- * @param form
- */
+/** Is dirty — any value differs from initialValues. */
 declare function isDirty(form: Form$1): boolean;
-/**
- * Get dirty fields -- fields whose current value differs from initialValues.
- * Keys are user-facing dotted paths ('a.b', 'a.0.c'), unlike the JSON array
- * keys stored in the values Map.
- * @param form
- * @return object mapping each dirty field's dotted path to true; the same
- * reference is returned until the dirty set actually changes
- */
+/** Get dirty fields — fields whose current value differs from
+ * initialValues. Keys are user-facing dotted paths ('a.b', 'a.0.c'); the
+ * same reference is returned until the dirty set actually changes. */
 declare function getDirtyFields(form: Form$1): Record<string, boolean>;
 
-/**
- * Set a field value as a user change.
- *
- * The write rides the same gated user-change pipeline a user typing into
- * the field would fire when a field is mounted on the path (registered
- * through {@link registerFieldMode} — `useField` registers on mount): the
- * field's effective `mode` (per-field override included) and the form's
- * `reValidateMode` drive validation exactly as in {@link
- * userChangeByPath}. With no mounted field on the path it degrades to a
- * plain value set ({@link setValue}).
- *
- * This is the channel for component-library bridges that hand a control a
- * plain setter bound to a field — they cannot rebuild the gating from
- * public form state, because the per-field mode override and the
- * live-error view that gates `reValidateMode` live in the field
- * registration, not in public state.
- *
- * Contrast {@link setValue}: that is the imperative channel — its
- * `shouldValidate` option kicks the field's validator unconditionally,
- * ignoring any mode. Functional updaters are the caller's to evaluate
- * ({@link getValue}).
- *
- * `options` carries the same {@link SetFieldOptions}: on the fallback path
- * (no mounted field) they forward to {@link setValueByPath} wholesale,
- * while on the mounted-field path only `shouldDirty: false` applies — the
- * write lands as a commit while the field's own mode gating keeps driving
- * validation, which is the point of this channel.
- *
- * @param form
- * @param name
- * @param value
- * @param options
- */
-declare function changeValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, value: PathValueOf<T, P>, options?: SetFieldOptions): void;
-/**
- * Set a field value as a user change, by parsed path
- * @param form
- * @param path
- * @param value
- * @param options
- */
+/** Set a field's value as a user change. When a field is mounted on the
+ * path it rides the gated user-change pipeline (the field's effective
+ * `mode` and the form's `reValidateMode` drive validation, as in
+ * {@link userChangeByPath}); with no mounted field it degrades to a plain
+ * {@link setValue}. Contrast {@link setValue}, whose `shouldValidate`
+ * kicks the validator unconditionally. */
+declare function changeValue<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P, value: PathValueOf<T, P>, options?: SetFieldOptions): void;
+/** Set a field's value as a user change, by parsed path. */
 declare function changeValueByPath(form: Form$1, path: Path, value: any, options?: SetFieldOptions): void;
-/**
- * Register a mounted field's `mode` override at `path` for user-change
- * gating ({@link userChangeByPath} / {@link userBlur}). Returns the
- * registration token for {@link unregisterFieldMode} plus whether the
- * slot was already occupied — two fields mounted at one path is almost
- * always a bug: the latest mount's mode governs every user-change write
- * there, which the React layer warns about in DEV.
- *
- * @param form
- * @param path
- * @param mode the field's `mode` option, or undefined to follow
- *        {@link Form.mode}
- * @return `token` to hand to {@link unregisterFieldMode}; `displaced`
- *         true when a previous registration at the same path still owned
- *         the slot
- */
+/** Register a mounted field's `mode` override at `path` for user-change
+ * gating. Returns the registration token for {@link unregisterFieldMode}
+ * plus whether the slot was already occupied — two fields at one path is
+ * almost always a bug (the latest mount's mode governs). */
 declare function registerFieldMode(form: Form$1, path: Path, mode: ValidationMode | undefined): {
     token: object;
     displaced: boolean;
 };
-/** Drop a {@link registerFieldMode} registration. A later mount at the
- * same path keeps its slot: only the entry owned by `token` is removed. */
+/** Drop a {@link registerFieldMode} registration; only the entry owned by
+ * `token` is removed, so a later mount keeps its slot. */
 declare function unregisterFieldMode(form: Form$1, path: Path, token: object): void;
-/**
- * Write a bound field's user change by path: the write plus the
- * mode/reValidateMode-gated validation pipeline — what a bound field's
- * onChange does when the user types. Reads the effective mode from the
- * field-mode registry (the latest mount's override governs), so a plain
- * write happens when no field is registered at `path`. Framework
- * adapters (React's `useField`, a Solid binding) forward their field
- * change events here.
- *
- * @param form
- * @param path
- * @param value
- */
+/** First key in the mounted-field registry that is a strict descendant of
+ * `ancestor`, in registration order — undefined when none is mounted.
+ * Same descendant rule as `onPathEvent` ('['+','+segment keeps sibling
+ * lookalike keys from matching). */
+declare function firstMountedDescendantKey(form: Form$1, ancestor: Path): string | undefined;
+/** Write a bound field's user change by path: the write plus the
+ * mode/reValidateMode-gated validation pipeline. Reads the effective mode
+ * from the field-mode registry, so a plain write happens when no field is
+ * registered at `path`. Framework adapters forward their change events
+ * here. */
 declare function userChangeByPath(form: Form$1, path: Path, value: any): void;
+/** A bound field's blur: mark the path touched (unconditional), then kick
+ * its validator under the blur-side gate. Framework adapters forward blur
+ * events here. */
+declare function userBlur(form: Form$1, path: Path): void;
+
 /**
- * A bound field's blur: mark the path touched, then kick its validator
- * under the blur-side gate (`mode` `'onBlur'`/`'onTouched'`/`'all'`, or
- * `reValidateMode: 'onBlur'` while the field carries a live error). The
- * touched marking is unconditional — a field counts as touched on blur
- * regardless of mode. Framework adapters forward field blur events here.
+ * Create a non-hook field binding — react-hook-form's `register`
+ * contract, wired onto this library's store: the bound element never
+ * re-renders, every change still lands in the store through the gated
+ * user-change pipeline, and `trigger`/submit/`getValues` read it like
+ * any other field. `useField({uncontrolled: true})` already covers the
+ * hook case; `register` exists for the call sites a hook cannot serve —
+ * dynamic lists, conditional fields, non-React adapters — and for RHF
+ * migration (`{...register('name')}` spreads unchanged).
+ *
+ * Lifecycle rides the returned `ref` callback, exactly like React's own
+ * ref semantics guarantee attach/detach:
+ * - **attach** (element handed over): restore a StrictMode-detached
+ *   snapshot (React 19 detaches refs on the dev remount), seed the
+ *   element's initial DOM content into the store when the path has no
+ *   live value yet (an uncontrolled element's `defaultValue`/`checked`
+ *   is invisible to React state, so the DOM is the source), register the
+ *   field-mode entry (the "mounted field" signal routing `changeValue`
+ *   into the gated pipeline), wire declarative `rules` through
+ *   `registerValidatorByPath`, and subscribe the `'focusError'` channel
+ *   (`setFocus`, failed-submit auto-focus) plus the bulk-reset DOM sync
+ *   (payload-less `'change'` rewrites the element, register-style);
+ * - **detach** (`null`): unregister mode entry and validator, drop the
+ *   subscriptions, and tombstone the path unless
+ *   `shouldUnregister: false` — the library's historical unmount
+ *   default, snapshot/restore-safe under StrictMode.
+ *
+ * Event extraction defaults to the element's own protocol (files →
+ * `target.files`, checkbox → `target.checked`, `valueAsNumber`/
+ * `valueAsDate` under their flags, else `target.value`), overridable
+ * with `eventToValue` — the same extraction `<Field>` performs.
  *
  * @param form
- * @param path
+ * @param name path or segment array
+ * @param options {@link RegisterOptions}
+ * @return spreadable props {@link RegisterProps}
  */
-declare function userBlur(form: Form$1, path: Path): void;
+declare function registerField(form: Form$1, name: Name, options?: RegisterOptions): RegisterProps;
 
 declare function setIsSubmitting(form: Form$1, value: boolean): void;
 declare function incrementSubmitCount(form: Form$1): void;
 declare function setSubmitSuccessful(form: Form$1, value: boolean): void;
-/**
- * Set the form-level disabled flag and emit a payload-less 'disabled'
- * event — subscribed fields (useField and the components built on it)
- * re-render with the merged disabled state: form flag || their own
- * `disabled` option.
- * @param form
- * @param value
- */
+/** Set the form-level disabled flag and emit a payload-less 'disabled'
+ * event — subscribed fields re-render with the merged state (form flag ||
+ * their own `disabled` option). */
 declare function setDisabled(form: Form$1, value: boolean): void;
-/**
- * Set the form's user-owned metadata slot (Formik's `status` role): the
- * payload-less 'status' event wakes {@link useStatus} and any imperative
- * `subscribe(form, {event: 'status'})` listeners. Nothing else reads or
- * interprets the value — server session flags, step state, non-field
- * errors of any shape are all fair game. Starts `undefined`.
- * @param form
- * @param value
- */
+/** Set the form's user-owned metadata slot (Formik's `status` role): the
+ * payload-less 'status' event wakes {@link useStatus} and imperative
+ * `subscribe` listeners. Nothing else interprets the value. */
 declare function setStatus(form: Form$1, value: any): void;
+/** A submit callback: the submitted values plus the triggering event. */
+type SubmitCallback<T> = (values: T, e?: any) => void | Promise<void>;
 /** Submit callbacks for {@link handleSubmit}. All optional — a missing
  * callback is simply skipped, matching the <Form> component semantics. */
 type HandleSubmitOptions<T extends Record<string, any> = any> = {
     /** Called after validation passes, before onValidSubmit. */
-    onSubmit?: (values: T, e?: any) => void | Promise<void>;
+    onSubmit?: SubmitCallback<T>;
     /** Called after validation passes, following a successful onSubmit. */
-    onValidSubmit?: (values: T, e?: any) => void | Promise<void>;
-    /**
-     * Called when validation fails.
-     * @param errors array of {path, type, message} entries in insertion
-     *        order; path is the dotted field path ('a.b', 'list.0'), type is
-     *        the error kind ('custom' for plain string errors, 'native' for
-     *        failed DOM constraint validation), message is the display text
-     * @param values current form values
-     */
+    onValidSubmit?: SubmitCallback<T>;
+    /** Called when validation fails, with the flattened error entries and
+     * current values. */
     onInvalidSubmit?: (errors: FieldErrorEntry[], values: T) => void;
-    /**
-     * Called after validation passes and the submit callbacks ran, with the
-     * final (schema-coerced) values — the slot <Form>'s `action` prop uses
-     * to dispatch React 19 server actions with FormData. Runs inside the
-     * same isSubmitting window and is awaited like onSubmit/onValidSubmit.
-     */
-    onAction?: (values: T, e?: any) => void | Promise<void>;
-    /**
-     * Focus the first error field after a failed submit. Defaults to true —
-     * only an explicit `false` disables it. When custom validation fails,
-     * a 'focusError' event carrying the first error's path key is emitted
-     * on the form (bound fields such as <Field> subscribe and focus their
-     * input); when native constraint validation fails, the submitted
-     * form's first ':invalid' control is focused directly.
-     */
+    /** Called after validation passes with the final (schema-coerced)
+     * values — the slot <Form>'s `action` prop uses to dispatch React 19
+     * server actions. May return an {@link ActionErrorResult}: its `errors`
+     * record lands as `type: 'server'` errors and the submit counts
+     * unsuccessful; any other return means success. */
+    onAction?: (values: T, e?: any) => void | Promise<void | ActionErrorResult>;
+    /** Focus the first error field after a failed submit. Defaults to true. */
     shouldFocusError?: boolean;
+    /** Whether native constraint validation gates this attempt. Defaults to
+     * the form's {@link Form.shouldUseNativeValidation} flag. Targets
+     * without checkValidity never gate. */
+    shouldUseNativeValidation?: boolean;
 };
-/**
- * Create an async submit handler for `form` — the headless counterpart of
- * the <Form> component's onSubmit wiring.
- *
- * Behavior mirrors <Form> exactly: preventDefault when present, then the
- * submit state machine (isSubmitting/submitCount/isSubmitSuccessful) runs
- * around native constraint validation (via `e.currentTarget.checkValidity`,
- * skipped when the target has no checkValidity — e.g. React Native or
- * toolbar-button submits) and custom validators. Failed validation fires
- * onInvalidSubmit with the flattened error entries; a passing submit runs
- * onSubmit then onValidSubmit. Errors thrown by either are swallowed into
- * isSubmitSuccessful=false rather than rejecting the returned promise.
- * Failed validation also focuses the offending field (see
- * {@link HandleSubmitOptions.shouldFocusError}).
- *
- * @param form form instance
- * @param options submit callbacks
- * @return async event handler, callable without an event object
- */
+/** What a server action / onAction callback returns when the server
+ * rejected the payload: a field-path → message(s) record, landed as
+ * `type: 'server'` errors. Undefined (or anything else) means success. */
+type ActionErrorResult = {
+    errors?: Record<string, string | string[]>;
+};
+/** Create an async submit handler for `form` — the headless counterpart of
+ * the <Form> component's onSubmit wiring. Runs the submit state machine
+ * around native constraint validation (skipped for targets without
+ * checkValidity) and custom validators; failed validation fires
+ * onInvalidSubmit, a passing submit runs onSubmit then onValidSubmit.
+ * Errors thrown by either are swallowed into isSubmitSuccessful=false.
+ * A new attempt while one is in flight is ignored outright (no state
+ * changes at all) — including handleSubmit calls nested inside onSubmit. */
 declare function handleSubmit<T extends Record<string, any> = any>(form: Form$1<T>, options?: HandleSubmitOptions<T>): (e?: {
     preventDefault?: () => void;
     currentTarget?: any;
 }) => Promise<void>;
 
-/** Type tag of a failed rule, as stored on the resulting FieldError. */
-type RuleType = 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
-/**
- * Declarative field rules — a subset of react-hook-form's `register` rules.
- *
- * Failed rules land in the form's error state as FieldErrors (`type` is the
- * rule name) instead of only surfacing through the browser's validity
- * bubble, so any design system can render the messages uniformly.
- */
-type FieldRules = {
-    /**
-     * Fails on empty values: `''`, `undefined`, `null` or an empty array
-     * (`0` and `false` count as filled) — react-hook-form's `required`
-     * semantics. A string is the error message; `true` uses the default.
-     * When it fails, the remaining rules are skipped — an empty value
-     * reports only its required error.
-     */
-    required?: string | true;
-    /** Fails when `Number(value)` is below this bound; `NaN` values skip. */
-    min?: number;
-    /** Fails when `Number(value)` is above this bound; `NaN` values skip. */
-    max?: number;
-    /** Fails when a string value is shorter than this, or an array has
-     * fewer entries; other values skip. */
-    minLength?: number;
-    /** Fails when a string value is longer than this, or an array has more
-     * entries; other values skip. */
-    maxLength?: number;
-    /** Fails when the value does not match `pattern.value`. */
-    pattern?: {
-        value: RegExp;
-        message: string;
-    };
-    /**
-     * Custom rule callbacks — react-hook-form's `register({validate})`
-     * shape: one function, or a record of named functions. Each runs after
-     * the declarative checks, and only when they passed (`required` failing
-     * short-circuits the rest, RHF's first-error semantics). A returned
-     * error keeps its message; its `type` becomes the record key
-     * (`'validate'` for the single-function form) so consumers can switch
-     * on `error.type`. Sync-only — async checks belong in the field's
-     * `validate` option.
-     */
-    validate?: SyncValidator | Record<string, SyncValidator>;
-    /**
-     * Overrides the message per rule type — `min`, `max`, `minLength`,
-     * `maxLength` defaults and pattern's inline `message` alike — e.g. for
-     * centralizing or localizing messages.
-     */
-    messages?: Partial<Record<Exclude<RuleType, 'required'>, string>>;
-};
-
-type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
+type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = {
     form?: Form$1<TValues>;
     name: TPath;
     initialValue?: any;
@@ -566,11 +318,11 @@ type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends
      * second argument carries the validation context (`meta.signal` aborts
      * when the round is superseded).
      */
-    validate?: (value: PathValueOf<TValues, TPath>, meta: {
+    validate?: ((value: PathValueOf<TValues, TPath>, meta: {
         form: Form$1<TValues>;
         path: Path;
         signal: AbortSignal;
-    }) => ReturnType<Validator>;
+    }) => ReturnType<Validator>) | StandardSchemaV1<PathValueOf<TValues, TPath>>;
     /**
      * Declarative rules (required/min/max/minLength/maxLength/pattern),
      * compiled into a synchronous validator. `required` is special: it runs
@@ -613,9 +365,13 @@ type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends
      */
     delayError?: number;
     /**
-     * Disable this field: OR-ed with the form-level flag
-     * (`createForm({disabled})` / `setDisabled`) into the result's
-     * `disabled`. A field cannot opt out of a disabled form.
+     * Disable this field: merged into the result's `disabled` as
+     * `form.disabled || own === true || (own !== false && an ancestor
+     * declared disabled)`. `disabled: true` on a parent path disables every
+     * descendant field too (react-hook-form subtree semantics), and a
+     * descendant declares `disabled: false` to opt back out of that
+     * ancestor. The form-level flag (`createForm({disabled})` /
+     * `setDisabled`) cannot be opted out of.
      */
     disabled?: boolean;
     /**
@@ -676,13 +432,39 @@ type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends
      * for the resolved baseline; a field unmounted in between never kicks.
      */
     validateOnMount?: boolean;
+    /**
+     * DOM event → value extractor for the result's {@link
+     * UseFieldResult.inputProps} binding. Defaults to the element's own
+     * protocol (files → `target.files`, checkbox → `target.checked`,
+     * `valueAsNumber`/`valueAsDate` under their flags, else
+     * `target.value`); a non-DOM event passes through unchanged, so custom
+     * controls can hand raw values. Only consumed by `inputProps` — the
+     * headless `onChange` keeps taking raw values.
+     */
+    eventToValue?: (e: any) => any;
+    /** `inputProps` stores `e.target.valueAsNumber` instead of the string
+     * value (number inputs, RHF's `register({valueAsNumber})`). An
+     * explicit `eventToValue` takes precedence. */
+    valueAsNumber?: boolean;
+    /** `inputProps` stores `e.target.valueAsDate` instead of the string
+     * value (date/time inputs, RHF's `register({valueAsDate})`). An
+     * explicit `eventToValue` takes precedence; combining with
+     * `valueAsNumber` is a TypeError (`valueAsNumber` wins). */
+    valueAsDate?: boolean;
+    /**
+     * Element type hint for {@link UseFieldResult.inputProps} only:
+     * `'checkbox'` renders `checked` instead of `value`, `'file'` renders
+     * neither (file inputs cannot be value-controlled). The extraction
+     * itself already auto-detects both types from the event's target.
+     */
+    type?: string;
 };
 /**
  * The result of {@link useField}. Deliberately a closed shape: no index
  * signature, so a typo'd property access (`field.vlaue`) is a type error
  * instead of silently reading `undefined`.
  */
-type UseFieldResult<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
+type UseFieldResult<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = {
     /** The form instance this field is bound to (explicit prop or context) —
      * handy for consumers that need direct access to the headless API. */
     form: Form$1<TValues>;
@@ -728,8 +510,42 @@ type UseFieldResult<TValues extends Record<string, any> = any, TPath extends Fie
      * whose element is not bound neither throws nor focuses anything.
      */
     focusRef: (el: any) => void;
+    /**
+     * DOM-ready props for an `<input>`: `<input {...field.inputProps} />`
+     * binds the element to the field without hand-wiring value/onChange/
+     * onBlur/ref/a11y. `onChange` takes the DOM event (extraction per
+     * {@link UseFieldOptions}' `eventToValue`/`valueAsNumber`/`valueAsDate`
+     * /`type`), `ref` is the focus channel, `aria-invalid`/`aria-describedby`
+     * complete the {@link errorIdFromKey} chain — render the error element
+     * with `fieldErrorId(name)` to finish it. The headless `value`/
+     * `onChange`/`onBlur`/`focusRef` stay available for custom controls
+     * that hand raw values (design systems) — `inputProps` is the DOM
+     * boundary adapter, never a replacement.
+     */
+    inputProps: UseFieldInputProps;
 };
-declare function useField<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(options: UseFieldOptions$1<TValues, TPath>): UseFieldResult<TValues, TPath>;
+/**
+ * The spreadable DOM props {@link UseFieldResult.inputProps} carries:
+ * `name`, `onChange` (event-based), `onBlur`, `ref`, `disabled`, the
+ * error a11y wiring, and exactly one of `value` (controlled),
+ * `defaultValue` (uncontrolled) or `checked` (`type: 'checkbox'`) —
+ * `type: 'file'` carries none. Always spread `inputProps` FIRST, so the
+ * caller's own props (placeholder, className, an explicit `ref` they
+ * merge themselves) win.
+ */
+type UseFieldInputProps = {
+    name: string;
+    value?: any;
+    defaultValue?: any;
+    checked?: boolean;
+    onChange: (e: any) => void;
+    onBlur: () => void;
+    ref: (el: any) => void;
+    disabled: boolean;
+    'aria-invalid'?: boolean;
+    'aria-describedby'?: string;
+};
+declare function useField<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>>(options: UseFieldOptions$1<TValues, TPath>): UseFieldResult<TValues, TPath>;
 
 type FieldArrayItem<K extends string> = {
     id: string;
@@ -737,7 +553,7 @@ type FieldArrayItem<K extends string> = {
 } & Record<K, string>;
 /** Options accepted by {@link useFieldArray} and the per-instance hook
  * returned by `createFormContext()`. */
-type UseFieldArrayOptions<K extends string = 'id'> = {
+type UseFieldArrayOptions<K extends string = 'id'> = Pick<FieldOptionBase, 'rules' | 'shouldUnregister'> & {
     name: Name;
     form?: Form$1;
     /**
@@ -747,32 +563,31 @@ type UseFieldArrayOptions<K extends string = 'id'> = {
      * same name. The underlying id is unchanged.
      */
     keyName?: K;
-    /**
-     * Declarative rules validated against the whole array value
-     * (react-hook-form's `useFieldArray` `rules`): `required` fails on an
-     * empty array, `minLength`/`maxLength` read the array's length. Checked
-     * on submit and `trigger`, like every registered validator.
-     */
-    rules?: FieldRules;
-    /**
-     * Whether unmounting this array removes its branch. Defaults to the
-     * form-level `shouldUnregister` — tombstone (drop values) like a bound
-     * field's unmount; pass `false` to keep the values.
-     */
-    shouldUnregister?: boolean;
 };
-type UseFieldArrayResult<K extends string = 'id'> = {
+/** Second argument of the row-adding movers: `focus` decides whether the
+ * new row takes focus once it commits — `true` targets its first mounted
+ * child field, a string names the child field. */
+type FieldArrayFocusOptions = {
+    focus?: boolean | string;
+};
+type UseFieldArrayResult<TItem = any, K extends string = 'id'> = {
     fields: FieldArrayItem<K>[];
-    append: (value: any) => void;
-    prepend: (value: any) => void;
-    insert: (index: number, value: any) => void;
-    remove: (index: number) => void;
+    /** Append one row. With the item type declared —
+     * `useFieldArray<Item>({name: 'items'})` — the value is checked
+     * against the array's element type. */
+    append: (value: TItem, options?: FieldArrayFocusOptions) => void;
+    prepend: (value: TItem, options?: FieldArrayFocusOptions) => void;
+    insert: (index: number, value: TItem, options?: FieldArrayFocusOptions) => void;
+    /** Remove one row, or several in a single write (`remove([0, 2])` —
+     * order-insensitive, duplicates ignored, out-of-range indices are
+     * silent no-ops). */
+    remove: (indices: number | number[]) => void;
     swap: (from: number, to: number) => void;
     move: (from: number, to: number) => void;
-    replace: (values: any[]) => void;
-    update: (index: number, value: any) => void;
+    replace: (values: TItem[]) => void;
+    update: (index: number, value: TItem) => void;
 };
-declare function useFieldArray<K extends string = 'id'>(options: UseFieldArrayOptions<K>): UseFieldArrayResult<K>;
+declare function useFieldArray<TItem = any, K extends string = 'id'>(options: UseFieldArrayOptions<K>): UseFieldArrayResult<TItem, K>;
 /**
  * The result of {@link useFieldArrayItem}. Mirrors the {@link useField}
  * return shape (`value`/`errors`/`error`) plus the row's `index` and
@@ -798,6 +613,14 @@ type UseFieldArrayItemResult<TValue = any> = {
     index: number;
     form: Form$1;
 };
+/** Options for {@link useFieldArrayItem} and its per-instance core: the
+ * array's `name`, the row's stable `id` (from `fields[i].id`), and an
+ * optional explicit `form`. */
+type UseFieldArrayItemOptions = {
+    name: Name;
+    id: string;
+    form?: Form$1;
+};
 /**
  * Subscribe to a single row of a {@link useFieldArray} field — the
  * per-item counterpart `useFieldArray` alone cannot offer. `useFieldArray`
@@ -823,127 +646,116 @@ type UseFieldArrayItemResult<TValue = any> = {
  * the same path — it publishes the id table), the row's `id` from
  * `fields[i].id`, and optionally an explicit `form`
  */
-declare function useFieldArrayItem<TValue = any>(options: {
-    name: Name;
-    id: string;
-    form?: Form$1;
-}): UseFieldArrayItemResult<TValue>;
+declare function useFieldArrayItem<TValue = any>(options: UseFieldArrayItemOptions): UseFieldArrayItemResult<TValue>;
 
-declare const FormContext: React.Context<Form$1<any> | null>;
-declare const FormProvider: React.Provider<Form$1<any> | null>;
+declare const FormContext: Context<Form$1<any> | null>;
+declare const FormProvider: Provider<Form$1<any> | null>;
 /**
- * Read the form from the module-level {@link FormContext}. Pass the values
- * shape — `useFormContext<Values>()` — to get a fully typed `Form<Values>`
- * headless API; the `any` default keeps untyped call sites compiling.
- *
- * For multiple forms in one subtree use {@link createFormContext} instead.
- *
+ * Read the form from the module-level {@link FormContext}; pass the values
+ * shape (`useFormContext<Values>()`) for a typed `Form<Values>`. Use
+ * {@link createFormContext} for multiple forms in one subtree.
  * @throws when no `<FormProvider>` is mounted above the call site.
  */
 declare function useFormContext<T extends Record<string, any> = any>(): Form$1<T>;
-/**
- * Create an isolated bundle of form-context bindings: its own React context
- * plus `useField` / `useFieldArray` / `useFieldArrayItem` /
- * `useFormContext` hooks that resolve their form from it.
- *
- * Why: the module-level {@link FormContext} works fine for a single form per
- * subtree, but nesting two forms (or reusing a component inside a different
- * form) makes them fight over one context. Calling this factory once per app
- * area — `const Ctx = createFormContext<Values>()` — fixes the value shape
- * (`Ctx.useField({name: 'user.name'})` gets its `name` constrained by
- * `FieldPath<Values>` and its `value` typed accordingly), so call sites stop
- * hand-writing generics, and each instance's Provider scopes a strictly
- * separate form. The bundle also carries its raw React context
- * (`Ctx.context`) so `<Form context={Ctx.context}>` can provide into it.
- */
-declare function createFormContext<TValues extends Record<string, any> = any>(): {
-    context: React.Context<Form$1<TValues> | null>;
-    FormProvider: ({ form, children }: {
+/** Options the bundle's pre-bound hooks take: the underlying hook's
+ * options minus `form` — this factory's own context supplies it. For
+ * `useField`, `{name: TPath}` keeps `name` a direct TPath inference site. */
+type BoundFieldOptions<TValues extends Record<string, any>, TPath extends AnyPath<TValues>> = {
+    name: TPath;
+} & Omit<UseFieldOptions$1<TValues, TPath>, 'form'>;
+type BoundFieldArrayOptions<TValues extends Record<string, any>, K extends string = 'id'> = {
+    name: FieldPath<TValues> | Name;
+    keyName?: K;
+    rules?: FieldRules;
+    shouldUnregister?: boolean;
+};
+type BoundFieldArrayItemOptions<TValues extends Record<string, any>> = {
+    name: FieldPath<TValues> | Name;
+    id: string;
+};
+/** The bundle {@link createFormContext} returns: a private React context
+ * plus the hooks pre-bound to it, all typed against `TValues`. */
+type FormContextBundle<TValues extends Record<string, any> = any> = {
+    /** The raw React context, for `<Form context={...}>`: the component
+     * keeps its submit machinery while providing into this instance's
+     * private context. */
+    context: Context<Form$1<TValues> | null>;
+    FormProvider: (props: {
         form: Form$1<TValues>;
         children: ReactNode;
     }) => ReactNode;
     useFormContext: () => Form$1<TValues>;
-    useField: <TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(options: {
-        name: TPath;
-    } & Omit<UseFieldOptions$1<TValues, TPath>, "form">) => UseFieldResult<TValues, TPath>;
-    useFieldArray: <K extends string = "id">(options: {
-        name: FieldPath<TValues> | Name;
-        keyName?: K;
-        rules?: FieldRules;
-        shouldUnregister?: boolean;
-    }) => UseFieldArrayResult<K>;
-    useFieldArrayItem: <TValue = any>(options: {
-        name: FieldPath<TValues> | Name;
-        id: string;
-    }) => UseFieldArrayItemResult<TValue>;
+    useField: <TPath extends AnyPath<TValues> = AnyPath<TValues>>(options: BoundFieldOptions<TValues, TPath>) => UseFieldResult<TValues, TPath>;
+    useFieldArray: <TItem = any, K extends string = 'id'>(options: BoundFieldArrayOptions<TValues, K>) => UseFieldArrayResult<TItem, K>;
+    useFieldArrayItem: <TValue = any>(options: BoundFieldArrayItemOptions<TValues>) => UseFieldArrayItemResult<TValue>;
 };
-declare const CheckboxGroupContext: React.Context<any>;
-declare const CheckboxGroupProvider: React.Provider<any>;
+/**
+ * Create an isolated bundle of form-context bindings: its own React context
+ * plus `useField`/`useFieldArray`/`useFieldArrayItem`/`useFormContext`
+ * hooks resolving from it. One factory per app area scopes a separate
+ * form and fixes the value shape (`Ctx.useField` gets typed `name`/`value`);
+ * `Ctx.context` lets `<Form context={Ctx.context}>` provide into it.
+ */
+declare function createFormContext<TValues extends Record<string, any> = any>(): FormContextBundle<TValues>;
+declare const CheckboxGroupContext: Context<any>;
+declare const CheckboxGroupProvider: Provider<any>;
 declare function useCheckboxGroupContext(): any;
 
-/** Subscription granularity for {@link onPathEvent}.
- * - `'leaf'`: the subscriber reads exactly one key ({@link
- *   useValueByPath}); only writes at that key or above it can change what
- *   it reads.
- * - `'branch'`: the subscriber aggregates a whole subtree below a key
- *   ({@link useFieldArray}); descendant writes matter too. */
+/** Subscription granularity for {@link onPathEvent}: `'leaf'` reads one
+ * key (only writes at it or above matter); `'branch'` aggregates a whole
+ * subtree (descendant writes matter too). */
 type WatchScope = 'leaf' | 'branch';
-/** Events {@link subscribe} can watch. `'errors'` and `'touched'` are
- * stored per exact key, so they match exact keys ({@link onKeyEvent});
- * `'change'`, `'validating'`, `'submitting'`, `'submitCount'`,
- * `'disabled'`, `'status'` and `'submitSuccessful'` go through
- * {@link onPathEvent}. `'validating'` carries paths (one per async
- * validator round) and matches by path exactly like `'change'`;
- * `'submitting'`, `'submitCount'`, `'disabled'`, `'status'` and
- * `'submitSuccessful'` are payload-less broadcasts, so `name` never
- * narrows them — every subscriber hears every emission. */
+/** Events {@link subscribe} can watch. `'errors'`/`'touched'` match exact
+ * keys ({@link onKeyEvent}); `'change'`/`'validating'` match by path
+ * ({@link onPathEvent}); the rest are payload-less broadcasts every
+ * subscriber hears. */
 type SubscribeEvent = 'change' | 'errors' | 'touched' | 'validating' | 'submitting' | 'submitCount' | 'submitSuccessful' | 'disabled' | 'status' | 'loading';
-/** Options accepted by {@link subscribe}. */
 type SubscribeOptions = {
-    /** Path (or list of paths) to watch. Omit to receive every emission of
-     * `event`, payload-less broadcasts included. A single segments path
-     * (`['tags', 0]`) and a list of names (`['tags', 'user.name']`) are told
-     * apart by the same rule `trigger` uses: only a segments path can hold
-     * a number. */
+    /** Path or paths to watch; omit to receive every emission. A segments
+     * path vs a name list is told apart by `trigger`'s rule: only segments
+     * hold a number. */
     name?: Name | Name[];
     /** Event to watch. Defaults to `'change'`. */
     event?: SubscribeEvent;
-    /** Which writes around `name` are relevant — `'leaf'` or `'branch'`.
-     * Only meaningful for the path-carrying events `'change'` and
-     * `'validating'`: `'errors'`/`'touched'` match exact keys and
-     * `'submitting'`/`'submitCount'`/`'disabled'`/`'status'`/
-     * `'submitSuccessful'` are payload-less. Defaults to `'branch'` — the
-     * intuitive linkage semantics, where subscribing to `'tags'` means the
-     * whole branch. */
+    /** Which writes around `name` are relevant. Only meaningful for the
+     * path-carrying events; defaults to `'branch'` (subscribing to `'tags'`
+     * means the whole branch). */
     scope?: WatchScope;
-    /** Invoked with no arguments after each matching emission. Read fresh
-     * state through the `get*` readers inside it. */
+    /** Invoked after each matching emission; read fresh state through the
+     * `get*` readers inside it. */
     callback: () => void;
 };
 /**
  * Subscribe to form events imperatively — the non-render counterpart of
- * the `use*` hooks: linkages and side effects (province changed → clear
- * city, autosave, analytics) run without mounting a watching component.
- *
- * Without `name`, `callback` fires on every `event` emission, payload-less
- * broadcasts (reset, setInitialValues) included. With `name`, matching
- * follows the event's shape: `'errors'`/`'touched'` match the exact key
- * ({@link onKeyEvent}) — another field's error never wakes this
- * subscriber — while `'change'`/`'validating'`/`'submitting'`/
- * `'submitCount'`/`'disabled'`/`'submitSuccessful'` go through
- * {@link onPathEvent}, so the default `'branch'` scope wakes a `'tags'`
- * subscriber when any `tags.*` descendant is written. `'validating'`
- * carries a path per validator round and narrows by path like
- * `'change'`; `'disabled'`/`'submitSuccessful'` (like `'submitting'`)
- * are payload-less broadcasts that every named subscriber receives. A
- * `name` array builds one subscription per path and the returned
- * function unsubscribes them all.
- *
- * @param form the form to watch
- * @param options event, name(s), scope and callback
- * @return unsubscribe function
+ * the `use*` hooks. Without `name`, `callback` fires on every emission;
+ * with `name`, matching follows the event's shape (`'errors'`/`'touched'`
+ * match exact keys, the rest match by path or broadcast). A name array
+ * builds one subscription per path.
  */
 declare function subscribe(form: Form$1, options: SubscribeOptions): () => void;
+/** The handle {@link watch} returns: a subscribe/getSnapshot pair any
+ * reactive runtime can bind to. One internal listener stays alive from
+ * creation, so `getSnapshot()` is always fresh; `dispose` ends it. */
+type WatchHandle<T> = {
+    /** Read the current snapshot, cached between events; repeated reads
+     * share one reference until state changes. */
+    getSnapshot: () => T;
+    /** Register a change listener; fires only when the projection changed.
+     * With `isEqual`, an equal verdict skips the callback; without one,
+     * every event wakes it. */
+    subscribe: (invalidate: () => void) => () => void;
+    /** Remove the internal listener and every consumer callback; the handle
+     * is dead afterwards. */
+    dispose: () => void;
+};
+/**
+ * Watch a projection of form state without React — the framework-free
+ * {@link useWatch} (same `isEqual` bailout), tree-shaken when unused.
+ * Returns a {@link WatchHandle}: read `getSnapshot()`, re-read/re-render
+ * when `subscribe`'s listener fires. The handle subscribes eagerly, so
+ * reads are never stale; `getter`/`isEqual` are captured at creation.
+ */
+declare function watch<T>(form: Form$1, event: SubscribeEvent, getter: () => T, isEqual?: (prev: T, next: T) => boolean): WatchHandle<T>;
 
 /**
  * Create a form instance bound to this component.
@@ -955,11 +767,19 @@ declare function subscribe(form: Form$1, options: SubscribeOptions): () => void;
  * while touched flags and errors survive. Change detection is
  * reference-first with a structural fallback, so re-renders that pass an
  * inline literal with equal content never re-sync -- the user's
- * in-progress typing is never clobbered.
+ * in-progress typing is never clobbered. Passing `resetOptions` reroutes
+ * those changed-content syncs through {@link reset} instead, so its keep*
+ * flags govern what survives (`keepDirtyValues: true` keeps the user's
+ * uncommitted edits on dirty fields); the reference/structural guard
+ * applies to both routes.
  */
 declare function useForm<T extends Record<string, any> = any>(options?: Options<T> & {
     values?: T;
+    resetOptions?: ResetOptions;
 }): Form$1<T>;
+/** Snapshot equality comparator — the `isEqual` contract {@link
+ * useWatchCore} documents. */
+type SnapshotComparator<T> = (prev: T, next: T) => boolean;
 /**
  * Shared core of {@link useWatch} and the path-scoped hooks: a
  * useSyncExternalStore binding over a custom event subscription.
@@ -976,7 +796,7 @@ declare function useForm<T extends Record<string, any> = any>(options?: Options<
  * snapshot and notifies. Omitted, the historical drop-and-notify pipeline
  * runs byte-for-byte unchanged.
  */
-declare function useWatchCore<T>(subscribeFactory: (invalidate: () => void) => () => void, getter: () => T, isEqual?: (prev: T, next: T) => boolean): T;
+declare function useWatchCore<T>(subscribeFactory: (invalidate: () => void) => () => void, getter: () => T, isEqual?: SnapshotComparator<T>): T;
 /**
  * Subscribe to a form event and keep the component's snapshot of `getter()`
  * in sync with the form state.
@@ -989,6 +809,12 @@ declare function useWatchCore<T>(subscribeFactory: (invalidate: () => void) => (
  * shape every hook shares; the raw emitter form remains accepted for
  * back-compat and for subscription sources that are not a full form.
  *
+ * Framework-free counterpart: {@link watch} — the same event/getter/
+ * `isEqual` contract exposed as a named export returning a
+ * subscribe/getSnapshot handle any reactive runtime can bind to
+ * (useWatch is its React binding; the ref-based cache here keeps inline
+ * getters from re-subscribing per render).
+ *
  * By default the re-render surface is the event's own scope: every emit
  * the subscription hears drops the snapshot cache and wakes React, which
  * then bails out when the recomputed snapshot is reference-identical
@@ -1001,9 +827,9 @@ declare function useWatchCore<T>(subscribeFactory: (invalidate: () => void) => (
  * stores the new snapshot and re-renders. Same contract as TanStack's
  * `useSelector` compare. Omitted, behavior is unchanged.
  */
-declare function useWatch<T>(formOrEmitter: Form$1 | EventEmitter<FormEvents>, event: SubscribeEvent, getter: () => T, isEqual?: (prev: T, next: T) => boolean): T;
+declare function useWatch<T>(formOrEmitter: Form$1 | EventEmitter<FormEvents>, event: SubscribeEvent, getter: () => T, isEqual?: SnapshotComparator<T>): T;
 /** Options for {@link useValue} and {@link useValueByPath}. */
-type UseValueOptions<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments> = {
+type UseValueOptions<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>> = {
     /** Value to return while the field reads undefined — react-hook-form's
      * `useWatch` `defaultValue`: an untouched, never-seeded field reads
      * this instead of `undefined`. */
@@ -1019,7 +845,7 @@ type UseValueOptions<T extends Record<string, any> = any, P extends FieldPath<T>
 /**
  * Get field value state
  */
-declare function useValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, options?: UseValueOptions<T, P>): PathValueOf<T, P>;
+declare function useValue<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P, options?: UseValueOptions<T, P>): PathValueOf<T, P>;
 /**
  * Get field value state by path
  */
@@ -1027,10 +853,22 @@ declare function useValueByPath(form: Form$1, path: Path, options?: {
     defaultValue?: any;
     exact?: boolean;
 }): any;
+/**
+ * Subscribe to the whole values tree: re-renders the calling component
+ * whenever any 'change' event lands — react-hook-form's `watch()` with no
+ * arguments. The snapshot is the memoized `getValues(form)` result, so
+ * repeated reads during one render share one reference and, under
+ * `__DEV__`, one frozen copy.
+ *
+ * Broad scope by design: read it in components that must stay cheap and
+ * need the full tree; per-field readers should reach for {@link useValue}
+ * instead so a keystroke re-renders exactly the affected field.
+ */
+declare function useValues<T extends Record<string, any> = any>(form: Form$1<T>): T;
 /**
  * Get field touched state
  */
-declare function useTouched<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
+declare function useTouched<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): boolean;
 /**
  * Get field touched state by path
  */
@@ -1039,7 +877,7 @@ declare function useTouchedByPath(form: Form$1, path: Path): boolean;
  * Get field error message state
  * @return current error's message string (display text), or undefined
  */
-declare function useError<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): string | undefined;
+declare function useError<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): string | undefined;
 /**
  * Get field error state by path
  * @return current FieldError object ({type, message}), or undefined
@@ -1050,7 +888,7 @@ declare function useErrorByPath(form: Form$1, path: Path): FieldError | undefine
  * @return every error registered for the field (insertion order); an empty
  *         array when the field has none
  */
-declare function useFieldErrors<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): FieldError[];
+declare function useFieldErrors<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): FieldError[];
 /**
  * Get all field errors by path
  * @return every error registered for the field (insertion order); an empty
@@ -1067,7 +905,7 @@ declare function useIsDirty(form: Form$1): boolean;
  * the flag, payload-less broadcasts (reset, setInitialValues) always
  * sync, and writes elsewhere never re-render it.
  */
-declare function useIsFieldDirty<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
+declare function useIsFieldDirty<T extends Record<string, any> = any, P extends AnyPath<T> = AnyPath<T>>(form: Form$1<T>, name: P): boolean;
 /**
  * Get whether one field is dirty, by parsed path. See {@link
  * useIsFieldDirty}.
@@ -1095,7 +933,7 @@ declare function useTouchedFields(form: Form$1): string[];
  * {@link useIsDirty}. Cheaper than calling the granular hooks one by one
  * (one subscription and one snapshot instead of one per flag).
  */
-type FormState = {
+type FormState<T extends Record<string, any> = any> = {
     /** Any live value differs from its baseline (see {@link isDirty}). */
     isDirty: boolean;
     /** Dirty fields keyed by user-facing dotted path ('a.b', 'a.0.c'). */
@@ -1110,6 +948,12 @@ type FormState = {
      * In-flight validation is NOT factored in ({@link isValidating} is the
      * separate signal; async rounds temporarily pass this flag like RHF's). */
     isValid: boolean;
+    /** Every error as one record keyed by user-facing dotted path
+     * ('a.b', 'list.0') — react-hook-form's `formState.errors` shape,
+     * typed as {@link FieldErrors} (per-key values optional). Memoized
+     * (see {@link getErrorsRecord}): the reference is stable between error
+     * writes, so the snapshot comparator can bail on it. */
+    errors: FieldErrors<T>;
     isSubmitting: boolean;
     /**
      * Whether a submit has been attempted on this form — set on the first
@@ -1128,8 +972,50 @@ type FormState = {
     /** The form-level disabled flag (fields OR their own `disabled`). */
     disabled: boolean;
 };
-declare function useFormState(form: Form$1): FormState;
+declare function useFormState<T extends Record<string, any> = any>(form: Form$1<T>): FormState<T>;
+/**
+ * The official selector primitive — TanStack Form's
+ * `useStore(store, selector)` counterpart. Subscribes to every
+ * state-bearing form event and keeps `selector()`'s result as the
+ * snapshot; the selector itself is a plain closure (read the form through
+ * any getter — `getValue`, `getValues`, `form.errors.size`, …).
+ *
+ * Without `isEqual` the subscription is object-identity based: each event
+ * recomputes the selector and React bails out when the result is
+ * reference-identical (the contract every `useWatch` reader relies on).
+ * The optional `isEqual(prev, next)` comparator is for wide-scope
+ * selectors that return a fresh reference per call (a whole-values
+ * projection, say): an equal verdict skips notifying React altogether —
+ * no render, not even a bailed-out one (TanStack `useSelector` compare
+ * contract).
+ *
+ * `useFormState` is the built-in aggregate selector; {@link useWatch} is
+ * the single-event version. Reach for `useStore` when the projection is
+ * yours and spans state events — e.g. `form.validating.size > 0 &&
+ * form.isSubmitting` as one flag.
+ */
+declare function useStore<T>(form: Form$1, selector: () => T, isEqual?: SnapshotComparator<T>): T;
 declare function useHasErrors(form: Form$1): boolean;
+/**
+ * Get every error as one record keyed by user-facing dotted path
+ * ('a.b', 'list.0') — react-hook-form's `formState.errors` shape, for
+ * error-summary panels and a11y announcements. Values are the stored
+ * FieldError[] arrays shared with the form (treat as read-only). The
+ * record is memoized per form (see {@link getErrorsRecord}): the hook
+ * re-renders only when an error write actually changed the record's
+ * content.
+ */
+declare function useErrors<T extends Record<string, any> = any>(form: Form$1<T>): FieldErrors<T>;
+/**
+ * Get every error as one nested object following the values tree
+ * (`errors.items?.[0]?.name` reads) — the typed optional-chaining
+ * counterpart of {@link useErrors}' flat dotted record. Leaves hold the
+ * stored FieldError[] arrays shared with the form (treat as read-only).
+ * Memoized alongside the record (see {@link getErrorsTree}): the hook
+ * re-renders only when an error write actually changed the tree's
+ * content.
+ */
+declare function useErrorsTree<T extends Record<string, any> = any>(form: Form$1<T>): FieldErrorsTree<T>;
 /**
  * Get whether the form currently has no errors — react-hook-form's
  * `formState.isValid` counterpart. Subscribes to the `'errors'` event only;
@@ -1212,367 +1098,156 @@ declare function useFormError(form: Form$1): string | undefined;
  */
 declare function useFormErrors(form: Form$1): FieldError[];
 
-/**
- * Options accepted by {@link useTransform}.
- */
-type UseTransformOptions<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments, TDisplay = PathValueOf<TValues, TPath>> = {
-    /**
-     * Map the form's stored (raw) value to the display value the control
-     * renders — the read direction. Omitted: the raw value is displayed
-     * as-is (identity).
-     */
+type UseTransformOptions<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>, TDisplay = PathValueOf<TValues, TPath>> = {
+    /** Map the stored (raw) value to the display value (read direction);
+     * omitted = identity. */
     toDisplay?: (raw: PathValueOf<TValues, TPath>) => TDisplay;
-    /**
-     * Map a display value back to the raw value written into the form —
-     * the write direction. Omitted: the display value is written as-is
-     * (identity). The round trip should be an identity
-     * (`toDisplay(fromDisplay(x)) === x`); a store value the transform
-     * cannot invert (e.g. `undefined` for a not-yet-edited field) must be
-     * handled by `toDisplay`, since it runs first.
-     */
-    fromDisplay?: (display: TDisplay) => PathValueOf<TValues, TPath>;
+    /** Map a display value back to the raw value (write direction);
+     * omitted = identity. May return a Promise — only the latest write
+     * commits (stale resolutions drop). The round trip should be an
+     * identity; non-invertible store values must be handled by
+     * `toDisplay`, which runs first. */
+    fromDisplay?: (display: TDisplay) => PathValueOf<TValues, TPath> | Promise<PathValueOf<TValues, TPath>>;
+    /** Debounce the display→raw commit; only the last write in the window
+     * commits (TanStack `asyncDebounceMs`). `0`/omitted commits
+     * immediately; validation fires at commit time through the
+     * user-change pipeline. */
+    asyncDebounceMs?: number;
 };
 /**
- * Bind a control to a field whose stored value and display value differ
- * — TanStack Form's `useTransform` counterpart, with the round trip made
- * explicit: `toDisplay` maps the store value to what the control shows,
- * `fromDisplay` maps the control's display value back to what the store
- * holds. The store always carries the raw typed value, so
- * `getValues`/submit/validation never see display representations.
- *
- * ```jsx
- * const age = useTransform(form, 'age', {
- *   toDisplay: (raw: number) => String(raw),
- *   fromDisplay: (display: string) => Number(display)
- * });
- * <input value={age.value} onChange={e => age.onChange(e.target.value)} />
- * ```
- *
- * `value` subscribes to 'change' at leaf scope exactly like a controlled
- * `useField` value — typing, programmatic `setValue` and ancestor writes
- * all re-derive it, writes elsewhere never re-render it. `onChange`
- * writes through `userChangeByPath` (the user-change channel): with a
- * field mounted at the same path the mode/reValidateMode-gated
- * validation fires exactly as if the user typed into a bound field; with
- * no mounted field it degrades to a plain value write. Touched marking
- * stays a blur concern — pair this with `useField` at the same path, or
- * call `setTouched`, when blur semantics matter.
- *
- * The transform functions are read fresh on every render (inline
- * closures work), and `value` is recomputed per render — keep display
- * values primitive (string/number) so React's equal-state bailout holds.
- *
- * @param form the form instance (explicit; the hook is headless — no
- *        context read, no provider required)
- * @param name the field's path (dotted string or segments)
- * @param options the two mapping directions; both optional (identity)
+ * Bind a control whose display value differs from the stored raw value
+ * (TanStack `useTransform`): `toDisplay` maps store→display,
+ * `fromDisplay` maps display→store. The store always carries the raw
+ * value. `value` subscribes to 'change' at leaf scope; `onChange` writes
+ * through the user-change channel, so mode-gated validation fires as if
+ * the user typed. Transform functions are read fresh each render.
  */
-declare function useTransform<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments, TDisplay = PathValueOf<TValues, TPath>>(form: Form$1<TValues>, name: TPath, options?: UseTransformOptions<TValues, TPath, TDisplay>): {
+declare function useTransform<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>, TDisplay = PathValueOf<TValues, TPath>>(form: Form$1<TValues>, name: TPath, options?: UseTransformOptions<TValues, TPath, TDisplay>): {
     value: TDisplay;
     onChange: (display: TDisplay) => void;
 };
 
-/**
- * Props for <Form>.
- *
- * Native validation behavior: the rendered <form> always sets noValidate,
- * which suppresses the browser's built-in blocked-submit UI. However, native
- * constraint validation still gates submission — the form element's
- * checkValidity() runs before custom validators, and when it fails,
- * reportValidity() surfaces the offending constraints as native bubbles and
- * submission stops (onInvalidSubmit fires). onSubmit/onValidSubmit only run
- * once every native constraint (required, type=email, minLength, ...) passes.
- *
- * The submit flow itself lives in the headless `handleSubmit` (see form.ts);
- * this component is a thin wrapper that binds it to the rendered <form>.
- */
+/** Props for <Form>. Native constraint validation gates submission: the
+ * form always sets noValidate, but checkValidity() runs before custom
+ * validators and a failure stops submission (onInvalidSubmit fires).
+ * `shouldUseNativeValidation={false}` skips the gate (targets without
+ * checkValidity are always exempt). The flow itself lives in the headless
+ * `handleSubmit`; this is a thin wrapper binding it to the <form>. */
 type FormProps<T extends Record<string, any> = any> = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> & {
     form?: Form$1<T>;
-    /**
-     * Provide into an isolated context from `createFormContext()` instead of
-     * the module-level one — `<Form context={ProfileForm.context}>` keeps the
-     * component's full submit machinery while the factory's bound hooks
-     * (`ProfileForm.useField`, `ProfileForm.useFormContext`, ...) resolve this
-     * form from their private context. The module-level `useFormContext()` /
-     * `useField` do not see it; that is the point of the isolation. Omitted,
-     * the form lands in the module-level FormContext as before.
-     */
+    /** Isolated context from `createFormContext()`: its bound hooks see this
+     * form, the module-level ones do not. Defaults to FormContext. */
     context?: React.Context<Form$1<any> | null>;
-    /**
-     * The values baseline — a sync object, a Promise, or a thunk returning
-     * either ({@link Options.initialValues}). Async sources render the form
-     * empty and gate on `form.isLoading` until they resolve.
-     */
+    /** Values baseline — sync object, Promise, or thunk; async sources gate on `isLoading`. */
     initialValues?: T | Promise<T> | (() => T | Promise<T>);
-    /**
-     * Form-level default for a bound field's unmount behavior
-     * ({@link Options.shouldUnregister}): `true` (the default) tombstones
-     * unmounted fields, `false` keeps their values.
-     */
+    /** Default unmount behavior: `true` tombstones unmounted fields, `false` keeps values. */
     shouldUnregister?: boolean;
-    /**
-     * Validate on mount (see {@link Options.validateOnMount}): every
-     * mounted field with a validator kicks once after mount and the
-     * form-level `validate` (if any) runs once. A field's own
-     * `validateOnMount` prop overrides this flag.
-     */
+    /** Validate on mount: each validator kicks once; a field's own prop overrides. */
     validateOnMount?: boolean;
-    /**
-     * Disable every bound field: the form-level flag fields OR with their
-     * own `disabled` option (a field cannot opt out). Seeded at create and
-     * kept in sync while this prop changes (undefined leaves the current
-     * flag untouched — toggle at runtime with `setDisabled`).
-     */
+    /** Disable every bound field (fields OR with their own option); undefined leaves the flag untouched. */
     disabled?: boolean;
-    /**
-     * Form-level default for field validation's `asyncAlways`: a field
-     * whose `required` gate failed still runs its debounced validator, its
-     * result landing per-source alongside the gate's errors. A field's own
-     * `asyncAlways` prop overrides this flag.
-     */
+    /** Form-level default for `asyncAlways`; a field's own prop overrides. */
     asyncAlways?: boolean;
-    /**
-     * Controlled external values. When the `values` reference changes, the
-     * new object is synced into the form (via setInitialValues semantics):
-     * uncommitted user edits are discarded -- master-detail semantics, where
-     * selecting another record replaces the draft -- while touched flags and
-     * errors are kept. Sync is reference-based: re-renders that pass the same
-     * `values` reference never clobber what the user is typing.
-     */
+    /** Controlled external values: a new reference syncs via setInitialValues
+     * (draft discarded, touched/errors kept); same reference never clobbers. */
     values?: T;
-    /** May be async — the submit flow awaits it, so form.isSubmitting
-     * covers the entire flight. */
+    /** May be async; `isSubmitting` covers the flight. */
     onSubmit?: (values: T, e: React.FormEvent) => void | Promise<void>;
     /** May be async, same as onSubmit. */
     onValidSubmit?: (values: T, e: React.FormEvent) => void | Promise<void>;
-    /**
-     * React 19 Server Action target: after validation passes (and after
-     * onSubmit/onValidSubmit), the validated, schema-coerced values are
-     * converted to FormData ({@link formDataFromValues} — files, arrays and
-     * nested objects included) and dispatched to this callback, e.g.
-     * `action={createUser}` for a server action or
-     * `action={formData => startTransition(() => dispatch(formData))}` in a
-     * useActionState bridge. `isSubmitting` covers the whole flight.
-     */
-    action?: (formData: FormData) => void | Promise<void>;
-    /**
-     * Called when validation fails.
-     * @param errors array of {path, type, message} entries in insertion
-     *        order; path is the dotted field path ('a.b', 'list.0'), type is
-     *        the error kind ('custom' for plain string errors, 'native' for
-     *        failed DOM constraint validation), message is the display text
-     * @param values current form values
-     */
+    /** Server Action target: after validation, schema-coerced values become
+     * FormData and dispatch here. Returning {@link ActionErrorResult} lands
+     * `type: 'server'` per-field errors (unsuccessful submit); a URL string
+     * renders the native `action` for no-JS progressive enhancement. */
+    action?: string | ((formData: FormData) => void | Promise<void | ActionErrorResult>);
+    /** Called when validation fails; errors are {path, type, message} entries
+     * (type: 'custom' | 'native'). */
     onInvalidSubmit?: (errors: {
         path: string;
         type: string;
         message: string;
     }[], values: T) => void;
-    /**
-     * Focus the first field with an error after a failed submit: custom
-     * validation failures focus the first errored field, native constraint
-     * failures focus the first ':invalid' control. Defaults to true; pass
-     * false to disable.
-     */
+    /** Focus the first errored field (or first ':invalid' control) after a failed submit. Default true. */
     shouldFocusError?: boolean;
+    /** Whether native constraint validation gates submission (pass false for
+     * custom-validator-only forms). Seeds the created form's flag and this
+     * form's submit wiring. */
+    shouldUseNativeValidation?: boolean;
 };
-declare function Form<T extends Record<string, any> = any>({ form: f1, context, initialValues, values, shouldUnregister, validateOnMount, disabled, asyncAlways, onSubmit, onValidSubmit, onInvalidSubmit, action, shouldFocusError, ...props }: FormProps<T>): React.JSX.Element;
+declare function Form<T extends Record<string, any> = any>({ form: f1, context, initialValues, values, shouldUnregister, validateOnMount, disabled, asyncAlways, onSubmit, onValidSubmit, onInvalidSubmit, action, shouldFocusError, shouldUseNativeValidation, ...props }: FormProps<T>): React.JSX.Element;
 
-/**
- * Props for {@link FormField}: every {@link UseFieldOptions} option plus a
- * render-prop `children` receiving the bound field result.
- */
-type FormFieldProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions$1<TValues, TPath> & {
+/** Every {@link UseFieldOptions} option plus a render-prop `children`
+ * receiving the bound field result. */
+type FormFieldProps<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = UseFieldOptions$1<TValues, TPath> & {
     children: (field: UseFieldResult<TValues, TPath>) => React.ReactNode;
 };
-/**
- * Headless field bound through a render prop — the non-hook counterpart of
- * {@link useField} for class components, callback-style consumers and
- * library bridges where a hook cannot be called (Formik `<Field>` /
- * TanStack `form.Field` shape).
- *
- * The child function receives the full {@link UseFieldResult} — value,
- * error(s), onChange/onBlur, `disabled`, `focusRef`, the bound `form` —
- * and renders whatever UI it wants; nothing is rendered when it returns
- * null/undefined, so it can also gate conditional layout. Resolves its
- * form from the module-level `FormContext` or the explicit `form` option
- * (per-instance contexts from `createFormContext()` keep using their own
- * `useField` hook).
- */
-declare function FormField<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>({ children, ...options }: FormFieldProps<TValues, TPath>): React.ReactNode;
+/** Headless field via a render prop — the non-hook {@link useField} for
+ * class components/callback consumers. The child receives the full
+ * {@link UseFieldResult}; resolves its form from FormContext or the
+ * `form` option. */
+declare function FormField<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>>({ children, ...options }: FormFieldProps<TValues, TPath>): React.ReactNode;
 
-/**
- * Props shared by Field/Checkbox/Select. Generic so a typed form flows into
- * the `validate` callback: with `form` (a `Form<Values>`) and `name`
- * (a `FieldPath<Values>`) provided, `validate` receives the value at that
- * path — `PathValueOf<Values, P>` — instead of `any`. The defaults keep the
- * bare `<Field name="x" />` (context-resolved, untyped) call sites exactly
- * as permissive as before.
- */
-type UseFieldOptions<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
-    form?: Form$1<TValues>;
+/** The error-message element id a field's `aria-describedby` points at
+ * (same id `<Field>`'s renderError span carries). A custom error
+ * component completes the accessible-name chain with
+ * `<span id={fieldErrorId(name)} role="alert">`. */
+declare function fieldErrorId(name: Name): string;
+
+/** Props shared by Field/Checkbox/Select: the hook options minus the
+ * required `name` (the components type it optional) and `validateDeps`
+ * (the components do not forward it), plus the index signature that lets
+ * DOM props flow through. */
+type UseFieldOptions<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = Omit<UseFieldOptions$1<TValues, TPath>, 'name' | 'validateDeps'> & {
     name?: TPath;
-    initialValue?: any;
-    shouldUnregister?: boolean;
-    /**
-     * Field-level validator. The value argument is typed when the field is
-     * tied to a typed form (via the `form` prop); the return shape mirrors
-     * {@link Validator} — an error (string / FieldError / mixed array) or
-     * undefined when valid, possibly a Promise for async validation. The
-     * second argument carries the validation context (`meta.signal` aborts
-     * when the round is superseded).
-     */
-    validate?: (value: PathValueOf<TValues, TPath>, meta: {
-        form: Form$1;
-        path: Path;
-        signal: AbortSignal;
-    }) => ReturnType<Validator>;
-    /**
-     * Declarative rules (required/min/max/minLength/maxLength/pattern,
-     * plus custom `validate` callbacks), compiled into a validator that
-     * runs before `validate`; failures land in the form's error state.
-     * The declarative subset is also rendered as native constraint
-     * attributes (`required`, `minLength`, `pattern`, …) onto the element
-     * for browser/AT hints — `:invalid` styling, screen-reader
-     * announcements — while the store pipeline stays the source of truth
-     * for messages (`renderError`/`aria-invalid` keep working; a user-passed
-     * `required`/`pattern`/… prop overrides the derived attribute). Passed
-     * through to useField — like validateDebounce it is never spread onto
-     * the DOM element.
-     */
-    rules?: FieldRules;
-    /**
-     * Milliseconds to debounce this field's validation kicks. Defaults to 0
-     * (validate immediately); only the last kick inside the window runs the
-     * validator, and `trigger` waits the window out. Passed through to
-     * useField/useValidate.
-     */
-    validateDebounce?: number;
-    /**
-     * Run this field's debounced validator even when its `required` gate
-     * failed (TanStack Form's `asyncAlways`): the gate's errors land
-     * immediately, the validator's own result lands alongside them
-     * per-source. Falls back to the form-level `createForm({asyncAlways})`.
-     * Passed through to useField.
-     */
-    asyncAlways?: boolean;
-    /**
-     * Validate this field once on mount (see {@link
-     * UseFieldOptions}' `validateOnMount`): overrides the form-level
-     * `createForm({validateOnMount})` / `<Form validateOnMount>` flag in
-     * either direction. Passed through to useField.
-     */
-    validateOnMount?: boolean;
-    /**
-     * Disable this field's control: OR-ed with the form-level flag
-     * (`createForm({disabled})` / `setDisabled`) — a field cannot opt out
-     * of a disabled form. Passed through to useField, like every option,
-     * never spread onto the DOM element from props.
-     */
-    disabled?: boolean;
-    /**
-     * Milliseconds to delay showing a newly appearing error (render layer
-     * only — `aria-invalid`/`renderError` wait out the window while the
-     * form's error state stays immediate for trigger/submit). An error
-     * that clears inside the window never shows; once visible, error
-     * changes apply immediately. Passed through to useField.
-     */
-    delayError?: number;
-    /**
-     * Field-level validation mode override: this field validates on its own
-     * schedule instead of the form's `mode` (other fields are unaffected);
-     * the form's `reValidateMode` still governs re-validation once the
-     * field has an error. Passed through to useField, never spread onto
-     * the DOM element.
-     */
-    mode?: ValidationMode;
-    /**
-     * Uncontrolled mode: render the element with `defaultValue` instead of
-     * `value` — typing re-renders nothing (the store still carries every
-     * write; errors/touched/disabled still re-render the field). The
-     * snapshot is pinned at mount; bulk operations (reset/setInitialValues)
-     * sync the DOM element directly without a render — RHF-register
-     * behavior (read live values with useValue/getValues). Passed through
-     * to useField, never spread onto the DOM element.
-     */
-    uncontrolled?: boolean;
     [key: string]: any;
 };
-type FieldProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath> & {
+type FieldProps<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = UseFieldOptions<TValues, TPath> & {
     as?: React.ComponentType<any>;
     asProps?: Record<string, any>;
-    eventToValue?: (e: any) => any;
     valueToProps?: (value: any) => Record<string, any>;
-    /**
-     * Optional error renderer. When provided and the field has an error,
-     * Field renders `<span id={id} role="alert">{renderError(error, id)}</span>`
-     * next to the input. The input's aria-describedby points at that span's
-     * id (the same `fieldErrorId(name)` derivation) whenever the field has
-     * an error — with or without renderError — so custom error components
-     * that render the element themselves (using `fieldErrorId`) get the
-     * wiring for free.
-     */
+    /** Error renderer: renders `<span id role="alert">` beside the input;
+     * `aria-describedby` always points at that id (`fieldErrorId`). */
     renderError?: (error: string, id: string) => React.ReactNode;
-    /**
-     * Store `e.target.valueAsNumber` instead of the string value —
-     * react-hook-form's `register({valueAsNumber})` counterpart for number
-     * inputs (`<input type="number">`). `NaN` passes through as-is when the
-     * input cannot be parsed, matching RHF. An explicit `eventToValue`
-     * takes precedence.
-     */
-    valueAsNumber?: boolean;
-    /**
-     * Store `e.target.valueAsDate` instead of the string value — RHF's
-     * `register({valueAsDate})` counterpart for date/time inputs. `null`
-     * passes through when the input cannot be parsed. An explicit
-     * `eventToValue` takes precedence; combining with `valueAsNumber` is a
-     * TypeError.
-     */
-    valueAsDate?: boolean;
 };
-/**
- * The error-message element id a field's `aria-describedby` points at —
- * `fieldErrorId('a[0].b')` is `'a-0-b'`, the same id `Field`'s built-in
- * `renderError` span carries. This is the library-level wiring convention:
- * whenever a bound field (Field/Checkbox/Select) has an error it sets
- * `aria-invalid` and describes the element with this id, so a custom error
- * component only needs `<span id={fieldErrorId(name)} role="alert">` to
- * complete the accessible-name chain for screen readers.
- * @param name the same field name passed to the bound component
- */
-declare function fieldErrorId(name: Name): string;
-/**
- * The callable shape of {@link Field}: `form` + `name` flow their generics
- * into `validate`'s value argument (`PathValueOf<TValues, TPath>`). A named
- * interface rather than an inline `as <TValues, ...>() => ...` signature —
- * same types, and the inline form trips no-use-before-define on the type
- * parameters.
- */
+/** Callable shape of {@link Field}; a named interface because the inline
+ * `as <TValues,...>() => ...` form trips no-use-before-define. */
 type FieldComponent = {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: FieldProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
+    <TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>>(props: FieldProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
 };
 declare const Field: FieldComponent;
-type CheckboxProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath>;
-/**
- * Callable shape of {@link Checkbox}: the same form-typed `validate`
- * inference contract as {@link FieldComponent}.
- */
+/** Callable shape of {@link Checkbox}: same form-typed `validate` contract
+ * as {@link FieldComponent}. */
 type CheckboxComponent = {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: CheckboxProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
+    <TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>>(props: UseFieldOptions<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
 };
 declare const Checkbox: CheckboxComponent;
-type SelectProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath> & {
+type SelectProps<TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>> = UseFieldOptions<TValues, TPath> & {
     multiple?: boolean;
     children?: React.ReactNode;
 };
-/**
- * Callable shape of {@link Select}: the same form-typed `validate`
- * inference contract as {@link FieldComponent}.
- */
+/** Callable shape of {@link Select}: same form-typed `validate` contract
+ * as {@link FieldComponent}. */
 type SelectComponent = {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: SelectProps<TValues, TPath> & React.RefAttributes<HTMLSelectElement>): React.ReactElement | null;
+    <TValues extends Record<string, any> = any, TPath extends AnyPath<TValues> = AnyPath<TValues>>(props: SelectProps<TValues, TPath> & React.RefAttributes<HTMLSelectElement>): React.ReactElement | null;
 };
 declare const Select: SelectComponent;
 
-export { Checkbox, CheckboxGroupContext, CheckboxGroupProvider, Field, FieldError, FieldErrorEntry, FieldPath, Form, FormContext, FormEvents, FormField, Form$1 as FormInstance, FormProvider, Name, Options, Path, PathSegments, PathValueOf, Select, SyncValidator, ValidationMode, Validator, changeValue, changeValueByPath, createFormContext, emitChangeByPath, fieldErrorId, getDirtyFields, getFieldState, getTouchedFields, getValue, getValueByPath, getValues, handleSubmit, hasTouched, hasTouchedByPath, incrementSubmitCount, isDirty, isFieldDirtyByPath, isTouched, registerFieldMode, removeField, removeFieldByPath, reset, resetField, seedValueByPath, setDisabled, setInitialValues, setIsSubmitting, setStatus, setSubmitSuccessful, setTouched, setTouchedByPath, setValue, setValueByPath, subscribe, unregisterFieldMode, useCanSubmit, useCheckboxGroupContext, useDirtyFields, useError, useErrorByPath, useField, useFieldArray, useFieldArrayItem, useFieldErrors, useFieldErrorsByPath, useForm, useFormContext, useFormError, useFormErrors, useFormState, useHasErrors, useIsDirty, useIsFieldDirty, useIsFieldDirtyByPath, useIsLoading, useIsSubmitSuccessful, useIsSubmitting, useIsValid, useIsValidating, useStatus, useSubmitCount, useTouched, useTouchedByPath, useTouchedFields, useTransform, useValue, useValueByPath, useWatch, useWatchCore, userBlur, userChangeByPath };
-export type { FieldRules, FieldState, FormState, HandleSubmitOptions, RemoveFieldOptions, ResetFieldOptions, ResetOptions, SetFieldOptions, SubscribeEvent, SubscribeOptions, UseTransformOptions, UseValueOptions, WatchScope };
+/** Props for <ErrorSummary>: same form/context resolution <Form> itself
+ * uses — an explicit `form` wins, otherwise the (optionally isolated)
+ * context form. */
+type ErrorSummaryProps<T extends Record<string, any> = any> = {
+    form?: Form$1<T>;
+    context?: React.Context<Form$1<any> | null>;
+    heading?: string;
+};
+/** A GOV.UK-style error summary: one `role='alert'` box listing every
+ * field error, each linking to the field's error element id. Clicking a
+ * link focuses the field through the same `focusError` channel a failed
+ * submit uses; after a failed submit the box itself takes focus (pair it
+ * with `shouldFocusError={false}`, whose field focus lands later and
+ * would otherwise win). {@link FORM_ERROR} entries have no field to focus
+ * and render as plain list items. */
+declare function ErrorSummary<T extends Record<string, any> = any>({ form: formProp, context, heading }: ErrorSummaryProps<T>): React.ReactElement | null;
+
+export { AnyPath, Checkbox, CheckboxGroupContext, CheckboxGroupProvider, ErrorSummary, Field, FieldError, FieldErrorEntry, FieldErrors, FieldErrorsTree, FieldPath, FieldRules, Form, FormContext, FormEvents, FormField, Form$1 as FormInstance, FormProvider, Name, Options, Path, PathValueOf, RegisterOptions, RegisterProps, Select, StandardSchemaV1, ValidationMode, Validator, changeValue, changeValueByPath, createFormContext, emitChangeByPath, fieldErrorId, firstMountedDescendantKey, getDirtyFields, getFieldState, getTouchedFields, getValue, getValueByPath, getValues, handleSubmit, hasTouched, hasTouchedByPath, incrementSubmitCount, isDirty, isFieldDirtyByPath, isTouched, registerField, registerFieldMode, removeField, removeFieldByPath, reset, resetField, seedValueByPath, setDisabled, setInitialValues, setIsSubmitting, setStatus, setSubmitSuccessful, setTouched, setTouchedByPath, setValue, setValueByPath, subscribe, unregisterFieldMode, useCanSubmit, useCheckboxGroupContext, useDirtyFields, useError, useErrorByPath, useErrors, useErrorsTree, useField, useFieldArray, useFieldArrayItem, useFieldErrors, useFieldErrorsByPath, useForm, useFormContext, useFormError, useFormErrors, useFormState, useHasErrors, useIsDirty, useIsFieldDirty, useIsFieldDirtyByPath, useIsLoading, useIsSubmitSuccessful, useIsSubmitting, useIsValid, useIsValidating, useStatus, useStore, useSubmitCount, useTouched, useTouchedByPath, useTouchedFields, useTransform, useValue, useValueByPath, useValues, useWatch, useWatchCore, userBlur, userChangeByPath, watch };
+export type { ActionErrorResult, FieldArrayFocusOptions, FieldState, FormContextBundle, FormState, HandleSubmitOptions, RemoveFieldOptions, ResetFieldOptions, ResetOptions, SetFieldOptions, SubscribeEvent, SubscribeOptions, UseTransformOptions, UseValueOptions, WatchHandle, WatchScope };