attaform 0.21.1 → 0.22.0

package/dist/shared/{attaform.D0dWZsJt.d.mts → attaform.DvUH4a3o.d.cts}

@@ -1,4 +1,4 @@
-import { ObjectDirective, Ref, ComputedRef } from 'vue';
+import { ObjectDirective, Ref, MaybeRefOrGetter, ComputedRef } from 'vue';
 
 /**
  * Schema-attached field metadata — the shared types used by both Zod
@@ -73,6 +73,123 @@ type ResolvedFieldMeta = {
     readonly meta: Readonly<FieldMetaPayload>;
 };
 
+/**
+ * Path primitives for advanced integrations. The form library accepts
+ * paths in dotted-string form (`'user.email'`) at every public API.
+ * These primitives are exposed for adapter authors who need to
+ * canonicalise user-provided paths.
+ */
+declare const pathKeyBrand: unique symbol;
+/**
+ * Branded string identifier for a canonicalised path. Useful as a
+ * `Map` key — two paths that resolve to the same canonical form
+ * produce the same `PathKey`. Treat as opaque; don't try to parse.
+ */
+type PathKey = string & {
+    readonly [pathKeyBrand]: 'PathKey';
+};
+/** A single path segment — a property name or array index. */
+type Segment = string | number;
+/** A structured path as a read-only sequence of segments. */
+type Path = readonly Segment[];
+/**
+ * Parse a dotted-string path into structured segments.
+ *
+ * ```ts
+ * parseDottedPath('user.address.line1')   // ['user', 'address', 'line1']
+ * parseDottedPath('items.0.name')         // ['items', 0, 'name']
+ * parseDottedPath('')                     // ['']  (the empty-string key)
+ * ```
+ *
+ * The empty-string input `''` is the **literal empty-key path**, not
+ * the root. Use the array form `[]` for root. Form-level errors
+ * (root `.refine()`) live at the empty-string path bucket so
+ * `errors('')` returns them without sweeping every field error too.
+ *
+ * Throws `InvalidPathError` for paths with empty INTERNAL segments
+ * (`'a..b'`, leading or trailing dots). For keys containing literal
+ * dots, pass an array form (`['user.name']`) instead.
+ */
+declare function parseDottedPath(path: string): Segment[];
+/**
+ * Canonicalise a path into structured segments plus a stable string
+ * key. Accepts either dotted-string or array form; integer-looking
+ * segments normalise to numbers.
+ *
+ * ```ts
+ * canonicalizePath('items.0.name')
+ * // { segments: ['items', 0, 'name'], key: '["items",0,"name"]' as PathKey }
+ *
+ * canonicalizePath(['items', 0, 'name'])
+ * // → same result
+ * ```
+ *
+ * The returned `key` is suitable as a `Map`/`Set` key — equal paths
+ * produce equal keys regardless of input form.
+ */
+declare function canonicalizePath(input: string | Path): {
+    segments: readonly Segment[];
+    key: PathKey;
+};
+/**
+ * The root path — an empty segment tuple. Pass to APIs that accept
+ * a `Path` to address the form value as a whole.
+ */
+declare const ROOT_PATH: Path;
+/** Stable string key for the root path. */
+declare const ROOT_PATH_KEY: PathKey;
+/**
+ * `true` when `path` starts with every segment of `prefix` (in order).
+ * The empty `prefix` matches every path — ROOT prefix is universal.
+ *
+ * Walks segments rather than `PathKey` strings because the data this
+ * helper operates on (e.g. `meta.errors[].path`) carries segment
+ * arrays directly.
+ *
+ * ```ts
+ * isPathPrefix(['cargo'], ['cargo', 'items', 0, 'sku'])  // true
+ * isPathPrefix(['cargo', 'items'], ['cargo'])             // false (path shorter)
+ * isPathPrefix([], ['anything'])                          // true (root prefix)
+ * ```
+ */
+declare function isPathPrefix(prefix: readonly Segment[], path: readonly Segment[]): boolean;
+
+/**
+ * Per-FormStore registry tracking which DOM elements have opted into
+ * persistence for which paths. Lives on the FormStore so that two SFCs
+ * sharing a key share the registry — opt-ins are per-element, not
+ * per-component.
+ *
+ * The directive's input handler computes `meta.persist` for each write
+ * by calling `hasOptIn(elementId, path)` — only THIS element's writes
+ * persist if THIS element opted in. Other call sites that aren't tied
+ * to a single element (history undo/redo, field-array helpers, devtools
+ * edits) use `hasAnyOptInForPath(path)` — persist if any element has
+ * opted into that path.
+ *
+ * Internal data structure: `Map<PathKey, Set<elementId>>`. Small forms
+ * have ~10-50 paths; iteration is cheap. All operations are O(1) given
+ * (id, path).
+ */
+type PersistOptInRegistry = {
+    /** Add an opt-in entry; idempotent. */
+    add(elementId: string, path: PathKey): void;
+    /** Remove a single (element, path) entry. */
+    remove(elementId: string, path: PathKey): void;
+    /** Remove every opt-in for `elementId`. Called from directive's beforeUnmount. */
+    removeAllFor(elementId: string): void;
+    /** Check whether THIS element has opted into THIS path. */
+    hasOptIn(elementId: string, path: PathKey): boolean;
+    /** Check whether ANY element has opted into this path. */
+    hasAnyOptInForPath(path: PathKey): boolean;
+    /** Iterate every path that currently has at least one opt-in. */
+    optedInPaths(): IterableIterator<PathKey>;
+    /** True iff no element has opted into any path. */
+    isEmpty(): boolean;
+    /** Drop every entry. Called from FormStore.dispose. */
+    clear(): void;
+};
+
 /** Internal brand for the `Unset` type. Never exposed at runtime. */
 declare const _unsetBrand: unique symbol;
 /**
@@ -545,6 +662,15 @@ type DefaultValuesInput<T> = T extends string ? string | Unset : T extends numbe
     [K in keyof T]?: DefaultValuesInput<T[K]>;
 } | Unset : T;
 
+/**
+ * Identifier for a form. A `FormKey` is the string passed via
+ * `useForm({ key })`, used to look up a form by name from a distant
+ * component, namespace persisted drafts, and label errors and
+ * DevTools entries. Anonymous `useForm` calls allocate one
+ * automatically; you only need to pick one when the form needs
+ * stable identity.
+ */
+type FormKey = string;
 /**
  * Per-form options threaded from `useForm` into the adapter factory.
  * Today carries the resolved `maxRecursionDepth` so adapter walks can
@@ -555,133 +681,6 @@ interface SchemaFactoryOptions {
     /** Resolved recursion ceiling (per-form > app-default > library default). */
     maxRecursionDepth: number;
 }
