attaform 0.27.6 → 0.29.0

package/dist/shared/{attaform.DniawQLP.d.cts → attaform.CsoeRi3P.d.mts}

@@ -164,6 +164,65 @@ declare const ROOT_PATH_KEY: PathKey;
  */
 declare function isPathPrefix(prefix: readonly Segment[], path: readonly Segment[]): boolean;
 
+/**
+ * Per-path field status. Replaced wholesale (not mutated in place) on
+ * every change. Five semantic groups:
+ *
+ *   - `connected` — is a DOM element registered for this path?
+ *   - `focused` / `blurred` — DOM-state flags. `null` while no element
+ *     is connected (no DOM means the concepts don't apply); plain
+ *     booleans once connected, with the invariant `blurred === !focused`
+ *     enforced by `markFocused`.
+ *   - `touched` — focus/blur history, not DOM state. Always a plain
+ *     boolean: `false` at registration, sticky `true` after first blur,
+ *     cleared only by `form.reset()` / `form.resetField(path)`. Persists
+ *     across disconnects so v-if'd-away fields don't lose their touched
+ *     state on rehide (wizard "show review of touched fields" patterns
+ *     rely on this).
+ *   - `interacted` — value-mutation history, not DOM state. Plain
+ *     boolean: `false` at registration, sticky `true` once the user
+ *     issues a value edit through the directive's input listeners
+ *     (never on hydration, default seeding, or programmatic setValue);
+ *     cleared with `touched` by `form.reset()` / `form.resetField(path)`.
+ *   - `blurredAfterInteraction` — the first blur that follows a value
+ *     edit (the field has been edited and then left). Plain boolean,
+ *     sticky `true`. A tab-through blur with no prior edit does NOT set
+ *     it (`interacted` is still false at that blur). Composes
+ *     `interacted` with the departure; drives the default display gate.
+ */
+type FieldRecord = {
+    readonly path: Path;
+    readonly updatedAt: string | null;
+    readonly connected: boolean;
+    readonly focused: boolean | null;
+    readonly blurred: boolean | null;
+    readonly touched: boolean;
+    readonly interacted: boolean;
+    readonly blurredAfterInteraction: boolean;
+};
+/** Per-path DOM element tracking. Client-only. */
+type ElementRecord = {
+    /**
+     * Original Path captured at first registration. Stored alongside the
+     * elements Set so the DOM-order sort cache can recover the structured
+     * Path without round-tripping through `JSON.parse(pathKey)`.
+     */
+    readonly path: Path;
+    readonly elements: Set<HTMLElement>;
+};
+/**
+ * Per-path record stored in `originals`. Pairing `segments` with the tracked
+ * value means `dirty` and `resetField`'s container loop don't have to
+ * `JSON.parse(pathKey)` on every iteration — the canonical Path is already
+ * sitting next to the value it belongs to. PathKey still keys the Map (the
+ * stable string is the only collision-free identifier), but downstream
+ * iteration reads `segments` directly.
+ */
+type OriginalsRecord = {
+    readonly segments: Path;
+    readonly value: unknown;
+};
+
 /** Internal brand for the `Unset` type. Never exposed at runtime. */
 declare const _unsetBrand: unique symbol;
 /**
@@ -300,6 +359,48 @@ type JoinSegments<S extends ReadonlyArray<string | number>, Acc extends string =
     infer Head extends string | number,
     ...infer Rest extends ReadonlyArray<string | number>
 ] ? Acc extends '' ? JoinSegments<Rest, `${Head}`> : JoinSegments<Rest, `${Acc}.${Head}`> : Acc;
+/**
+ * The advice half of a segment-array rejection, used when `S` never
+ * inferred a tuple at all.
+ *
+ * A caller who passes a plain `string` reaches this branch, because
+ * inference falls back to the constraint and `JoinSegments` of a
+ * non-tuple array is `''`. Naming a path would be a lie there, so the
+ * message names the remedies instead. This is the case behind #568: a
+ * row component received its path prefix as an untyped `string` prop,
+ * every concatenation widened to `string`, and the only signal was
+ * `segments: never`.
+ */
+type PlainStringAdvice = 'attaform: a plain string cannot be checked against the schema. Pass a literal path, type the dynamic prefix, or use the segment-array form.';
+/**
+ * Why a segment array was rejected, as a type the compiler prints.
+ *
+ * Every segment-array overload brands its parameter
+ * `S & (<joined path is valid> ? unknown : <this>)`. The brand used to
+ * be `never`, and `S & never` is `never`, so TypeScript reported the
+ * parameter as `never` and said nothing about what was wrong. A string
+ * literal intersects without collapsing, so the sentence survives into
+ * the diagnostic and the argument keeps its inferred tuple type:
+ *
+ * ```
+ * Argument of type '["boxes", 3, "nope"]' is not assignable to parameter
+ * of type 'readonly ["boxes", 3, "nope"] &
+ *   "attaform: 'boxes.3.nope' is not a path in this form's schema"'.
+ * ```
+ *
+ * Nothing can satisfy the brand, so a wrong path is still a compile
+ * error; only the message changes.
+ */
+type SegmentPathRejection<Joined extends string> = [Joined] extends [''] ? PlainStringAdvice : `attaform: '${Joined}' is not a path in this form's schema`;
+/**
+ * `SegmentPathRejection` for `register`, whose accepted set is
+ * `RegisterFlatPath` rather than `FlatPath`.
+ *
+ * The distinction is worth its own sentence: a container path is in the
+ * schema and still not registrable, so "not a path in this form's
+ * schema" would be false where it is most likely to be read.
+ */
+type SegmentRegisterRejection<Joined extends string> = [Joined] extends [''] ? PlainStringAdvice : `attaform: '${Joined}' is not a registrable path. v-register binds a leaf input, so container paths are excluded.`;
 /**
  * `true` when `T` is a union (multiple members), `false` when it's a
  * single type. Used to gate non-homomorphic mapped-type forms so
@@ -464,44 +565,89 @@ type IsTuple<T extends readonly unknown[]> = number extends T['length'] ? false
  * runtime possibility of a missing array position.
  */
 type NestedReadType<RootValue, FlattenedPath extends string> = NestedTypeBuilder<RootValue, FlattenedPath, true>;
