attaform 0.28.0 → 0.30.0

package/dist/shared/{attaform.B4VkS43-.d.mts → attaform.Rc9u4Vfw.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, B as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, as as AcceptableDefaults, af as ValidateOnConfig, a as UseFormReturnType } from './attaform.Cgu-hdSb.mjs';
+import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType } from './attaform.bKLzMU0o.mjs';
 
 /**
  * The Zod v4 schema roots `useForm` accepts. A fixed-shape

package/dist/shared/{attaform.D5V4tZWq.d.mts → attaform.UGyOK83T.d.mts}

@@ -1,4 +1,4 @@
-import { G as GenericForm, F as FormKey, a as UseFormReturnType, a5 as RegisterValue, V as PathKey, k as DisplayCtx, w as GetDisplayState, l as DisplayMachine, aa as SlimPrimitiveKind, C as CoercionEntry, e as CoercionRegistry, au as FieldRecord, av as ErrorCell, ag as ValidationError, aw as OriginalsRecord, A as AbstractSchema, T as Path, ak as WriteMeta, h as DeepPartial, al as WriteShape, ax as AttaformDomBinding, ay as TransformAbortHolder, ae as ValidateOn, d as AttaformDefaults } from './attaform.Cgu-hdSb.mjs';
+import { G as GenericForm, F as FormKey, a as UseFormReturnType, _ as RegisterValue, v as Path, w as PathKey, ar as DisplayCtx, as as GetDisplayState, at as DisplayMachine, au as FieldRecord, av as ErrorCell, ad as ValidationError, aw as OriginalsRecord, A as AbstractSchema, ah as WriteMeta, d as DeepPartial, ai as WriteShape, ax as AttaformDomBinding, ay as TransformAbortHolder } from './attaform.bKLzMU0o.mjs';
 import { Ref, ComputedRef, ShallowRef, App, InjectionKey, Plugin } from 'vue';
 
 /**
@@ -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,12 +165,69 @@ 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;
+
+type DynamicPathSweep = {
+    /**
+     * Note that a cache has just stored an entry for `segments` under
+     * `key`. Paths a schema shape bounds are ignored, so only the
+     * candidates the sweep could ever drop are walked.
+     */
+    readonly track: (segments: Path, key: PathKey) => void;
+    /**
+     * Register a cache's own eviction. It receives the canonical
+     * `PathKey` of a path the form no longer has, and deletes whatever it
+     * files under that path. A cache keying by more than the path (a
+     * shape sigil, say) deletes every variant; a key it never held is a
+     * no-op.
+     */
+    readonly onEvict: (evict: (key: PathKey) => void) => void;
+};
 
 /**
- * Per-form display engine: owns the clock and the timers that the pure
- * `getDisplayState` reducer policy needs, so the reducer itself stays a
+ * Per-form display engine: owns the clock and the timers the display
+ * reducer's timing policy needs, so the reducer itself stays a
  * deterministic `(prev, ctx) => next` function.
  *
  * It keeps a `Map` of the machines that are still *active* (a spinner is
@@ -173,15 +246,15 @@ declare function useRegister<V = unknown>(): UseRegisterReturn<V> | undefined;
  * retained set is bounded by the rendered non-idle fields; none of them
  * arm a timer, so retention costs memory, never CPU.
  *
- * Untrusted reducer: `getDisplayState` is consumer-overridable, so the
- * engine treats the returned `reviewAt` as untrusted. A non-finite deadline
- * (NaN / ±Infinity from a custom predicate's bad arithmetic) is ignored
- * rather than handed to `setTimeout`, where it coerces to 0 and spins; an
- * over-large finite deadline is clamped below the 32-bit `setTimeout`
- * overflow; and the timer refuses to re-arm for the exact deadline it just
- * fired, so a predicate re-emitting a fixed or past `reviewAt` can't drive an
- * infinite fire loop. None of these arise from the library default, which
- * always advances its deadline or drops it.
+ * `setTimeout` invariants on the returned `reviewAt`, enforced here rather
+ * than trusted from the reducer. A non-finite deadline is ignored rather
+ * than handed to `setTimeout`, where it coerces to 0 and spins; an over-large
+ * finite deadline is clamped below the 32-bit `setTimeout` overflow; and the
+ * timer refuses to re-arm for a deadline it just fired that has also already
+ * passed. The last of those is not belt-and-braces: the library reducer's own
+ * min-visible hold re-emits ONE fixed instant for the length of the window,
+ * which is exactly the shape that stranded a field on `'pending'` forever (see
+ * `rearm`).
  *
  * Background tabs: `setTimeout` is throttled to >= 1s while a tab is hidden,
  * so a min-visible hold can overshoot. A `visibilitychange` listener bumps
@@ -215,56 +288,64 @@ type DisplayEngine = {
 };
 
 /**
- * Schema-driven coercion of user-typed DOM values at the v-register
- * directive layer. When the slim schema declares a numeric or
- * boolean type at a path, the directive coerces incoming string
- * values (`'25'` → `25`, `'true'` → `true`) before the slim-primitive
- * gate sees the write — making the schema authoritative for storage
- * shape and freeing consumers from sprinkling `.number` modifiers
- * across templates.
- *
- * Coercion is consumer-extensible: a `CoercionRegistry` is just an
- * `Array<CoercionEntry>` keyed at config time by `(input, output)`
- * `SlimPrimitiveKind` literals. The library ships
- * `defaultCoercionRules` (string→number, string→boolean) and
- * `defineCoercion` for type-narrowed authoring; consumers spread the
- * defaults to extend or supply their own array to replace.
- *
- * Coercion applies ONLY to user-typed DOM values flowing through
- * the directive's assigner. Programmatic writes (`form.setValue`,
- * `setValueWithInternalPath`) bypass coercion — they're authoritative
- * writes whose strict typing is on the caller. This mirrors the
- * `transforms` pipeline's user-input-only contract.
+ * The error stores, indexed by path prefix.
+ *
+ * `aggregateErrorsAt(state, prefix)` answers "every active error at or
+ * under this path", and it used to answer it by walking every entry in
+ * all three error stores, resolving each key back to segments and
+ * testing the prefix. That is fine for one call. A table asks for one
+ * per row: `form.list('rows')` on 400 rows with 800 errors did 320,000
+ * of those tests, and a keystroke in any single row re-did all of them,
+ * costing a quarter of a second per character typed.
+ *
+ * The cost is structural, not incidental: the work is O(rows x errors)
+ * where the answer is O(errors). So the keys are collected ONCE per
+ * change to the stores, resolved to segments once, and sorted, and a
+ * query binary-searches its own window instead of scanning.
+ *
+ * ## Why a sorted key array is the right index
+ *
+ * A `PathKey` is `JSON.stringify(segments)`, so a path's descendants
+ * all begin with the parent's key minus its closing bracket, plus a
+ * comma: every key under `["rows",0]` begins `["rows",0,`. Call that
+ * the marker. Two facts make a sorted array enough:
+ *
+ *  - every descendant key is >= the marker, since it begins with it;
+ *  - every descendant key is <= the parent's own key, since the two
+ *    agree up to the last character, where `,` (0x2C) sorts before
+ *    `]` (0x5D).
+ *
+ * So `[marker, parentKey]` is a contiguous window containing every
+ * descendant and the parent itself. It is a SUPERSET, not an exact
+ * answer, and the caller still applies `isPathPrefix` to what comes
+ * back: the window narrows the scan, it does not decide membership.
+ * That split is deliberate. Membership stays where it already was, so
+ * the encoding argument above cannot quietly become the definition of
+ * a prefix.
+ *
+ * The root prefix has no marker (`[]` minus its bracket plus a comma is
+ * `[,`, which nothing begins with), and the root matches everything
+ * anyway, so it is answered by handing back the whole index.
  */
 