-
-/**
- * Path primitives for advanced integrations. The form library accepts
- * paths in dotted-string form (`'user.email'`) at every public API.
- * These primitives are exposed for adapter authors who need to
- * canonicalise user-provided paths.
- */
-declare const pathKeyBrand: unique symbol;
-/**
- * Branded string identifier for a canonicalised path. Useful as a
- * `Map` key — two paths that resolve to the same canonical form
- * produce the same `PathKey`. Treat as opaque; don't try to parse.
- */
-type PathKey = string & {
-    readonly [pathKeyBrand]: 'PathKey';
-};
-/** A single path segment — a property name or array index. */
-type Segment = string | number;
-/** A structured path as a read-only sequence of segments. */
-type Path = readonly Segment[];
-/**
- * Parse a dotted-string path into structured segments.
- *
- * ```ts
- * parseDottedPath('user.address.line1')   // ['user', 'address', 'line1']
- * parseDottedPath('items.0.name')         // ['items', 0, 'name']
- * parseDottedPath('')                     // ['']  (the empty-string key)
- * ```
- *
- * The empty-string input `''` is the **literal empty-key path**, not
- * the root. Use the array form `[]` for root. Form-level errors
- * (root `.refine()`) live at the empty-string path bucket so
- * `errors('')` returns them without sweeping every field error too.
- *
- * Throws `InvalidPathError` for paths with empty INTERNAL segments
- * (`'a..b'`, leading or trailing dots). For keys containing literal
- * dots, pass an array form (`['user.name']`) instead.
- */
-declare function parseDottedPath(path: string): Segment[];
-/**
- * Canonicalise a path into structured segments plus a stable string
- * key. Accepts either dotted-string or array form; integer-looking
- * segments normalise to numbers.
- *
- * ```ts
- * canonicalizePath('items.0.name')
- * // { segments: ['items', 0, 'name'], key: '["items",0,"name"]' as PathKey }
- *
- * canonicalizePath(['items', 0, 'name'])
- * // → same result
- * ```
- *
- * The returned `key` is suitable as a `Map`/`Set` key — equal paths
- * produce equal keys regardless of input form.
- */
-declare function canonicalizePath(input: string | Path): {
-    segments: readonly Segment[];
-    key: PathKey;
-};
-/**
- * The root path — an empty segment tuple. Pass to APIs that accept
- * a `Path` to address the form value as a whole.
- */
-declare const ROOT_PATH: Path;
-/** Stable string key for the root path. */
-declare const ROOT_PATH_KEY: PathKey;
-/**
- * `true` when `path` starts with every segment of `prefix` (in order).
- * The empty `prefix` matches every path — ROOT prefix is universal.
- *
- * Walks segments rather than `PathKey` strings because the data this
- * helper operates on (e.g. `meta.errors[].path`) carries segment
- * arrays directly.
- *
- * ```ts
- * isPathPrefix(['cargo'], ['cargo', 'items', 0, 'sku'])  // true
- * isPathPrefix(['cargo', 'items'], ['cargo'])             // false (path shorter)
- * isPathPrefix([], ['anything'])                          // true (root prefix)
- * ```
- */
-declare function isPathPrefix(prefix: readonly Segment[], path: readonly Segment[]): boolean;
-
-/**
- * Per-FormStore registry tracking which DOM elements have opted into
- * persistence for which paths. Lives on the FormStore so that two SFCs
- * sharing a key share the registry — opt-ins are per-element, not
- * per-component.
- *
- * The directive's input handler computes `meta.persist` for each write
- * by calling `hasOptIn(elementId, path)` — only THIS element's writes
- * persist if THIS element opted in. Other call sites that aren't tied
- * to a single element (history undo/redo, field-array helpers, devtools
- * edits) use `hasAnyOptInForPath(path)` — persist if any element has
- * opted into that path.
- *
- * Internal data structure: `Map<PathKey, Set<elementId>>`. Small forms
- * have ~10-50 paths; iteration is cheap. All operations are O(1) given
- * (id, path).
- */
-type PersistOptInRegistry = {
-    /** Add an opt-in entry; idempotent. */
-    add(elementId: string, path: PathKey): void;
-    /** Remove a single (element, path) entry. */
-    remove(elementId: string, path: PathKey): void;
-    /** Remove every opt-in for `elementId`. Called from directive's beforeUnmount. */
-    removeAllFor(elementId: string): void;
-    /** Check whether THIS element has opted into THIS path. */
-    hasOptIn(elementId: string, path: PathKey): boolean;
-    /** Check whether ANY element has opted into this path. */
-    hasAnyOptInForPath(path: PathKey): boolean;
-    /** Iterate every path that currently has at least one opt-in. */
-    optedInPaths(): IterableIterator<PathKey>;
-    /** True iff no element has opted into any path. */
-    isEmpty(): boolean;
-    /** Drop every entry. Called from FormStore.dispose. */
-    clear(): void;
-};
-
-/**
- * Identifier for a form. A `FormKey` is the string passed via
- * `useForm({ key })`, used to look up a form by name from a distant
- * component, namespace persisted drafts, and label errors and
- * DevTools entries. Anonymous `useForm` calls allocate one
- * automatically; you only need to pick one when the form needs
- * stable identity.
- */
-type FormKey = string;
 /**
  * One validation failure. `path` points at the offending field as a
  * structured array — `['user', 'address', 0, 'line1']` for a nested
@@ -1541,6 +1540,132 @@ type WriteMeta = {
      * consumer code.
      */
     readonly crossTab?: boolean;