+/**
+ * The array a path actually addresses, nullish stripped, or `never`
+ * when the path does not address an array. Shared by `ArrayPath`
+ * (membership) and `ArrayItem` (element type) so the filter and the
+ * extractor cannot disagree about what counts as one.
+ *
+ * The strip is the load-bearing part. `Form` is the schema's INPUT
+ * shape, so `z.array(row).default([])` resolves to `row[] | undefined`,
+ * and `NestedType` tags a discriminated union's per-variant keys the
+ * same way on purpose: that tagging is what keeps `NestedType` in
+ * lockstep with `FlatPath`, so every path `FlatPath` offers resolves to
+ * a useful value type. A bare `extends readonly unknown[]` predicate
+ * read the tag as "not an array", which is how every optional,
+ * defaulted, nullable, and DU-variant array fell out of the field-array
+ * helpers while the runtime went on accepting all of them (#541).
+ *
+ * `extends infer Leaf` binds the stripped leaf once so the guards below
+ * do not re-instantiate `NestedType`, and the tuple wraps suppress
+ * distribution so a union leaf is judged whole: `A[] | B[]` is an
+ * array, `A[] | string` is not.
+ *
+ * Exported so `rollup-plugin-dts` keeps it as a named alias in the
+ * bundled `.d.ts` instead of inlining the body at every reference.
+ * Consumers reach for `ArrayPath` / `ArrayItem`; this alias is not part
+ * of the stable surface.
+ */
+type ArrayLeafOf<Form, P extends string> = Exclude<NestedType<Form, P>, undefined | null> extends infer Leaf ? [Leaf] extends [never] ? never : [Leaf] extends [readonly unknown[]] ? Leaf : never : never;
 /**
  * Filter FlatPath<Form> down to the subset of paths whose resolved leaf
  * is an array. Used by the typed field-array helpers (append / remove /
  * swap / ...) so those helpers only accept paths that actually address
  * an array — calling `append('email', ...)` on a `{ email: string }`
- * is a compile error.
+ * is a compile error. Optionality is not a disqualifier; see
+ * `ArrayLeafOf` for what "is an array" means here.
  *
  * `P extends string` re-triggers distribution over the `FlatPath<Form>`
  * union so the conditional evaluates per member. Without it, the
  * branch would reduce against the union as a whole and collapse to
  * `never` whenever a single member failed the predicate.
  */
-type ArrayPath<Form, P extends FlatPath<Form> = FlatPath<Form>> = P extends string ? NestedType<Form, P> extends readonly unknown[] ? P : never : never;
+type ArrayPath<Form, P extends FlatPath<Form> = FlatPath<Form>> = P extends string ? [ArrayLeafOf<Form, P>] extends [never] ? never : P : never;
 /**
  * Extract the element type of the array addressed by `Path`. Callers
  * constrain `Path extends ArrayPath<Form>` so this is always well-defined.
+ * Rides on `ArrayLeafOf`, the same alias `ArrayPath` admits the path
+ * with, so an accepted path never hands its helper a `never` value slot.
  */
-type ArrayItem<Form, Path extends ArrayPath<Form>> = NestedType<Form, Path> extends ReadonlyArray<infer Item> ? Item : never;
+type ArrayItem<Form, Path extends ArrayPath<Form>> = ArrayLeafOf<Form, Path> extends ReadonlyArray<infer Item> ? Item : never;
+/**
+ * The record a path actually addresses, nullish stripped, or `never`
+ * when the path does not address one. Shared by `RecordPath`
+ * (membership) and `RecordValue` (value type).
+ *
+ * `string extends keyof Leaf` is the index-signature probe: it holds for
+ * `Record<string, V>` (`keyof` is `string`) and fails for a fixed object
+ * (`keyof` is the literal key union). The leading array guard keeps
+ * arrays (which also satisfy the object check) out of the record set.
+ *
+ * Nullish is stripped first for the reason `ArrayLeafOf` gives, with an
+ * extra bite here: `keyof (Record<string, V> | undefined)` is `never`,
+ * so on a `.default({})` or `.optional()` record the probe could not
+ * fire at all and `form.record(path)` rejected the path (#541).
+ *
+ * Exported for the same `.d.ts` reason as `ArrayLeafOf`, and equally
+ * not part of the stable surface.
+ */
+type RecordLeafOf<Form, P extends string> = Exclude<NestedType<Form, P>, undefined | null> extends infer Leaf ? [Leaf] extends [never] ? never : [Leaf] extends [readonly unknown[]] ? never : [Leaf] extends [Record<string, unknown>] ? string extends keyof Leaf ? Leaf : never : never : never;
 /**
  * Companion to `ArrayPath`: filter `FlatPath<Form>` down to the subset
  * of paths whose resolved leaf is a record (an object with an open
  * string-keyed index signature, e.g. `z.record(z.string(), V)`). A
  * fixed-shape object (`z.object({ ... })`) is excluded — its keys are
  * statically known, so it has no `string` index signature.
- *
- * `string extends keyof T` is the index-signature probe: it holds for
- * `Record<string, V>` (`keyof` is `string`) and fails for a fixed object
- * (`keyof` is the literal key union). The leading array guard keeps
- * arrays (which also satisfy the object check) out of the record set.
  */
-type RecordPath<Form, P extends FlatPath<Form> = FlatPath<Form>> = P extends string ? NestedType<Form, P> extends readonly unknown[] ? never : NestedType<Form, P> extends Record<string, unknown> ? string extends keyof NestedType<Form, P> ? P : never : never : never;
+type RecordPath<Form, P extends FlatPath<Form> = FlatPath<Form>> = P extends string ? [RecordLeafOf<Form, P>] extends [never] ? never : P : never;
 /**
  * Value type of the record addressed by `Path` — the `V` in a
  * `Record<string, V>`. Callers constrain `Path extends RecordPath<Form>`,
  * so the leaf is always an open string-keyed record and this is
- * well-defined.
+ * well-defined. Rides on `RecordLeafOf`, the same alias `RecordPath`
+ * admits the path with, so the two cannot disagree.
  */
-type RecordValue<Form, Path extends RecordPath<Form>> = NestedType<Form, Path> extends Record<string, infer Value> ? Value : never;
+type RecordValue<Form, Path extends RecordPath<Form>> = RecordLeafOf<Form, Path> extends Record<string, infer Value> ? Value : never;
 /**
  * Widens primitive-literal leaves to their primitive supertype to
  * match the runtime "slim-primitive write contract."
@@ -722,11 +868,13 @@ interface JsonObject {
  * structured array — `['user', 'address', 0, 'line1']` for a nested
  * field, `[]` (the root path) for a form-level error (root `.refine()`
  * messages, `setErrors` entries with no path, hydration failures,
- * server-emitted form banners). `formKey` identifies which form
- * produced the error so a single error list can be routed to multiple
- * forms. The optional `data` slot carries an arbitrary server payload.
+ * server-emitted form banners). Which form produced an error is
+ * envelope-level identity: the `ValidationResponse` / submit result
+ * that carries the list stamps `formKey` once, and aggregators that
+ * merge lists across forms (the wizard) stamp their own envelope. The
+ * optional `data` slot carries an arbitrary server payload.
  *
- * Returned by `validate()` / `validateAsync()` / `handleSubmit`'s
+ * Returned by `validate()` / `parse()` / `handleSubmit`'s
  * `onError` callback, and accepted (leniently, as `ErrorInput`) by
  * `form.setErrors`.
  */
