attaform 0.27.6 → 0.29.0

package/dist/shared/{attaform.CHlJLAiv.d.mts → attaform.DDtqHYv1.d.mts}

@@ -1,5 +1,5 @@
-import { G as GenericForm, F as FormKey, a as UseFormReturnType, a4 as RegisterValue, T as PathKey, k as DisplayCtx, w as GetDisplayState, l as DisplayMachine, S as Path, a9 as SlimPrimitiveKind, C as CoercionEntry, e as CoercionRegistry, af as ValidationError, A as AbstractSchema, aj as WriteMeta, h as DeepPartial, ak as WriteShape, as as TransformAbortHolder, ad as ValidateOn, d as AttaformDefaults, at as RegisterModelDynamicCustomDirective } from './attaform.DniawQLP.mjs';
-import { Ref, ComputedRef, App, InjectionKey, Plugin } from 'vue';
+import { G as GenericForm, F as FormKey, a as UseFormReturnType, a7 as RegisterValue, V as PathKey, k as DisplayCtx, w as GetDisplayState, l as DisplayMachine, ac as SlimPrimitiveKind, C as CoercionEntry, e as CoercionRegistry, aw as FieldRecord, ax as ErrorCell, ai as ValidationError, ay as OriginalsRecord, A as AbstractSchema, T as Path, am as WriteMeta, h as DeepPartial, an as WriteShape, az as AttaformDomBinding, aA as TransformAbortHolder, ag as ValidateOn, d as AttaformDefaults } from './attaform.CsoeRi3P.mjs';
+import { Ref, ComputedRef, ShallowRef, App, InjectionKey, Plugin } from 'vue';
 
 /**
  * Options accepted by `injectForm` when passing an object instead of
@@ -121,6 +121,22 @@ declare function injectForm<Form extends GenericForm, GetValueFormType extends G
  * composable's `onMounted` warn fires once per instance to surface
  * the misuse case at runtime.
  *
+ * A wrapper meant to work both ways says so with
+ * `useRegister({ optional: true })`, which silences the unbound
+ * diagnostic and changes nothing else. Without it the diagnostic still
+ * earns its keep: a single-mode wrapper whose parent forgot
+ * `v-register` renders a field that looks fine and stores nothing.
+ *
+ * `rv?.isBound` is the test for "did a parent bind me", and it is the
+ * one to reach for: script-setup code holds the Proxy, which is an
+ * object and so always truthy, while a template holds the unwrapped
+ * ref, which is `undefined` when unbound. Those two disagree, and
+ * `isBound` reads the same on both. A dual-mode wrapper (one used
+ * both `v-register`-bound and plain `v-model`-bound) branches on it,
+ * and does not need to duplicate its element to do so: the
+ * compile-time value injection keeps an author-written `:value` /
+ * `:checked` as its unbound leg, so one element serves both (#620).
+ *
  * Diagnostic: in dev mode, a single `console.warn` fires per instance
  * at `onMounted` if the captured value is still `undefined` — by then
  * the parent has had its full mount lifecycle to bind, so a missing
@@ -149,8 +165,48 @@ declare function injectForm<Form extends GenericForm, GetValueFormType extends G
  * the hybrid's only `.value`. Older code that read `rv.value?.path`
  * keeps working; new code can write `rv.path` directly.
  */