+    /**
+     * When `true`, this write lands normally (storage, validation,
+     * persistence, history) but does NOT notify `form.onChange` handlers.
+     * The side-channel reacts to user edits, not programmatic rebaselines:
+     * `reset()` tags its replacement with this flag, and the public
+     * `setValue(path, value, { silent: true })` option forwards it so a
+     * consumer hydrating the form (loading a saved record into the fields)
+     * can land values without echoing each one back through an autosave
+     * loop. The store's internal taggers and that single consumer-facing
+     * option are the only writers.
+     */
+    readonly silent?: boolean;
+};
+/** Options for a `setValue` write. */
+type SetValueOptions = {
+    /**
+     * When `true`, the write lands normally (storage, validation, persistence,
+     * history) but does NOT notify `form.onChange` handlers. Use it to hydrate
+     * the form (load a saved record into the fields) without echoing every
+     * field back through an autosave loop.
+     */
+    readonly silent?: boolean;
+};
+/**
+ * A source address for `form.onChange` — the subtree(s) a handler reacts to.
+ *
+ * - a dotted path string (`'user.email'`) — one leaf or subtree;
+ * - a list of path strings (`['shipping', 'billing']`) — react to any of
+ *   several paths; the handler fires once per matched path, `ctx.path`
+ *   distinguishing which;
+ * - a getter or ref / computed resolving to either — re-read on each write,
+ *   so the aim can follow a moving target (the active list row). Re-aiming
+ *   is never itself a trigger; only a real write dispatches.
+ *
+ * Omit the source entirely (`form.onChange(handler)`) to react to the whole
+ * form. An empty list (`form.onChange([], handler)`) lists zero paths, so it
+ * never fires — that is a deliberate no-op, NOT a shorthand for the root.
+ */
+type OnChangeSource = MaybeRefOrGetter<string | readonly string[]>;
+/**
+ * Context handed to an `onChange` handler alongside the changed value.
+ *
+ * `onChange` is a pure side-channel: it reacts to value changes and runs
+ * side effects, but never touches the form's own lifecycle. Nothing a
+ * handler does here marks the form dirty, pending, or validating — autosave
+ * status lives in the consumer's own state, validation in `.refine` and
+ * `field.show*`.
+ */
+type OnChangeContext<FormApi = unknown> = {
+    /**
+     * The source path this fire is for, in dotted form (`'user.email'`).
+     * The empty string `''` is the whole form (a root handler). For a
+     * multi-path source, the handler fires once per matched path and `path`
+     * names which one.
+     */
+    readonly path: string;
+    /**
+     * The value at the source path BEFORE this change, seeded at registration.
+     * Accurate for leaf sources. For a container or the whole form, an
+     * in-place leaf edit preserves the container's reference, so `previous`
+     * can be reference-equal to the current value (Vue's deep-watch gotcha) —
+     * snapshot inside the handler if a true container diff is needed.
+     */
+    readonly previous: unknown;
+    /**
+     * Aborted when a newer write to the same source supersedes this run. A
+     * debounced or awaiting handler should bail on `signal.aborted` (or pass
+     * `signal` straight to `fetch`) so superseded work cancels itself.
+     */
+    readonly signal: AbortSignal;
+    /** Retry counter — `0` on the first run, incremented by `onError`'s `retry()`. */
+    readonly attempt: number;
+    /**
+     * The form handle, so a portable `useForm({ onChange })` handler can reach
+     * back into the form (e.g. `ctx.form.validateAsync(ctx.path)` to gate an
+     * autosave on validity). Typed precisely by the `form.onChange` overload.
+     */
+    readonly form: FormApi;
+    /**
+     * The leaf path(s), in dotted form, that actually changed in this
+     * dispatch. For a leaf source this is just `[path]`; for a container or
+     * the whole form it is every changed descendant.
+     */
+    readonly changed: readonly string[];
+};
+/**
+ * Context handed to an `onChange` handler's `onError` callback when the
+ * handler throws or rejects.
+ */
+type OnChangeErrorContext<FormApi = unknown> = {
+    /** The source path this run was for, in dotted form (`''` for the whole form). */
+    readonly path: string;
+    /** The value passed to the handler that failed. */
+    readonly value: unknown;
+    /** The attempt number that failed (`0` on the first run). */
+    readonly attempt: number;
+    /**
+     * Re-run the handler with the same value and `attempt + 1`. A no-op once a
+     * newer write has superseded this run — stale work is never resurrected.
+     * Backoff and a retry cap are the consumer's to impose.
+     */
+    readonly retry: () => void;
+    /** The form handle. Typed precisely by the `form.onChange` overload. */
+    readonly form: FormApi;
+};
+/** A reaction to form value changes. Its return is ignored; throws route to `onError`. */
+type OnChangeHandler<Value = unknown, FormApi = unknown> = (value: Value, ctx: OnChangeContext<FormApi>) => void | Promise<void>;
+/** Handles a throw / rejection from an `onChange` handler. Must not throw. */
+type OnChangeErrorHandler<FormApi = unknown> = (error: unknown, ctx: OnChangeErrorContext<FormApi>) => void;
+/** Options for `form.onChange`. */
+type OnChangeOptions<FormApi = unknown> = {
+    /**
+     * Called when the handler throws or its promise rejects. Without it, a
+     * failure is swallowed (logged in dev). `onChange` never throws into the
+     * write that triggered it.
+     */
+    readonly onError?: OnChangeErrorHandler<FormApi>;
+};
+/**
+ * The `useForm({ onChange })` option — a whole-form handler registered at
+ * construction, bound to the form's lifetime. Either a bare handler or a
+ * `{ handler, onError }` pair.
+ */
+type OnChangeConfig<Value = unknown, FormApi = unknown> = OnChangeHandler<Value, FormApi> | {
+    readonly handler: OnChangeHandler<Value, FormApi>;
+    readonly onError?: OnChangeErrorHandler<FormApi>;
 };
 /**
  * Undo/redo configuration passed via `useForm({ history })`.
@@ -1826,6 +1951,17 @@ type UseFormConfiguration<Form extends GenericForm, GetValueFormType, Schema ext
      * per blur for `<input v-register.lazy>`).
      */
     debounceMs?: number;