@@ -741,8 +889,6 @@ type ValidationError = {
      * literal empty-key field.
      */
     path: (string | number)[];
-    /** Identifies which form produced this error. */
-    formKey: FormKey;
     /**
      * Stable machine identifier for the failure, scoped by prefix:
      *
@@ -764,6 +910,23 @@ type ValidationError = {
      */
     data?: Json | null;
 };
+/**
+ * One path's slot in the form's tagged error store. The two sources
+ * that can put an error at a path stay segregated inside the cell:
+ * `schema` holds the validation pipeline's verdicts, `user` holds
+ * `setErrors` entries (and their history / SSR replays). Reads merge
+ * schema -> derived-blank -> user; each writer replaces exactly its
+ * own side. Cells are immutable — every write replaces the whole cell
+ * (or deletes the key when both sides empty), so Vue's per-key Map
+ * tracking fires for any side's change. An empty side is the shared
+ * frozen `NO_ERRORS` array, never a fresh allocation.
+ *
+ * @internal
+ */
+type ErrorCell = {
+    readonly schema: readonly ValidationError[];
+    readonly user: readonly ValidationError[];
+};
 /**
  * The lenient input shape `form.setErrors` accepts: a real `Error`, or
  * a partial `ValidationError` where every field is optional.
@@ -773,20 +936,17 @@ type ValidationError = {
  *   the path-scoped `setErrors(path, …)` form, which stamps its own.
  * - `code`: defaults to `atta:user-error`.
  * - `data`: forwarded verbatim onto the produced `ValidationError`.
- * - `formKey`: accepted but ignored — the form always stamps its own.
  *
- * Because every field is optional and `formKey` is accepted-and-ignored,
- * `ValidationError` is a subtype of `ErrorInput`: a `ValidationError[]`
- * you read back, or a server response that already emits the shape, pipes
- * straight into `form.setErrors` with no adapter and no excess-property
- * friction.
+ * Because every field is optional, `ValidationError` is a subtype of
+ * `ErrorInput`: a `ValidationError[]` you read back, or a server
+ * response that already emits the shape, pipes straight into
+ * `form.setErrors` with no adapter.
  */
 type ErrorInput = Error | {
     message?: string;
     path?: (string | number)[];
     code?: string;
     data?: Json | null;
-    formKey?: FormKey;
 };
 /** Settled validation result when the form (or subtree) parsed successfully. */
 type ValidationResponseSuccess<TData> = {
@@ -831,10 +991,19 @@ type ValidationResponse<TData> = ValidationResponseSuccess<TData> | ValidationRe
 type DefaultValuesResponse<TData> = ValidationResponseSuccess<TData> | ValidationResponseErrorWithData<TData>;
 /**
  * Trimmed `ValidationResponse` that omits the `data` payload. Used by
- * `validate()` / `validateAsync()` since consumers usually only need
- * the success flag and error list at those entry points.
+ * the reactive `validate()` status, whose consumers only need the
+ * success flag and error list.
  */
 type ValidationResponseWithoutValue<Form> = Omit<ValidationResponse<Form>, 'data'>;
+/**
+ * Options bag for `form.parse`. `commit: true` turns the pure read
+ * into an authoritative run: the verdict is committed to the error
+ * store at the parsed scope and in-flight per-field validation runs
+ * are cancelled first. Default `false`.
+ */
+type ParseOptions = {
+    readonly commit?: boolean;
+};
 /**
  * Sync-or-async return shape for `AbstractSchema.validateAtPath`. The
  * adapter returns the response inline when the schema and the
@@ -998,7 +1167,7 @@ type AbstractSchema<Form, GetValueFormType> = {
      * the gate accepts the consumer's raw value verbatim and stops
      * walking children — storage holds the user's input, and the
      * normalizer fires during `safeParse` (handleSubmit / validate /
-     * validateAsync), not at `setValue` time.
+     * parse), not at `setValue` time.
      *
      * Path-prefix semantic: returns true if ANY ancestor of `path`
      * resolves to such a wrapper, so descendants under a preprocess-
@@ -1006,29 +1175,50 @@ type AbstractSchema<Form, GetValueFormType> = {
      * the result by canonicalized path key.
      */
     isPreprocessOrCoerceLeaf(path: Path): boolean;
+    /**
+     * Reports whether `path` resolves to an opaque leaf: a schema that
+     * declares a value without describing its shape. In Zod v4 that's
+     * `z.any()`, `z.unknown()`, and `z.custom(...)` (the kind both
+     * `z.instanceof(X)` and `z.custom<T>()` compile to); in Zod v3 it's
+     * `z.any()` / `z.unknown()`, with `z.instanceof(X)` peeling through
+     * `ZodEffects` to `ZodAny`.
+     *
+     * Consulted by the slim-primitive write gate. An opaque leaf admits
+     * every kind, INCLUDING containers, and it declares no sub-paths.
+     * Without this the gate accepts an array at the leaf and then walks
+     * into it, checking `files.0` against a schema that never declared
+     * that path; the empty accept set there reads as "not in your
+     * schema" and no-ops the whole write (#542).
+     *
+     * Exact-path semantic, unlike `isPreprocessOrCoerceLeaf`: it answers
+     * for the node at `path` only. Descendants stay unwritable on their
+     * own, because the schema genuinely does not declare them and
+     * fabricating them would put phantom nodes on `form.fields`. Writing
+     * the whole value at the opaque leaf is the supported move.
+     */
+    isOpaqueLeafAtPath(path: Path): boolean;
     /**
      * Distinguish a tuple (fixed-length, position-typed) from an
      * unbounded array at `path`. The runtime calls this on every
      * `mergeStructural` / `setAtPathWithSchemaFill` write that descends
-     * into an array branch — caching the answer at the schema level
-     * replaces the per-write 1M-index probe + sequential probe loop
-     * (up to 1024 schema lookups) the runtime previously used.
+     * into an array branch, and the answer is definitive — the runtime
+     * never second-guesses it.
      *
      * Return values:
      * - `number` → tuple of this structural length. The runtime pads
      *   the consumer to this length and recurses position-by-position.
-     * - `null` → unbounded array. The runtime uses the consumer's
-     *   length and reuses one element default for every position.
-     * - `undefined` → the path doesn't resolve to an array OR the
-     *   adapter can't determine the shape. The runtime falls back to
-     *   a probe loop in this case (defensive — every built-in adapter
-     *   returns `number` or `null`).
+     * - `null` → not a tuple. Covers the unbounded array (the runtime
+     *   uses the consumer's length and reuses one element default for
+     *   every position) and every path that doesn't resolve to an
+     *   array at all — there `getDefaultAtPath` yields no element
+     *   default either, so the consumer's array passes through
+     *   unchanged.
      *
      * Wrappers (optional / nullable / default / readonly / catch /
      * pipe / lazy) are peeled transparently before the type check, so
      * `optional(z.tuple([...]))` reports its tuple length.
      */
-    arrayShapeAtPath(path: Path): number | null | undefined;
+    arrayShapeAtPath(path: Path): number | null;
     /**
      * Whether the schema at `path` is a FIXED object: a closed set of
      * declared keys (`z.object`), as opposed to an open or union container
@@ -1052,6 +1242,29 @@ type AbstractSchema<Form, GetValueFormType> = {
      * `false`.
      */
     isFixedObjectAtPath(path: Path): boolean;
+    /**
+     * How the container at `path` spells the keys of its own entries:
+     * `'number'` for an array or a tuple, `'string'` for an object or a
+     * record, and for a `z.map` the kind its declared key type accepts.
+     * `undefined` for anything else, a leaf and an undeclared path
+     * included.
+     *
+     * The write walkers consult it at a `Map`, where a new entry has to
+     * be filed under a key of the declared type and the path segment
+     * alone cannot say which: an integer-looking segment canonicalises
+     * to a number, so `scores.42` against a `z.map(z.string(), V)` would
+     * otherwise take the number `42` as its key and fail the map's own
+     * parse. An entry the map already holds needs no ruling — its
+     * existing key wins.
+     *
+     * A map whose key type is neither string-ish nor number-ish, or
+     * which admits both, reports `undefined`: no segment can spell such
+     * a key, so the map stays a whole value with no addressable entries.
+     *
+     * Adapters MAY cache per path; the runtime calls this on the write
+     * path.
+     */
+    entryKeyKindAtPath(path: Path): 'string' | 'number' | undefined;
     /**
      * Return every sub-schema that could resolve at the given structured
      * path. Multiple results are only expected for discriminated / union
@@ -1122,9 +1335,12 @@ type AbstractSchema<Form, GetValueFormType> = {
      */
     getSlimPrimitiveTypesAtPath(path: Path): Set<SlimPrimitiveKind>;
     /**
-     * Return `true` iff `path` resolves to a **leaf** in the schema — a
-     * path whose slim primitive set contains only primitive kinds (no
-     * `object`, `array`, `map`, `set`). The runtime proxies (`form.values`,
+     * Return `true` iff `path` resolves to a **leaf** in the schema: a
+     * path the schema declares no sub-paths under. That is every path
+     * whose slim primitive set contains only primitive kinds (no
+     * `object`, `array`, `map`, `set`), plus the opaque leaves, which
+     * admit every kind and are classified by kind instead (below). The
+     * runtime proxies (`form.values`,
      * `form.errors`, `form.fields`) query this at every step to decide
      * between **descend into a sub-proxy** (container) and **terminate
      * with a leaf value** (leaf).
@@ -1142,6 +1358,14 @@ type AbstractSchema<Form, GetValueFormType> = {
      *   date/function) → `true`. `'date'` counts as a leaf (don't drill
      *   into `Date`). `'function'` is a leaf for the same reason — opaque
      *   value.
+     * - **Opaque leaf** (`z.any()`, `z.unknown()`, `z.custom()`, and the
+     *   `z.instanceof(X)` that compiles to it) → `true`, and it answers
+     *   ahead of the kind test. An opaque leaf admits every kind
+     *   INCLUDING the container ones, so reading it off the slim
+     *   primitive set alone classifies it as a container and puts
+     *   phantom nodes under it on `form.fields` — see
+     *   `isOpaqueLeafAtPath`. What leafness asks is whether the schema
+     *   declares sub-paths here, and an opaque leaf declares none.
      * - **Optional / Nullable / Default / Catch** wrappers transparent —
      *   adds `'null'` / `'undefined'` to the inner kind set without
      *   changing the leaf classification.
@@ -1307,6 +1531,19 @@ type AbstractSchema<Form, GetValueFormType> = {
      * toward returning `true` when in doubt.
      */
     hasContainerOrRootRefine?(): boolean;
+    /**
+     * `true` when the schema tree contains at least one discriminated
+     * union at any depth (inside arrays, tuples, records, and lazy
+     * schemas included). The store computes its per-form DU capability
+     * flag from this once at construction: `false` lets every write skip
+     * the cross-variant ancestor guard and the variant-reshape dispatch,
+     * and DU stub correction never runs. Optional: an adapter that omits
+     * it is treated as containing unions, keeping the conservative
+     * per-write probes on. Never return `false` for a schema that DOES
+     * hold a discriminated union — that disables variant reshape and
+     * stub correction for the form.
+     */
+    hasDiscriminatedUnions?(): boolean;
 };
 /**
  * Adapter-returned info for a discriminated union — its discriminator
@@ -1422,7 +1659,7 @@ type OnInvalidSubmitPolicy = 'none' | 'focus-first-error' | 'scroll-to-first-err
  *   registered field. No debounce — `debounceMs` is rejected by the
  *   type.
  * - `'submit'`: no live validation. `handleSubmit` and explicit
- *   `validate()` / `validateAsync()` calls are the only validation
+ *   `validate()` / `parse()` calls are the only validation
  *   surfaces. `debounceMs` is rejected by the type.
  */
 type ValidateOn = 'change' | 'blur' | 'submit';