-type UseRegisterReturn<V = unknown> = RegisterValue<V> & Ref<RegisterValue<V> | undefined>;
-declare function useRegister<V = unknown>(): UseRegisterReturn<V> | undefined;
+type UseRegisterReturn<V = unknown> = RegisterValue<V> & Ref<RegisterValue<V> | undefined> & {
+    /**
+     * Whether a parent has actually bound this wrapper. `false` until a
+     * `RegisterValue` lands, `true` once one has, and reactive in both
+     * directions: a parent that binds on a later render flips it, and
+     * so does one that stops binding.
+     *
+     * This is the test a dual-mode wrapper reaches for, and the reason
+     * it exists as a field rather than a truthiness check on the
+     * return: the composable cannot answer "is this bound" at setup
+     * time. A parent is free to bind on a later render
+     * (`v-register="ready ? form.register('x') : undefined"`), and
+     * `useRegister` has to keep serving that, so it can never return a
+     * plain `undefined` for "unbound right now". Script-setup code
+     * reading `rv` directly sees the hybrid Proxy, which is an object
+     * and therefore always truthy; a template sees the unwrapped ref,
+     * which IS `undefined` when unbound. `rv?.isBound` reads the same
+     * on both sides (#620).
+     */
+    readonly isBound: boolean;
+};
+/**
+ * Options for `useRegister`.
+ */
+type UseRegisterOptions = {
+    /**
+     * Declares that this wrapper is used both with and without a form, so
+     * a render with no parent binding is intended rather than a mistake.
+     * Silences the unbound diagnostic; nothing else changes.
+     *
+     * The diagnostic exists because a single-mode wrapper whose parent
+     * forgot `v-register` renders a field that looks fine and stores
+     * nothing, which is an expensive afternoon. Once a wrapper is
+     * deliberately dual-mode, the same signal fires on correct code and
+     * tells the author to do something wrong, so this is the one fact
+     * that separates the two cases and only the author has it (#620).
+     *
+     * Pair it with `rv?.isBound` to branch on what actually happened.
+     */
+    readonly optional?: boolean;
+};
+declare function useRegister<V = unknown>(options?: UseRegisterOptions): UseRegisterReturn<V> | undefined;
 
 /**
  * Per-form display engine: owns the clock and the timers that the pure
@@ -206,71 +262,12 @@ type DisplayEngine = {
     clear(): void;
     /** Tear down for good: `clear()` plus detaching the visibility listener. */
     dispose(): void;
-    /** Introspection for tests: count of retained machines. */
-    size(): number;
-    /** Introspection for tests: whether a path currently has a retained machine. */
-    has(key: PathKey): boolean;
-    /** Introspection for tests: whether a deadline timer is currently armed. */
-    hasTimer(): 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;
+    /** Introspection for tests: count of retained machines. Dev builds only. */
+    size?(): number;
+    /** Introspection for tests: whether a path has a retained machine. Dev builds only. */
+    has?(key: PathKey): boolean;
+    /** Introspection for tests: whether a deadline timer is armed. Dev builds only. */
+    hasTimer?(): boolean;
 };
 
 /**
@@ -327,20 +324,21 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     readonly formKey: FormKey;
     readonly form: Ref<F>;
     readonly fields: Map<PathKey, FieldRecord>;
-    readonly elements: Map<PathKey, ElementRecord>;
     /**
-     * Schema-driven errors. Written ONLY by the schema validation pipeline:
-     * `scheduleFieldValidation`, `handleSubmit`, the construction-time seed,
-     * history restore, and hydration. Cleared by `reset` / `resetField` and by
-     * a successful submit. `setErrors` / `clearErrors` do NOT touch this Map.
-     */
-    readonly schemaErrors: Map<PathKey, ValidationError[]>;
-    /**
-     * User-injected errors. Written ONLY by the `setErrors` / `clearErrors`
-     * API surface (and history / hydration replay). Survives schema revalidation and
+     * The tagged error store: one cell per error-bearing path, each cell
+     * segregating its two sources. The `schema` side is written ONLY by
+     * the validation pipeline (`scheduleFieldValidation`, `handleSubmit`,
+     * the construction-time seed, history restore, hydration) and cleared
+     * by `reset` / `resetField` and a successful submit; the `user` side
+     * is written ONLY by the `setErrors` / `clearErrors` API surface (and
+     * history / hydration replay) and survives schema revalidation and
      * successful submits — the consumer owns its lifetime explicitly.
+     * A key exists iff a side is non-empty; cells are replaced, never
+     * mutated, so Vue's per-key Map tracking fires for either side's
+     * change. Derived blank entries are NOT stored here — they synthesize
+     * at read (`derivedBlankErrors`).
      */
-    readonly userErrors: Map<PathKey, ValidationError[]>;
+    readonly errorCells: Map<PathKey, ErrorCell>;
     /**
      * Reactively-derived "No value supplied" errors. Pure function of
      * `(blankPaths, schema.isRequiredAtPath)` — no writers, no clears.
@@ -524,10 +522,22 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * Resolves after `hydrating` flips back to `false`; consumers can
      * `await form.rehydrate()` to gate UI on the fresh load.
      *
-     * Does NOT touch dirty / touched / submit state — chain
-     * `form.reset()` if you want a clean baseline.
+     * Does NOT touch touched / submit state; chain `form.reset()` if you
+     * want a clean surface. It DOES re-seat the defaults (see
+     * `adoptResolvedDefaults`), so dirty afterwards means "differs from
+     * what the factory just returned", and `form.reset()` lands on the
+     * fresh values rather than throwing them away.
      */
     rehydrate(): Promise<void>;