-/**
- * Type-narrowing helper for authoring entries. At runtime it's
- * identity; at compile time it preserves the `input` / `output`
- * literal types so `transform`'s parameter is narrowed to the
- * runtime type instead of widening to `SlimRuntimeOf<SlimPrimitiveKind>`.
- *
- * Without this helper, authoring `{ input: 'string', output:
- * 'number', transform: (s) => ... }` against the broader
- * `CoercionEntry` widens `s` to `string | number | boolean | ...`,
- * forcing a cast in every transform body. `defineCoercion` is the
- * opaque-free idiom.
- */
-declare function defineCoercion<I extends SlimPrimitiveKind, O extends SlimPrimitiveKind>(entry: CoercionEntry<I, O>): CoercionEntry<I, O>;
-/**
- * Internal index built from a `CoercionRegistry` at config-resolve
- * time. Keyed by `${input}->${output}` for O(1) per-keystroke
- * dispatch. The authoring shape (array, ergonomic, type-narrowing-
- * friendly) and the dispatch shape (Map, fast) decouple cleanly.
- */
-type CoercionIndex = ReadonlyMap<`${SlimPrimitiveKind}->${SlimPrimitiveKind}`, CoercionEntry>;
-/**
- * The library's built-in registry. Two cells: string→number and
- * string→boolean. Re-exported so consumers can spread it when
- * supplying a custom registry that extends defaults.
- */
-declare const defaultCoercionRules: CoercionRegistry;
+/** One indexed path: its key, and the segments that key decodes to. */
+type ErrorPathEntry = {
+    readonly key: PathKey;
+    readonly segments: Path;
+};
 
 type FormStore<F extends GenericForm, G extends GenericForm = F> = {
+    /**
+     * The form's single liveness sweep over every per-path cache. Owned by
+     * the store rather than by `buildFormApi` because the store's own
+     * per-path maps (`fields`, `originals`, `authoredPaths`,
+     * `fieldValidationState`) are the largest thing it evicts, and they
+     * exist whether or not a form API was ever built around them. Read
+     * surfaces register their own evictions into it, so one subscription
+     * and one liveness walk serve all of them. See
+     * `dynamic-path-sweep.ts`.
+     */
+    readonly pathSweep: DynamicPathSweep;
     readonly formKey: FormKey;
     readonly form: Ref<F>;
     readonly fields: Map<PathKey, FieldRecord>;
@@ -303,6 +384,22 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * sentinel — see `docs/validation/blank.md`.
      */
     readonly derivedBlankErrors: ComputedRef<ReadonlyMap<PathKey, ValidationError[]>>;
+    /**
+     * Every path carrying an error at or under `prefix`, sorted by key.
+     * `aggregateErrorsAt` takes its candidates from here instead of
+     * re-scanning all three error stores per call, which is what turns a
+     * table of N rows from O(N x errors) back into O(errors). See
+     * `error-path-index.ts`.
+     *
+     * Reading this rather than the form-global index is also what keeps
+     * containers isolated from each other. The index is one value for the
+     * whole form, so any path gaining or losing an error gives it a new
+     * identity; a container reading it directly woke on every other
+     * container's errors. Each prefix gets its own memoised `computed`
+     * that holds its previous array when its own window is unchanged, so
+     * the global change stops there. See `errorWindowAt` in the store.
+     */
+    readonly errorWindowAt: (prefix: Path, prefixKey: PathKey) => readonly ErrorPathEntry[];
     readonly originals: Map<PathKey, OriginalsRecord>;
     /**
      * Reactive set of paths whose displayed state should be EMPTY even
@@ -352,18 +449,9 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * the eventual directive lifecycle remains the source of truth.
      */
     readonly ssr: boolean;
-    /**
-     * Resolved `getDisplayState` predicate driving `field.displayState`,
-     * the `show*` booleans, and their `form.meta` rollups. Resolved once
-     * at construction via `resolveGetDisplayState(options.getDisplayState)`;
-     * `undefined` config falls through to `defaultDisplayState`. The
-     * field-state computeds read the resolved function directly on every
-     * read.
-     */
-    readonly getDisplayState: GetDisplayState;
     /**
      * Per-form display engine: owns the clock and the single timer the timed
-     * `getDisplayState` reducer policy needs, keeping the reducer itself a
+     * display-reducer policy needs, keeping the reducer itself a
      * pure `(prev, ctx) => next` function. The field-state computeds route
      * every `displayState` read through `displayEngine.resolve(...)`, which
      * threads the path's previous machine, persists or evicts the result, and
@@ -466,10 +554,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
@@ -502,26 +602,10 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * run yet — so without the gate, frame 1 paints the form as
      * "valid" before the real verdict arrives a tick later.
      *
-     * Initialized to `!strict`: non-strict consumers opt out of the
-     * validation pipeline by design, so locking them on
-     * `firstValidationDone === false` would defeat the opt-out.
      * Reset is left untouched — the post-reset validation flips it
      * back true on completion, same as the construction-time path.
      */
     readonly firstValidationDone: Ref<boolean>;
-    /**
-     * `true` when the sub-schema rooted at `path` (or any of its
-     * descendants) declares async work — composes
-     * `schema.getSchemasAtPath(path)` with each candidate's
-     * `needsAsyncValidation()`, memoised per canonical path key for
-     * the lifetime of the FormStore. Used by `meta.valid` /
-     * `field.valid` to skip the `firstValidationDone` gate on subtrees
-     * that are fully synchronous: their verdict resolves at construction
-     * (or on the next per-field run) without waiting on a microtask, so
-     * honouring the form-wide gate would just play dumb about a known
-     * answer.
-     */
-    pathHasAsyncValidation(path: Path): boolean;
     /**
      * Precomputed-key shortcut for `pathHasAsyncValidation`. The
      * canonical key is required and must correspond to `segments`; the
@@ -741,17 +825,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * source there).
      */
     markConnectedOptimistically(path: Path): void;
-    /**
-     * Leaf-only pristine check. `originals` is populated via
-     * `diffAndApply`'s `added` patches, which fire only on primitive
-     * leaves — a container path (e.g. `['profile']`) that isn't in
-     * `originals` returns `true` here even when a descendant is dirty.
-     * Callers that need container semantics should either loop over
-     * leaves or walk `originals` manually. The public `getFieldState`
-     * surface is typed to accept leaf paths only, so in practice this
-     * isn't exposed to consumers.
-     */
-    isPristineAtPath(path: Path): boolean;
     /**
      * Precomputed-key shortcut for `isPristineAtPath`. The canonical
      * key is required and must correspond to `segments`; the helper
@@ -778,7 +851,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     hasRemovedSubtreeUnder(path: Path): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
-    getOriginalAtPath(path: Path): unknown;
     /**
      * Cancel every in-flight field-level validation run — clears timers
      * for debounced 'change' runs that haven't fired, latches `aborted`
@@ -803,12 +875,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     endTransform(key: PathKey, token: number): void;
     /** Record a per-field normalization failure at `key` (`field.transformError`). */
     setTransformError(key: PathKey, err: Error): void;
-    /**
-     * Abort + release every in-flight async-transform run (all paths) and
-     * clear `transformErrors`. Mirrors `cancelFieldValidation`; called by
-     * `reset()` and store teardown.
-     */
-    cancelTransforms(): void;
     /**
      * Path-scoped counterpart to `cancelTransforms`: abort + release only
      * the runs at-or-under `prefix`, clearing their `transformError`.
@@ -839,10 +905,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * store's captured `debounceMs`. Used so sibling instances sharing a
      * FormStore can each validate on their own cadence.
      */
-    scheduleFieldValidation(path: Path, immediate: boolean, override?: {
-        readonly mode?: ValidateOn;
-        readonly debounceMs?: number;
-    }): void;
+    scheduleFieldValidation(path: Path, immediate: boolean, instance?: WriteMeta['instance']): void;
     /**
      * Subscribe to every `applyFormReplacement`. Fires synchronously
      * after `form.value` has been swapped to `next` and all field /
@@ -889,14 +952,12 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     readonly modules: Map<string, unknown>;
     /**
-     * Resolved schema-coercion index — the merged config from
-     * `createAttaform({ defaults: { coerce } })` ∪ `useForm({ coerce })`,
-     * keyed by `${input}->${output}` for O(1) per-keystroke dispatch.
-     * Empty Map when coercion is disabled. Read at `register()` time
-     * by `buildCoerceFn` to bake the per-path coerce closure on
-     * `RegisterValue.coerce`.
+     * Whether schema-driven coercion runs for this form — `false` only
+     * when the consumer passed `useForm({ coerce: false })`. Read at
+     * `register()` time by `buildCoerceFn` to bake the per-path coerce
+     * closure on `RegisterValue.coerce`.
      */
-    readonly coerceIndex: CoercionIndex;
+    readonly coerceEnabled: boolean;
     /**
      * Tear down non-reactive resources owned by this FormStore. Invoked
      * by the registry when the last consumer unmounts. Cancels pending
@@ -1286,8 +1347,8 @@ type WizardOptions = {
     /**
      * When `wizard.handleSubmit` finds errors, automatically focus the
      * first failing form: jump to its step and invoke its
-     * `applyInvalidSubmitPolicy()` (focus / scroll per the form's own
-     * `onInvalidSubmit` configuration). Default `true`; pass `false` to
+     * `applyInvalidSubmitPolicy()` (which honors that form's own
+     * `focusOnInvalidSubmit` choice). Default `true`; pass `false` to
      * keep the active step where the user left it and handle navigation
      * manually in the `onError` callback.
      */
@@ -1486,6 +1547,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
@@ -1495,6 +1562,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
@@ -1649,8 +1723,6 @@ type AttaformRegistry = {
     readonly pendingHydration: PendingHydration;
     /** `true` while running on the server during SSR; `false` on the client. */
     readonly ssr: boolean;
-    /** App-level defaults applied to every `useForm` call. */
-    readonly defaults: AttaformDefaults;
     /**
      * Track a consumer of `key`. Returns a dispose function — call it
      * when the consumer unmounts. The form is evicted automatically
@@ -1706,13 +1778,7 @@ declare module 'vue' {
     }
 }
 /** Options for `createRegistry`. */
-type CreateRegistryOptions = SSRDetectOptions & {
-    /**
-     * App-level defaults applied to every `useForm` call. Per-form
-     * options always win. Omitted is equivalent to `{}`.
-     */
-    defaults?: AttaformDefaults;
-};
+type CreateRegistryOptions = SSRDetectOptions;
 /**
  * Create a fresh `AttaformRegistry`. `createAttaform()` calls
  * this internally — most consumers never need to call it directly.
@@ -2018,34 +2084,20 @@ type AttaformPluginOptions = SSRDetectOptions & {
      * fails silently. Pass `false` to skip the integration even in dev.
      */
     devtools?: boolean;
-    /**
-     * App-level defaults applied to every `useForm` call in this app.
-     * Per-form options always win. See `AttaformDefaults` for
-     * the supported option set and the merge rules.
-     *
-     * ```ts
-     * app.use(
-     *   createAttaform({
-     *     defaults: { debounceMs: 100 },
-     *   })
-     * )
-     * ```
-     */
-    defaults?: AttaformDefaults;
 };
 /**
  * Create the Vue plugin that installs the form library on a Vue
  * application. Required only when you want app-wide options
- * (`defaults`, `devtools: false`, `ssr: true`) — for the default
- * setup, `useForm` / `injectForm` / `useRegister` lazy-install the
- * registry on first use.
+ * (`devtools: false`, `ssr: true`) — for the default setup,
+ * `useForm` / `injectForm` / `useRegister` lazy-install the registry
+ * on first use.
  *
  * ```ts
  * import { createApp } from 'vue'
  * import { createAttaform } from 'attaform'
  *
  * createApp(App)
- *   .use(createAttaform({ defaults: { debounceMs: 100 } }))
+ *   .use(createAttaform({ devtools: false }))
  *   .mount('#app')
  * ```
  *
@@ -2310,75 +2362,5 @@ declare class ReservedFormKeyError extends AttaformError {
     constructor(key: string);
 }
 
-/**
- * Anti-flash timing for the library-default display reducer.
- *
- * - `showDelay` — how long in-flight work (a validation run or an async
- *   register transform) may run before its spinner is allowed to show. Work
- *   that settles inside this window never reveals `'pending'` at all, so a
- *   fast (often synchronous) check does not flash a spinner on every keystroke.
- * - `minVisible` — once shown, the minimum time the spinner stays up. Work
- *   that lands just past `showDelay` is held here so the spinner does not
- *   itself flash on and immediately off.
- *
- * Both are milliseconds.
- */
-type DisplayTimings = {
-    readonly showDelay: number;
-    readonly minVisible: number;
-};
-/**
- * Library-default anti-flash timings. `showDelay: 120` cleanly swallows
- * synchronous, microtask-resolved, and tiny-async work (validation runs and
- * async register transforms alike) so none of them flash a spinner;
- * `minVisible: 120` keeps a shown spinner snappy once one does land.
- * Retune via {@link makeDefaultDisplayState} without touching the engine.
- */
-declare const DEFAULT_TIMINGS: DisplayTimings;
-/**
- * Build a default `getDisplayState` reducer with custom anti-flash timing.
- * Power users who want a tighter or looser spinner than {@link DEFAULT_TIMINGS}
- * pass their own `{ showDelay, minVisible }`:
- *
- * ```ts
- * import { makeDefaultDisplayState } from 'attaform'
- *
- * useForm({
- *   schema,
- *   getDisplayState: makeDefaultDisplayState({ showDelay: 50, minVisible: 200 }),
- * })
- * ```
- *
- * The returned reducer is pure: the engine injects `now` and threads the
- * previous machine, so the same `(prev, ctx)` always yields the same next
- * machine. It shapes only the display projection — `errors`, `valid`,
- * `validating`, and the underlying validation run exactly as before.
- */
-declare function makeDefaultDisplayState({ showDelay, minVisible, }: DisplayTimings): GetDisplayState;
-/**
- * Library-default `getDisplayState` reducer. Resolves every path's
- * `field.displayState` — and thus `field.show*` and the `form.meta`
- * rollups — whenever the consumer has not configured an override at the
- * per-form or plugin level. Built from {@link DEFAULT_TIMINGS}; publicly
- * re-exported so an override can compose with it (a layered reducer that
- * special-cases a subtree but otherwise defers picks up future
- * refinements for free):
- *
- * ```ts
- * import { defaultDisplayState } from 'attaform'
- *
- * useForm({
- *   schema,
- *   getDisplayState: (prev, ctx) => {
- *     const next = defaultDisplayState(prev, ctx)
- *     return next.display === 'success' && ctx.field.path[0] === 'username'
- *       ? { display: 'idle' }
- *       : next
- *   },
- * })
- * ```
- */
-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, 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 { createRegistry as B, DEVTOOLS_WINDOW_KEY as D, escapeForInlineScript as E, gate as H, getRegistryFromApp as J, hydrateAttaformState as K, injectForm as M, injectWizard as N, OutsideSetupError as O, isRegisterValue as P, kAttaformRegistry as Q, RegistryNotInstalledError as R, lazy as T, renderAttaformState as V, useRegister as X, useRegistry as Y, useWizard as Z, AttaformError as c, AttaformErrorCode as d, InvalidPathError as g, InvalidUseFormConfigError as h, ReservedFormKeyError as i, SubmitErrorHandlerError as l, assignKey as y, createAttaform 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, UseRegisterOptions as U, WizardAggregateError as W, AnyForm as a, AttaformDevtoolsBridge as b, AttaformPluginOptions as e, FormStatusSeed as f, SerializedFormData as j, StepSlot as k, UseRegisterReturn as m, UseWizardReturnType as n, WizardCtx as o, WizardCtxForm as p, WizardOnError as q, WizardOnSubmit as r, WizardOptions as s, WizardPersistFn as t, WizardRestoreFn as u, WizardRestoreState as v, WizardStatusesProxy as w, WizardSubmitContext as x };

package/dist/shared/{attaform.Dq4vWxuG.mjs → attaform.WiGdIqgx.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.wfY8XFvm.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CdZIEf7_.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -17,7 +17,6 @@ const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
 const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
 function createRegistry(options = {}) {
   const ssr = detectSSR(options);
-  const defaults = Object.freeze({ ...options.defaults ?? {} });
   const forms = shallowReactive(/* @__PURE__ */ new Map());
   const wizards = shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
@@ -102,7 +101,6 @@ function createRegistry(options = {}) {
     wizards,
     pendingHydration,
     ssr,
-    defaults,
     trackConsumer,
     trackWizardConsumer,
     enqueuePrefetch,