@@ -1499,8 +1736,8 @@ type WriteMeta = {
     readonly skipDiscriminatorReshape?: boolean;
     /**
      * Records an array structural mutation precisely enough to replay the
-     * exact index permutation it produced, set by `field-arrays.ts`
-     * helpers. `setValueAtPath` uses it to surgically clear variant memory
+     * exact index permutation it produced, set by the typed array helpers
+     * in `array-engine.ts`. `setValueAtPath` uses it to surgically clear variant memory
      * for the indices the operation invalidated. Without this hint, a raw
      * whole-array `setValue(arrayPath, [...])` clears all memory under the
      * array (the runtime can't tell which indices stayed put). Internal —
@@ -1551,19 +1788,68 @@ type WriteMeta = {
     readonly hydration?: boolean;
 };
 /**
- * Undo/redo configuration passed via `useForm({ history })`.
+ * The store slice the history runtime binds to. Structural on purpose:
+ * `historyPlugin()` ships from the separate `attaform/history` entry, so
+ * the runtime receives the store through this seam instead of importing
+ * the store module (which would pull the history internals onto every
+ * form's eager path). A FormStore satisfies it as-is.
+ *
+ * @internal
+ */
+type HistoryKernel = {
+    readonly form: Ref<unknown>;
+    readonly blankPaths: Set<PathKey>;
+    readonly errorCells: Map<PathKey, ErrorCell>;
+    onFormChange(listener: (next: unknown, meta?: WriteMeta) => void): () => void;
+    applyFormReplacement(next: unknown): void;
+    restoreErrorCells(entries: ReadonlyArray<readonly [PathKey, ErrorCell]>): void;
+};
+/**
+ * The live undo/redo runtime a {@link HistoryPlugin} attaches to one
+ * form. Cached on the FormStore so every `useForm` / `injectForm`
+ * consumer of the same key shares one chain; `buildFormApi` adapts it
+ * into the public `form.history` namespace.
  *
- * - `true` — enable with the default position cap (`max: 128`).
- * - `{ max }` — enable and tune the bounded history size.
+ * @internal
+ */
+type HistoryModule = {
+    undo(): boolean;
+    redo(): boolean;
+    clear(): void;
+    canUndo: Readonly<ComputedRef<boolean>>;
+    canRedo: Readonly<ComputedRef<boolean>>;
+    historySize: Readonly<ComputedRef<number>>;
+    dispose(): void;
+};
+/**
+ * Opt-in undo/redo, created by `historyPlugin()` from `attaform/history`
+ * and passed via `useForm({ history })`:
+ *
+ * ```ts
+ * import { historyPlugin } from 'attaform/history'
+ *
+ * const form = useForm({ schema, history: historyPlugin({ max: 200 }) })
+ * ```
  *
- * When enabled, every mutation records a forward delta; `form.history.undo()`
+ * When enabled, every mutation records a position; `form.history.undo()`
  * / `form.history.redo()` walk the chain. `reset()` is itself a mutation —
  * the pre-reset state stays one undo away. Persistence hydration is the
  * floor: after hydrate applies, the chain reseeds with the hydrated value
  * and `undo()` cannot reach the transient pre-hydration default.
+ *
+ * One plugin instance is a reusable configuration, not per-form state:
+ * passing the same instance to several forms (or setting it once via
+ * `createAttaform({ defaults: { history } })`) gives each form its own
+ * independent chain.
  */
-type HistoryConfig = true | {
-    max?: number;
+type HistoryPlugin = {
+    /**
+     * Bind a fresh history runtime to one form's store. Called by
+     * `useForm` when the store is first created.
+     *
+     * @internal
+     */
+    readonly attach: (kernel: HistoryKernel) => HistoryModule;
 };
 /**
  * Consolidated undo/redo namespace at `form.history`. All history-related
@@ -1781,16 +2067,17 @@ type UseFormConfiguration<Form extends GenericForm, GetValueFormType, Schema ext
      */
     debounceMs?: number;
     /**
-     * Opt-in undo/redo. Off by default. `true` enables with a 128-position
-     * cap; `{ max: N }` tunes the cap.
+     * Opt-in undo/redo. Off by default. Pass `historyPlugin()` from
+     * `attaform/history` — a 128-position cap by default,
+     * `historyPlugin({ max: N })` to tune it.
      *
-     * Every mutation records a forward delta. `form.history.undo()` walks
+     * Every mutation records a position. `form.history.undo()` walks
      * one step back; `form.history.redo()` walks one step forward.
      * `reset()` is itself a mutation, so the pre-reset state stays one
      * undo away. The consolidated `form.history` namespace also exposes
      * `clear()`, `canUndo`, `canRedo`, and `size`.
      */
-    history?: HistoryConfig;
+    history?: HistoryPlugin;
     /**
      * Whether to remember the typed state of each discriminated-union
      * variant across switches. Default `true`.
@@ -1936,8 +2223,8 @@ type AttaformDefaults = {
      * `validateOn` resolves to `'change'`. Default `0` (synchronous).
      */
     debounceMs?: number;
-    /** Default for `useForm({ history })`. */
-    history?: HistoryConfig;
+    /** Default for `useForm({ history })` — a `historyPlugin()` instance. */
+    history?: HistoryPlugin;
     /** Default for `useForm({ rememberVariants })`. */
     rememberVariants?: boolean;
     /** Default for `useForm({ disabled })` — freeze the form's data. */
@@ -2016,7 +2303,7 @@ type AttaformDefaults = {
      *
      * "Permissive fallback" means storage and reads keep working at any
      * depth; only the per-write type gate stops checking past the cap.
-     * Full schema validation (`validateAsync`, `handleSubmit`) still runs
+     * Full schema validation (`parse`, `handleSubmit`) still runs
      * against the real schema, so refinement errors at any depth still
      * surface — the cap only affects the *write-time gate*.
      *
@@ -2425,6 +2712,49 @@ type RegisterOptions = {
      */
     autoAria?: boolean;
 };
+/**
+ * The narrow kernel surface the DOM binding drives. Structurally a
+ * subset of the form store: the field-record connect/disconnect
+ * transitions, focus marking (which owns blur-validation), the record
+ * and merged-error reads the focus walk needs, and the async-transform
+ * abort for a fully-detached path.
+ * @internal
+ */
+type DomBindingKernel = {
+    readonly noteDomConnected: (path: Path) => void;
+    readonly noteDomDisconnected: (path: Path) => void;
+    readonly markFocused: (path: Path, focused: boolean, meta?: {
+        readonly instance?: WriteMeta['instance'];
+    }) => void;
+    readonly getFieldRecord: (path: Path) => FieldRecord | undefined;
+    readonly getErrorsForPath: (path: Path) => ValidationError[];
+    readonly cancelTransformsUnder: (prefix: Path) => void;
+};
+/**
+ * The form store's DOM slice: the element registry backing
+ * `field.element` / `field.elements`, no-latch host focus anchors, and
+ * first-error focus resolution. Implemented in the directive cluster's
+ * lazy graph and armed into the store's `domBinding` slot on first use
+ * (see `RegisterValue.ensureDomBinding`); a `null` slot means nothing
+ * in the app ever registered an element.
+ * @internal
+ */
+type AttaformDomBinding = {
+    readonly elements: Map<PathKey, ElementRecord>;
+    readonly attach: (segments: Path, element: HTMLElement, formInstanceId: string, instanceMeta: WriteMeta['instance'] | undefined) => void;
+    readonly detach: (segments: Path, element: HTMLElement) => void;
+    readonly markHostConnected: (segments: Path, connected: boolean, hostEl: HTMLElement, formInstanceId: string) => void;
+    readonly getFirstErrorElement: (formInstanceId: string) => {
+        path: Path;
+        element: HTMLElement;
+    } | null;
+};
+/**
+ * Factory the directive / `useRegister` inject through
+ * `RegisterValue.ensureDomBinding` to arm a store's `domBinding` slot.
+ * @internal
+ */
+type DomBindingFactory = (kernel: DomBindingKernel) => AttaformDomBinding;
 /**
  * The object returned by `form.register(path)`. Pass it to a native
  * input via `v-register`:
@@ -2530,6 +2860,17 @@ type RegisterValue<Value = unknown> = Readonly<{
      * @internal
      */
     hasRegisteredDescendant: (hostElement: HTMLElement) => boolean;
+    /**
+     * Arm this binding's form store with the DOM-binding implementation
+     * (element registry, focus listeners, first-error focus resolution).
+     * The implementation lives in the directive cluster's lazy graph, so
+     * the directive and `useRegister` inject its factory here before any
+     * element call; once armed, the store's `domBinding` slot serves every
+     * later registration. Optional so hand-rolled RegisterValues, which
+     * own their element handling, don't have to declare it.
+     * @internal
+     */
+    ensureDomBinding?: (factory: DomBindingFactory) => void;
     /**
      * Canonical, JSON-encoded path key for this binding (e.g.
      * `'["items",0,"name"]'`). Useful for stable Map / Set keys, log
@@ -2958,10 +3299,10 @@ type RegisterModelDynamicCustomDirective = ObjectDirective<HTMLInputElement | HT
  * See `RegisterTextModifier` / `RegisterSelectModifier` for
  * per-modifier semantics.
  *
- * Registered globally by `createAttaform()` (and by the
- * `attaform/nuxt` module). Most consumers don't import the
- * directive itself — it's exposed for integrations that install
- * directives manually.
+ * Delivered by the Vite / Nuxt plugin's compile-time binding, or by
+ * `installVRegister(app)` from `attaform/directive` everywhere else.
+ * Most consumers don't import the directive itself — it's exposed for
+ * integrations that install directives manually.
  */
 type RegisterDirective = RegisterTextCustomDirective | RegisterCheckboxCustomDirective | RegisterSelectCustomDirective | RegisterRadioCustomDirective | RegisterModelDynamicCustomDirective;
 /**
@@ -3015,9 +3356,11 @@ declare module 'vue' {
  * form.setValue((prev) => ({ ...prev, name: 'Ada' }))
  * ```
  *
- * The library fills any missing structural slots (e.g. nested
- * objects) against the schema's defaults after the callback returns,
- * so partial returns are safe.
+ * A whole-form callback replaces the whole form. Any key the return
+ * omits is refilled from the SCHEMA's declared defaults (the slim
+ * value where none is declared), so an omitted key is not carried
+ * over from the previous value or from `defaultValues` — spread
+ * `prev` to keep the rest of the form.
  */
 type SetValueCallback<Read, Write = Read> = (prev: Read) => Read | Write;
 /**
@@ -3206,7 +3549,7 @@ type FieldState<Value = unknown> = {
      * `true` while a per-field validation run is in flight at this path.
      * Reflects field-level debounced runs (`validate-on-change`) and
      * cross-field re-validations targeting this path. Whole-form
-     * `validate()` / `validateAsync()` calls drive `form.meta.validating`
+     * `validate()` / `parse()` calls drive `form.meta.validating`
      * only — they don't flip per-field flags.
      *
      * Per-field analogue of `form.meta.validating`. Use for a tight
@@ -3650,7 +3993,7 @@ type FieldStateMap<Form extends GenericForm> = LeafWalker<Form, 'field'> & {
      * dot/bracket access (`form.fields.users[i].email`), which is what
      * descends.
      */
-    <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : never)): FieldState<NestedType<Form, JoinSegments<S>>>;
+    <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : SegmentPathRejection<JoinSegments<S>>)): FieldState<NestedType<Form, JoinSegments<S>>>;
     /**
      * Dynamic-array fallback for callers passing `Path`-typed (runtime)
      * segment arrays — e.g. forwarding `RegisterValue.segments` to
@@ -3721,7 +4064,7 @@ type FormErrorsSurface<Form> = ErrorsProxyShape<Form> & {
      * tuples that don't resolve to a known path fail at the call site.
      * Dynamic `Path`-typed inputs hit the untyped fallback overload below.
      */