+    /**
+     * A whole-form `onChange` handler, registered at construction and bound to
+     * the form's lifetime. The same side-channel as `form.onChange(handler)`,
+     * but declared in the options bag so it travels with the form (handy for a
+     * `useAutosave`-style composable). Pass a handler, or `{ handler, onError }`.
+     *
+     * For path-scoped reactions, call `form.onChange('path', handler)` on the
+     * returned form instead. `onChange` never touches the form's own
+     * lifecycle — keep validation in `.refine` and `field.show*`.
+     */
+    onChange?: OnChangeConfig<Form, UseFormReturnType<Form>>;
     /**
      * Opt-in persistence of the form's draft state. Off by default —
      * with no config, no reads, no writes, no storage code is loaded.
@@ -4286,8 +4422,11 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
          * type at a leaf). Refinement-level mismatches (out-of-enum
          * values, failing format checks, etc.) succeed and surface as
          * field errors instead.
+         *
+         * Pass `{ silent: true }` to land the write without notifying
+         * `form.onChange` handlers (e.g. hydrating a saved record).
          */
-        <Value extends SetValuePayload<DefaultValuesShape<Form>, WriteShape<Form>>>(value: Value): boolean;
+        <Value extends SetValuePayload<DefaultValuesShape<Form>, WriteShape<Form>>>(value: Value, options?: SetValueOptions): boolean;
         /**
          * Write at a specific path. Pass a value or a callback receiving
          * the previous value at that path.
@@ -4305,14 +4444,49 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
          * it blank (storage holds the slim default; UI displays
          * empty; submit raises "No value supplied" for required schemas).
          */