+    /**
+     * Adopt a resolved async-defaults value as the form's durable
+     * defaults and re-seed the dirty baseline from it. Called by the
+     * activate / rehydrate orchestrator once its factory settles.
+     * Exposed on the store (rather than imported) because
+     * `form-activation` is imported BY this module; a value import back
+     * the other way would close a cycle.
+     */
+    adoptResolvedDefaults(value: unknown): void;
     /**
      * Incremented by every `reset()` call. The submit wrapper captures
      * this at entry and skips writing `submitError` from a catch that
@@ -538,7 +548,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     readonly submissionGeneration: Ref<number>;
     /**
      * Counts in-flight validation calls across every `validate()` ref and
-     * every `validateAsync(...)` / `handleSubmit` pre-check. `validating`
+     * every committing `parse(...)` / `handleSubmit` pre-check. `validating`
      * on the public API mirrors `activeValidations.value > 0`. Tracked
      * separately from submissions because a validate-while-submitting
      * (e.g. a debounced field check overlapping a submit) needs to show
@@ -598,7 +608,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * call) and decremented in the matching `.finally` — so the per-path
      * bookkeeping is exactly co-extensive with the form-wide counter for
      * the field-scheduled branch. Whole-form `validate()` /
-     * `validateAsync()` runs touch `activeValidations` only; they don't
+     * `parse()` runs touch `activeValidations` only; they don't
      * have a single field path and so don't contribute here.
      *
      * Counter (not Set) because two runs for the same path can briefly
@@ -687,7 +697,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     /**
      * Stable identity for the array element at `path`. An array element
      * (numeric last segment) carries its allocated identity token,
-     * maintained by `array-identity.ts` across structural mutations.
+     * maintained by the arrays engine across structural mutations.
      * Empty for any non-array-element path: a record entry, a
      * fixed-object field, a container, or the root. Backs `FieldState.key`.
      */
@@ -700,7 +710,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     /**
      * Replace `schemaErrors` under `path` with `errors`, keying each
      * error by its OWN absolute path. Used by validation pipelines
-     * (scheduleFieldValidation, validateAsync, handleSubmit, reset)
+     * (scheduleFieldValidation, the committing parse, handleSubmit, reset)
      * to commit a parse result wholesale — entries not in the new
      * pass get dropped from the subtree, surviving keys update in
      * place to preserve insertion order. Pass `path === []` for the
@@ -711,10 +721,18 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     setUserErrorsForPath(path: Path, errors: readonly ValidationError[]): void;
     clearUserErrors(path?: Path): void;
     /**
-     * Merged read — returns `[...schemaErrors[path], ...userErrors[path]]`.
-     * Schema errors come first (structural validation before business logic),
-     * matching the iteration order for `getFirstErrorElement` and the
-     * top-level `errors` drillable Proxy.
+     * Rebuild the whole tagged store from a snapshot's `[key, cell]`
+     * entries — the history ring buffer's restore road. Entry arrays are
+     * cloned in, so the snapshot stays detached from the live store;
+     * cells with both sides empty are skipped.
+     */
+    restoreErrorCells(entries: ReadonlyArray<readonly [PathKey, ErrorCell]>): void;
+    /**
+     * Merged read — the cell at `path` in schema -> blank -> user order.
+     * Schema errors come first (structural validation before business
+     * logic), the derived blank entry synthesizes between, and user
+     * entries close, matching the iteration order for
+     * `getFirstErrorElement` and the top-level `errors` drillable Proxy.
      */
     getErrorsForPath(path: Path): ValidationError[];
     /**
@@ -729,15 +747,29 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     ensurePathOrdinal(key: PathKey): number;
     /**
-     * Register `element` as a binding for `path`, tagged with the calling
-     * `useForm()` instance's `formInstanceId`. The ID is the disambiguator
-     * used by `getFirstErrorElement` to scope focus / scroll to elements
-     * THIS form instance owns — important when two `useForm()` calls share
-     * a `key` (e.g. sidebar + main rendering the same form), since both
-     * write into one shared element store.
+     * The store's DOM slice, `null` until the directive cluster or
+     * `useRegister` arms it via `RegisterValue.ensureDomBinding`. Element
+     * registration, host anchors, and first-error focus resolution all
+     * live behind it; eager readers treat `null` as an empty registry.
      */