-    <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : never)): readonly ValidationError[];
+    <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : SegmentPathRejection<JoinSegments<S>>)): readonly ValidationError[];
     (segments: ReadonlyArray<string | number>): readonly ValidationError[];
     /**
      * No-arg call returns the whole-form error aggregate, the same as
@@ -3766,6 +4109,27 @@ type ErrorsProxyShape<T> = LeafWalker<T, 'errors', false>;
  * form.values()                      // the whole form value (root)
  * ```
  *
+ * The two shapes answer different questions. Dot access is the
+ * REACTIVE view: per-key tracking, no copying, always the live value.
+ * The call form returns a SNAPSHOT: a detached plain object that keeps
+ * what it held at capture time, so it is the shape to hand an async
+ * call, a serialiser, or a diff.
+ *
+ * ```ts
+ * const before = form.values()   // detached; survives later writes
+ * await api.save(before)         // cannot mutate underneath the call
+ * form.values.email              // reactive read; use this in computed
+ * ```
+ *
+ * Prefer dot access inside a `computed`, `watchEffect`, or template:
+ * it tracks the one key you read, where the call form depends on the
+ * whole form and re-runs the consumer on any change.
+ *
+ * The copy is deep across plain objects and arrays. Non-plain
+ * instances (Map, Set, File, Date) are shared by reference, matching
+ * `JSON.stringify` behaviour; `structuredClone(form.values())` gives a
+ * fully detached copy when one is needed.
+ *
  * Single-bracket dotted access (`form.values['address.city']`) is
  * intentionally NOT supported — JS object semantics treat the dotted
  * string as a single key. Use chained dot/bracket or the callable
@@ -3809,7 +4173,9 @@ type ValuesSurface<F> = Readonly<LiftedValueShape<F>> & {
  * `form.fields.<path>`; this is the aggregate view across the
  * whole form.
  *
- * Read-only at runtime — assignments throw. Destructuring snapshots
+ * Read-only at runtime — an assignment is refused with a dev-console
+ * warning and never lands (Attaform does not throw from a read
+ * surface). Destructuring snapshots
  * the current values; use `toRefs()` if you need reactive handles
  * to individual fields.
  */