-        <Path extends FlatPath<Form>, Value extends PathSetValuePayload<NestedType<Form, Path>>>(path: Path, value: Value): boolean;
+        <Path extends FlatPath<Form>, Value extends PathSetValuePayload<NestedType<Form, Path>>>(path: Path, value: Value, options?: SetValueOptions): boolean;
         /**
          * Tuple-segment form. Equivalent to the dotted-string overload —
          * useful when paths are built from variables or arrays:
          * `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 : never), value: Value, options?: SetValueOptions): boolean;
+    };
+    /**
+     * Subscribe to form value changes — the side-channel autosave is built on.
+     * Three call forms:
+     *
+     * - `form.onChange(handler, options?)` — react to the whole form.
+     * - `form.onChange('user.email', handler, options?)` — react to one path;
+     *   `value` is that path's value.
+     * - `form.onChange(source, handler, options?)` — react to a list of paths,
+     *   or a getter / ref resolving to a path or list (re-read on each write,
+     *   so the aim can follow a moving target like the active list row).
+     *
+     * The handler runs AFTER the value lands. Its return is ignored, and a
+     * throw or rejection routes to `options.onError`, never into the write that
+     * triggered it. Returns an idempotent `stop()`; called inside a component's
+     * setup it also stops automatically on unmount.
+     *
+     * `onChange` is a pure side-channel: nothing it does marks the form dirty,
+     * pending, or validating. Keep validation feedback in `.refine` and
+     * `field.show*`, and track autosave status in your own state.
+     *
+     * ```ts
+     * form.onChange('user.email', async (email, ctx) => {
+     *   const verdict = await ctx.form.validateAsync(ctx.path)
+     *   if (verdict.success) await api.save({ email }, { signal: ctx.signal })
+     * }, { onError: (error, ctx) => ctx.retry() })
+     * ```
+     */
+    onChange: {
+        /** React to the whole form. `value` is the current form. */
+        (handler: OnChangeHandler<ReadForm, UseFormReturnType<Form, GetValueFormType, ReadForm, K>>, options?: OnChangeOptions<UseFormReturnType<Form, GetValueFormType, ReadForm, K>>): () => void;
+        /** React to one path. `value` is that path's value. */
+        <P extends FlatPath<Form>>(source: P, handler: OnChangeHandler<NestedType<Form, P>, UseFormReturnType<Form, GetValueFormType, ReadForm, K>>, options?: OnChangeOptions<UseFormReturnType<Form, GetValueFormType, ReadForm, K>>): () => void;
+        /** React to a list of paths, or a getter / ref / computed. `value` is unknown. */
+        (source: OnChangeSource, handler: OnChangeHandler<unknown, UseFormReturnType<Form, GetValueFormType, ReadForm, K>>, options?: OnChangeOptions<UseFormReturnType<Form, GetValueFormType, ReadForm, K>>): () => void;
     };
     /**
      * Reactive validation status. Re-runs whenever the form (or the
@@ -4916,5 +5090,5 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
     blankPaths: ComputedRef<BlankPathsView>;
 };
 
-export { ROOT_PATH as a0, ROOT_PATH_KEY as a1, canonicalizePath as av, isPathPrefix as aw, isUnset as ax, parseDottedPath as ay, unset as az };
-export type { Primitive as $, AbstractSchema as A, HistoryConfig as B, CoercionEntry as C, DeepPartial as D, ErrorsProxyShape as E, FieldMetaPayload as F, GenericForm as G, HandleSubmit as H, IsTuple as I, IsUnion as J, JoinSegments as K, KeyofUnion as L, LiftedValueShape as M, MetaTrackerValue as N, NestedReadType as O, NestedType as P, OnError as Q, OnInvalidSubmitPolicy as R, OnSubmit as S, PartialFlatPath as T, Path as U, PathKey as V, PendingValidationStatus as W, PersistConfig as X, PersistConfigOptions as Y, PersistIncludeMode as Z, PersistOptInRegistry as _, ApiErrorDetails as a, ReactiveValidationStatus as a2, RegisterDirective as a3, RegisterFlatPath as a4, RegisterModelDynamicCustomDirective as a5, RegisterOptions as a6, RegisterSelectModifier as a7, RegisterTextModifier as a8, RegisterTransform as a9, RegisterValue as aa, SchemaFactoryOptions as ab, Segment as ac, SetValueCallback as ad, SetValuePayload as ae, SettledValidationStatus as af, SlimPrimitiveKind as ag, SlimRuntimeOf as ah, SubmitHandler as ai, TransformAbortHolder as aj, Unset as ak, UseFormConfiguration as al, UseFormReturnType as am, ValidateOn as an, ValidateOnConfig as ao, ValidationError as ap, ValidationResponse as aq, ValidationResponseWithoutValue as ar, ValueOfUnion as as, WriteMeta as at, WriteShape as au, ApiErrorEntry as b, ApiErrorEnvelope as c, ArrayItem as d, ArrayPath as e, AttaformDefaults as f, CoercionRegistry as g, CoercionResult as h, CustomDirectiveRegisterAssignerFn as i, DefaultValuesInput as j, DefaultValuesResponse as k, DefaultValuesShape as l, DisplayCtx as m, DisplayMachine as n, DisplayState as o, FieldState as p, FieldStateMap as q, FieldStateMapEntry as r, FlatPath as s, FormErrorRecord as t, FormErrorsSurface as u, FormKey as v, FormMeta as w, FormStorage as x, FormStorageKind as y, GetDisplayState as z };
+export { canonicalizePath as aA, isPathPrefix as aB, isUnset as aC, parseDottedPath as aD, unset as aE, ROOT_PATH as ab, ROOT_PATH_KEY as ac };
+export type { OnChangeSource as $, AttaformDefaults as A, FormStorage as B, CoercionEntry as C, DefaultValuesInput as D, ErrorsProxyShape as E, FormKey as F, GenericForm as G, FormStorageKind as H, HandleSubmit as I, HistoryConfig as J, IsTuple as K, IsUnion as L, JoinSegments as M, KeyofUnion as N, LiftedValueShape as O, MetaTrackerValue as P, NestedReadType as Q, RegisterModelDynamicCustomDirective as R, NestedType as S, OnChangeConfig as T, UseFormConfiguration as U, ValidationError as V, OnChangeContext as W, OnChangeErrorContext as X, OnChangeErrorHandler as Y, OnChangeHandler as Z, OnChangeOptions as _, AbstractSchema as a, OnError as a0, OnInvalidSubmitPolicy as a1, OnSubmit as a2, PartialFlatPath as a3, Path as a4, PathKey as a5, PendingValidationStatus as a6, PersistConfig as a7, PersistConfigOptions as a8, PersistIncludeMode as a9, SchemaFactoryOptions as aF, TransformAbortHolder as aG, PersistOptInRegistry as aH, Primitive as aa, ReactiveValidationStatus as ad, RegisterDirective as ae, RegisterFlatPath as af, RegisterOptions as ag, RegisterSelectModifier as ah, RegisterTextModifier as ai, RegisterTransform as aj, Segment as ak, SetValueCallback as al, SetValueOptions as am, SetValuePayload as an, SettledValidationStatus as ao, SlimPrimitiveKind as ap, SlimRuntimeOf as aq, SubmitHandler as ar, Unset as as, ValidateOn as at, ValidateOnConfig as au, ValidationResponse as av, ValidationResponseWithoutValue as aw, ValueOfUnion as ax, WriteMeta as ay, WriteShape as az, UseFormReturnType as b, RegisterValue as c, GetDisplayState as d, ApiErrorEnvelope as e, ApiErrorDetails as f, ApiErrorEntry as g, ArrayItem as h, ArrayPath as i, CoercionRegistry as j, CoercionResult as k, CustomDirectiveRegisterAssignerFn as l, DeepPartial as m, DefaultValuesResponse as n, DefaultValuesShape as o, DisplayCtx as p, DisplayMachine as q, DisplayState as r, FieldMetaPayload as s, FieldState as t, FieldStateMap as u, FieldStateMapEntry as v, FlatPath as w, FormErrorRecord as x, FormErrorsSurface as y, FormMeta as z };