-    registerElement(path: Path, element: HTMLElement, formInstanceId: string): boolean;
-    deregisterElement(path: Path, element: HTMLElement): number;
+    readonly domBinding: ShallowRef<AttaformDomBinding | null>;
+    /**
+     * Field-record connect transition, driven by the DOM binding on
+     * element attach / host connect (and by the SSR-only
+     * `markConnectedOptimistically`): `connected: true`, with
+     * `focused` / `blurred` lifted from `null` to optimistic booleans
+     * only when currently null — an existing boolean from an early focus
+     * event is never clobbered.
+     */
+    noteDomConnected(path: Path): void;
+    /**
+     * Field-record disconnect transition, driven by the DOM binding when
+     * a path's last element detaches or its host disconnects:
+     * `connected: false`, `focused` / `blurred` back to `null` (DOM-state
+     * properties are meaningless with nothing attached; interaction
+     * history stays).
+     */
+    noteDomDisconnected(path: Path): void;
     /**
      * Optional `meta.instance` carries per-`useForm()`-instance overrides
      * for `validateOn` / `debounceMs` so the blur-trigger respects the
@@ -777,20 +809,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * source there).
      */
     markConnectedOptimistically(path: Path): void;
-    /**
-     * Client-side connected mark for a `v-register` component host that binds
-     * value via the v-model channel but has no single inner control to latch
-     * (a composite widget, or none found). The directive calls it on mount
-     * (`true`) and unmount (`false`). Distinct from the SSR-only
-     * `markConnectedOptimistically`; idempotent on the leading edge.
-     *
-     * `hostEl` (the host root) is recorded on connect as this path's
-     * focus-first-error anchor, scoped to `formInstanceId` the same way a
-     * registered control is. A no-latch host enters no `elements` record, so
-     * without this it is absent from `getFirstErrorElement`'s walk; the anchor
-     * lets that walk resolve a focus target from the host subtree.
-     */
-    markHostConnected(path: Path, connected: boolean, hostEl: HTMLElement, formInstanceId: string): void;
     /**
      * Leaf-only pristine check. `originals` is populated via
      * `diffAndApply`'s `added` patches, which fire only on primitive
@@ -829,33 +847,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     hasRemovedSubtreeUnder(path: Path): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
     getOriginalAtPath(path: Path): unknown;
-    /**
-     * Returns the first errored field's first connected, visible DOM
-     * element scoped to `formInstanceId` — the target that
-     * `focusFirstError` / `scrollToFirstError` act on. "First" is
-     * VISUAL-first (DOM-tree order via `compareDocumentPosition`), not
-     * schema-declaration order, so a field rendered above another in the
-     * template focuses first regardless of which one the schema declared
-     * earlier. CSS `order:` flexbox/grid reordering is NOT respected
-     * (DOM-tree order wins) — documented as a tradeoff against forcing
-     * sync layout on every comparison.
-     *
-     * The `formInstanceId` filter scopes focus to elements registered
-     * through THIS form instance. When two `useForm({ key })` calls share
-     * a key, both register into the same element store; without the
-     * filter, the sidebar form's submit could focus the main form's
-     * input. With it, each `useForm()` callsite focuses only its own
-     * elements.
-     *
-     * Returns `null` when every errored path has no currently-attached
-     * element registered to this instance (fields behind `v-if="false"`,
-     * unmounted components, or a hidden `display:none` parent). Callers
-     * get the choice of no-op or a dev-only warning.
-     */
-    getFirstErrorElement(formInstanceId: string): {
-        path: Path;
-        element: HTMLElement;
-    } | null;
     /**
      * Cancel every in-flight field-level validation run — clears timers
      * for debounced 'change' runs that haven't fired, latches `aborted`
@@ -958,21 +949,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     registerCleanup(fn: () => void): void;
     /**
-     * Register an async drain function. Called by the registry before
-     * `dispose()` so async background work — chiefly the persistence
-     * layer's debounced storage writes — has a chance to settle without
-     * losing the last keystroke. Each registered function is awaited in
-     * parallel; failures are swallowed to keep eviction reliable.
-     */
-    registerDrain(fn: () => Promise<void>): void;
-    /**
-     * Drain async work registered via `registerDrain`. Resolves once
-     * every registered drain has settled (in parallel). Safe to call
-     * repeatedly — registered drains decide their own idempotency.
-     */
-    awaitPendingWrites(): Promise<void>;
-    /**
-     * Cache for per-state modules (history, persistence) that must
+     * Cache for per-state modules (chiefly history) that must
      * outlive any single consumer. Subsequent `useForm` / `injectForm`
      * calls for the same key read from this map so the public API shape
      * is identical regardless of mount order. Keyed by a string identifier
@@ -1577,6 +1554,12 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    `back()` does not pop; the trail is the audit
  *                    log, not the back-stack.
  *  - `next/back/goTo` — pure navigation. Refuses while `submitting`.
+ *                    The one exception is `next()` on an UNCLEARED
+ *                    `gate()` step, which behaves as `tryNext()` so
+ *                    wiring Next straight to it can never skip the
+ *                    gate's confirmation. Once that gate clears, `next()`
+ *                    is plain navigation again and does not re-submit to
+ *                    re-confirm.
  *  - `tryNext()`   — submit the active step, and once that submit
  *                    resolves clean, advance; invalid input keeps the pin
  *                    put under the form's standard error reveal (first
@@ -1586,6 +1569,13 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    (`@click="wizard.tryNext()"`); resolves to whether
  *                    the pin moved. No-ops to `false` on a degenerate or
  *                    final-step wizard (finish via `handleSubmit`).
+ *                    Called while the active step's form already has a
+ *                    submit in flight (the usual case being from inside
+ *                    that form's own callback), it rides that submit
+ *                    rather than starting a second one, so one action
+ *                    costs one submission. The pin has not moved by the
+ *                    time it resolves, so the answer is `false`; the
+ *                    advance lands with the in-flight submit.
  *  - `handleSubmit(onSubmit, onError?)` — always validates the entire
  *                    step list, from any step, and never advances the
  *                    pin: on success it latches `done`; on any error it
@@ -1783,13 +1773,6 @@ type AttaformRegistry = {
      * @internal
      */
     readonly shouldPrefetch: (key: FormKey) => boolean;