@@ -4153,7 +4519,7 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
          * `form.setValue([prefix, 'line1'], 'value')`. The resolved leaf
          * type is exact, matching the dotted-string form.
          */
-        <const S extends ReadonlyArray<string | number>, Value extends PathSetValuePayload<NestedType<Form, JoinSegments<S>>>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : never), value: Value): boolean;
+        <const S extends ReadonlyArray<string | number>, Value extends PathSetValuePayload<NestedType<Form, JoinSegments<S>>>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : SegmentPathRejection<JoinSegments<S>>), value: Value): boolean;
     };
     /**
      * Reactive validation status. Re-runs whenever the form (or the
@@ -4173,19 +4539,6 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      * settles to results from the most recent call.
      */
     validate: (path?: FlatPath<Form>) => Readonly<Ref<ReactiveValidationStatus<Form>>>;
-    /**
-     * Run validation once and return the result. Unlike `validate()`,
-     * this does not subscribe to form reactivity.
-     *
-     * ```ts
-     * const result = await form.validateAsync()
-     * if (!result.success) showErrors(result.errors)
-     * ```
-     *
-     * Pass a path to validate a subtree. `state.validating` flips
-     * `true` while the promise is in flight.
-     */
-    validateAsync: (path?: FlatPath<Form>) => Promise<ValidationResponseWithoutValue<Form>>;
     /**
      * Resolve once every in-flight async `register({ transforms })` run
      * has settled — globally, or (with `path`) only at-or-under that path.
@@ -4207,9 +4560,9 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      */
     settleTransforms: (path?: FlatPath<Form>) => Promise<void>;
     /**
-     * Imperative one-shot parse. Same pipeline as `validateAsync` —
-     * runs refinements, applies `.transform()`s, composes blank-required
-     * errors — but RETAINS the parsed data instead of stripping it.
+     * Imperative one-shot parse. Runs the full pipeline — refinements,
+     * `.transform()`s, blank-required composition — against the current
+     * form snapshot and RETAINS the parsed data.
      *
      * Storage holds the "honest input view" — values you wrote, with
      * preprocess normalization applied but `.transform()` deferred. For
@@ -4227,16 +4580,31 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      * }
      * ```
      *
+     * By default the call is a PURE read: nothing is written to
+     * `form.errors`, and in-flight per-field validation runs are left
+     * alone. Pass `{ commit: true }` to make the run authoritative —
+     * the verdict is committed to the error store at the parsed scope
+     * and any in-flight per-field runs are cancelled first (mirroring
+     * `handleSubmit`), so `await form.parse('email', { commit: true })`
+     * lands a deterministic view of `form.errors.email`:
+     *
+     * ```ts
+     * const result = await form.parse({ commit: true })
+     * if (!result.success) showErrors(result.errors)
+     * ```
+     *
      * Always async, and there is no synchronous variant by design: a
      * schema can carry async refinements or transforms, so a sync parse
      * would silently miss them the moment one is added. One always-
      * awaited `parse` closes that category of bug entirely. The returned
      * promise never rejects (a thrown adapter lands as a `success: false`
      * response). Pass a path to parse a subtree only. `meta.validating`
-     * flips `true` while the promise is in flight (shared with
-     * validateAsync).
+     * flips `true` while the promise is in flight.
      */
-    parse: (path?: FlatPath<Form>) => Promise<ValidationResponse<GetValueFormType>>;
+    parse: {
+        (path?: FlatPath<Form>, options?: ParseOptions): Promise<ValidationResponse<GetValueFormType>>;
+        (options: ParseOptions): Promise<ValidationResponse<GetValueFormType>>;
+    };
     /**
      * Bind a path to a native input via `v-register`. Returns a
      * `RegisterValue` carrying the live ref and event handlers the
@@ -4263,7 +4631,7 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      */
     register: {
         <Path extends RegisterFlatPath<Form>>(path: Path, options?: RegisterOptions): RegisterValue<NestedReadType<WriteShape<ReadForm>, Path>>;
-        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [RegisterFlatPath<Form>] ? unknown : never), options?: RegisterOptions): RegisterValue<NestedReadType<WriteShape<ReadForm>, JoinSegments<S>>>;
+        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [RegisterFlatPath<Form>] ? unknown : SegmentRegisterRejection<JoinSegments<S>>), options?: RegisterOptions): RegisterValue<NestedReadType<WriteShape<ReadForm>, JoinSegments<S>>>;
     };
     /**
      * The form's identifier — either the explicit `key` passed to
@@ -4344,8 +4712,12 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      *
      * Resolves after `hydrating` flips back to `false`. Throws
      * synchronously when the form was constructed with a plain-value
-     * `defaultValues` (nothing to re-fire). Does NOT clear dirty /
-     * touched / submit state — chain `form.reset()` for that.
+     * `defaultValues` (nothing to re-fire).
+     *
+     * The payload becomes the form's defaults, the same way a
+     * `reset(next)` argument does, so `form.reset()` afterwards lands on
+     * the values just fetched. Does NOT clear touched / submit state;
+     * chain `form.reset()` for that.
      */
     rehydrate(): Promise<void>;
     /**
@@ -4403,7 +4775,7 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      */
     toRef: {
         <Path extends FlatPath<Form>>(path: Path): Readonly<Ref<NestedReadType<WriteShape<ReadForm>, Path>>>;
-        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : never)): Readonly<Ref<NestedReadType<WriteShape<ReadForm>, JoinSegments<S>>>>;
+        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form>] ? unknown : SegmentPathRejection<JoinSegments<S>>)): Readonly<Ref<NestedReadType<WriteShape<ReadForm>, JoinSegments<S>>>>;
     };
     /**
      * Set the form's manual error layer. One surface for server-side
@@ -4473,10 +4845,10 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      */
     meta: FormMeta<Form>;
     /**
-     * Restore the form to its initial state. Without arguments,
-     * re-applies the schema defaults (and any `defaultValues` passed
-     * to `useForm`). Pass `nextDefaultValues` to seed the reset with
-     * a fresh set of overrides.
+     * Restore the form to its defaults. Without arguments, re-applies
+     * whatever the defaults currently are: `useForm({ defaultValues })`
+     * on a fresh form, or the last values a `reset(next)` or an async
+     * `defaultValues` factory settled on.
      *
      * Resets:
      *   - the form value back to defaults;
@@ -4485,6 +4857,26 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      *   - touched / focused / blurred per-field flags;
      *   - submission state (`submitting` / `submissionAttempts` /
      *     `submitted` / `submitError`).
+     *
+     * `nextDefaultValues` RE-SEATS the defaults rather than applying for
+     * one call, so the form has a single set of defaults that `reset()`,
+     * `resetField(path)`, and `dirty` all read. That is what makes the
+     * save-then-discard shape work: reset from the resource the server
+     * returned, and a later Discard returns to the save instead of
+     * rolling back across it.
+     *
+     * ```ts
+     * const saved = await api.save(form.values())
+     * form.reset(toValues(saved))   // the saved resource is now the baseline
+     * // …later…
+     * form.reset()                  // back to the saved resource
+     * ```
+     *
+     * The argument is sparse: it folds over the defaults already in
+     * force, so paths it does not name keep the value they had, and
+     * `reset({})` changes nothing. Arrays are replaced wholesale rather
+     * than merged element-wise. Pass `unset` at a path to withdraw its
+     * value and mark it blank.
      */
     reset: (nextDefaultValues?: DefaultValuesInput<Form>) => void;
     /**
@@ -4539,7 +4931,7 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
     clear: {
         (): boolean;
         <Path extends FlatPath<Form> | ''>(path: Path): boolean;
-        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form> | ''] ? unknown : never)): boolean;
+        <const S extends ReadonlyArray<string | number>>(segments: S & ([JoinSegments<S>] extends [FlatPath<Form> | ''] ? unknown : SegmentPathRejection<JoinSegments<S>>)): boolean;
     };
     /**
      * Consolidated undo/redo namespace — `form.history.{undo, redo,
@@ -4759,5 +5151,5 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
     blankPaths: ComputedRef<BlankPathsView>;
 };
 
-export { ROOT_PATH as X, ROOT_PATH_KEY as Y, canonicalizePath as al, isPathPrefix as am, isUnset as an, parseDottedPath as ao, unset as ap };
-export type { RegisterFlatPath as $, AbstractSchema as A, NestedType as B, CoercionEntry as C, DefaultValuesInput as D, ErrorInput as E, FormKey as F, GenericForm as G, HandleSubmit as H, IsTuple as I, JoinSegments as J, KeyofUnion as K, LiftedValueShape as L, MetaTrackerValue as M, NestedReadType as N, OnError as O, OnInvalidSubmitPolicy as P, OnSubmit as Q, PartialFlatPath as R, Path as S, PathKey as T, UseFormConfiguration as U, PendingValidationStatus as V, Primitive as W, ReactiveValidationStatus as Z, RegisterDirective as _, UseFormReturnType as a, RegisterOptions as a0, RegisterSelectModifier as a1, RegisterTextModifier as a2, RegisterTransform as a3, RegisterValue as a4, Segment as a5, SetValueCallback as a6, SetValuePayload as a7, SettledValidationStatus as a8, SlimPrimitiveKind as a9, SlimRuntimeOf as aa, SubmitHandler as ab, Unset as ac, ValidateOn as ad, ValidateOnConfig as ae, ValidationError as af, ValidationResponse as ag, ValidationResponseWithoutValue as ah, ValueOfUnion as ai, WriteMeta as aj, WriteShape as ak, AcceptableDefaults as aq, SchemaFactoryOptions as ar, TransformAbortHolder as as, RegisterModelDynamicCustomDirective as at, ArrayItem as b, ArrayPath as c, AttaformDefaults as d, CoercionRegistry as e, CoercionResult as f, CustomDirectiveRegisterAssignerFn as g, DeepPartial as h, DefaultValuesResponse as i, DefaultValuesShape as j, DisplayCtx as k, DisplayMachine as l, DisplayState as m, ErrorsProxyShape as n, FieldMetaPayload as o, FieldState as p, FieldStateMap as q, FieldStateMapEntry as r, FlatPath as s, FormErrorRecord as t, FormErrorsSurface as u, FormMeta as v, GetDisplayState as w, HistoryConfig as x, IsUnion as y, Json as z };
+export { ROOT_PATH as Y, ROOT_PATH_KEY as Z, canonicalizePath as ao, isPathPrefix as ap, isUnset as aq, parseDottedPath as ar, unset as as };
+export type { RecordPath as $, AbstractSchema as A, NestedType as B, CoercionEntry as C, DefaultValuesInput as D, ErrorInput as E, FormKey as F, GenericForm as G, HandleSubmit as H, IsTuple as I, JoinSegments as J, KeyofUnion as K, LiftedValueShape as L, MetaTrackerValue as M, NestedReadType as N, OnError as O, OnInvalidSubmitPolicy as P, OnSubmit as Q, ParseOptions as R, PartialFlatPath as S, Path as T, UseFormConfiguration as U, PathKey as V, PendingValidationStatus as W, Primitive as X, ReactiveValidationStatus as _, UseFormReturnType as a, RecordValue as a0, RegisterDirective as a1, RegisterFlatPath as a2, RegisterOptions as a3, RegisterSelectModifier as a4, RegisterTextModifier as a5, RegisterTransform as a6, RegisterValue as a7, Segment as a8, SetValueCallback as a9, TransformAbortHolder as aA, SetValuePayload as aa, SettledValidationStatus as ab, SlimPrimitiveKind as ac, SlimRuntimeOf as ad, SubmitHandler as ae, Unset as af, ValidateOn as ag, ValidateOnConfig as ah, ValidationError as ai, ValidationResponse as aj, ValidationResponseWithoutValue as ak, ValueOfUnion as al, WriteMeta as am, WriteShape as an, RegisterModelDynamicCustomDirective as at, SchemaFactoryOptions as au, AcceptableDefaults as av, FieldRecord as aw, ErrorCell as ax, OriginalsRecord as ay, AttaformDomBinding as az, ArrayItem as b, ArrayPath as c, AttaformDefaults as d, CoercionRegistry as e, CoercionResult as f, CustomDirectiveRegisterAssignerFn as g, DeepPartial as h, DefaultValuesResponse as i, DefaultValuesShape as j, DisplayCtx as k, DisplayMachine as l, DisplayState as m, ErrorsProxyShape as n, FieldMetaPayload as o, FieldState as p, FieldStateMap as q, FieldStateMapEntry as r, FlatPath as s, FormErrorRecord as t, FormErrorsSurface as u, FormMeta as v, GetDisplayState as w, HistoryPlugin as x, IsUnion as y, Json as z };