-    /**
-     * Wait for all pending persistence writes across every live form
-     * to settle. Useful for SSR shutdown and integration tests that
-     * need a deterministic teardown.
-     * @internal
-     */
-    readonly shutdown: () => Promise<void>;
 };
 /**
  * The Vue `InjectionKey` under which the registry is provided on the
@@ -2167,6 +2150,8 @@ declare function createAttaform(options?: AttaformPluginOptions): Plugin;
  * serialiser before embedding in your SSR payload.
  */
 type SerializedAttaformState = {
+    /** Envelope version — see {@link ATTAFORM_STATE_VERSION}. */
+    readonly v: number;
     /** Tuples of `[formKey, snapshot]` for every form in the app. */
     readonly forms: ReadonlyArray<readonly [FormKey, SerializedFormData]>;
 };
@@ -2206,10 +2191,16 @@ declare function renderAttaformState(app: App): SerializedAttaformState;
  * app.mount('#app')
  * ```
  *
+ * Accepts `unknown` because the payload crosses the wire untyped
+ * (an inline `<script>` tag, `JSON.parse`): the envelope is
+ * validated at runtime, and anything that isn't a version-matched
+ * `renderAttaformState` snapshot is skipped wholesale, so forms
+ * construct fresh from their schemas instead.
+ *
  * The next `useForm({ key })` call for each serialised form picks up
  * the snapshot transparently — no further action is required.
  */
-declare function hydrateAttaformState(app: App, payload: SerializedAttaformState): void;
+declare function hydrateAttaformState(app: App, payload: unknown): void;
 
 /**
  * Escape a JSON string so it's safe to embed inside an inline
@@ -2242,26 +2233,6 @@ declare function escapeForInlineScript(json: string): string;
  */
 declare const assignKey: unique symbol;
 
-/**
- * The `v-register` directive. Bind a form field to a native input,
- * select, textarea, checkbox, or radio:
- *
- * ```vue
- * <input v-register="form.register('email')" />
- * <select v-register="form.register('country')">
- *   <option value="us">US</option>
- *   <option value="uk">UK</option>
- * </select>
- * ```
- *
- * The directive picks the right binding strategy automatically based
- * on the element's `tagName` and `type`. Registered globally by
- * `createAttaform()`. Most consumers never import it directly, but
- * it's exposed for advanced integrations that wire directives
- * manually.
- */
-declare const vRegister: RegisterModelDynamicCustomDirective;
-
 /**
  * Type guard for a `RegisterValue`. Returns `true` when `val` looks
  * like the object returned from `form.register(path)`.
@@ -2490,5 +2461,5 @@ declare function makeDefaultDisplayState({ showDelay, minVisible, }: DisplayTimi
  */
 declare const defaultDisplayState: GetDisplayState;
 
-export { renderAttaformState as $, createAttaform as B, DEFAULT_TIMINGS as D, createRegistry as E, defaultCoercionRules as H, defaultDisplayState as J, defineCoercion as K, escapeForInlineScript as M, gate as N, OutsideSetupError as O, getRegistryFromApp as P, hydrateAttaformState as Q, RegistryNotInstalledError as R, injectForm as T, injectWizard as V, isRegisterValue as X, kAttaformRegistry as Y, lazy as Z, makeDefaultDisplayState as _, useRegister as a0, useRegistry as a1, useWizard as a2, vRegister as a3, AttaformError as c, AttaformErrorCode as d, DEVTOOLS_WINDOW_KEY as f, InvalidPathError as i, InvalidUseFormConfigError as j, ReservedFormKeyError as k, SubmitErrorHandlerError as n, assignKey as z };
-export type { AttaformRegistry as A, CompiledStep as C, FormStatus as F, GateMarker as G, InjectWizardInput as I, LazyMarker as L, SerializedAttaformState as S, UseRegisterReturn as U, WizardAggregateError as W, AnyForm as a, AttaformDevtoolsBridge as b, AttaformPluginOptions as e, DisplayTimings as g, FormStatusSeed as h, SerializedFormData as l, StepSlot as m, UseWizardReturnType as o, WizardCtx as p, WizardCtxForm as q, WizardOnError as r, WizardOnSubmit as s, WizardOptions as t, WizardPersistFn as u, WizardRestoreFn as v, WizardRestoreState as w, WizardStatusesProxy as x, WizardSubmitContext as y };
+export { makeDefaultDisplayState as $, assignKey as B, DEFAULT_TIMINGS as D, createAttaform as E, createRegistry as H, defaultCoercionRules as J, defaultDisplayState as K, defineCoercion as M, escapeForInlineScript as N, OutsideSetupError as O, gate as P, getRegistryFromApp as Q, RegistryNotInstalledError as R, hydrateAttaformState as T, injectForm as V, injectWizard as X, isRegisterValue as Y, kAttaformRegistry as Z, lazy as _, renderAttaformState as a0, useRegister as a1, useRegistry as a2, useWizard as a3, AttaformError as c, AttaformErrorCode as d, DEVTOOLS_WINDOW_KEY as f, InvalidPathError as i, InvalidUseFormConfigError as j, ReservedFormKeyError as k, SubmitErrorHandlerError as n };
+export type { AttaformRegistry as A, CompiledStep as C, FormStatus as F, GateMarker as G, InjectWizardInput as I, LazyMarker as L, SerializedAttaformState as S, UseRegisterOptions as U, WizardAggregateError as W, AnyForm as a, AttaformDevtoolsBridge as b, AttaformPluginOptions as e, DisplayTimings as g, FormStatusSeed as h, SerializedFormData as l, StepSlot as m, UseRegisterReturn as o, UseWizardReturnType as p, WizardCtx as q, WizardCtxForm as r, WizardOnError as s, WizardOnSubmit as t, WizardOptions as u, WizardPersistFn as v, WizardRestoreFn as w, WizardRestoreState as x, WizardStatusesProxy as y, WizardSubmitContext as z };