attaform 0.27.6 → 0.28.0

package/dist/shared/{attaform.CHlJLAiv.d.mts → attaform.D5V4tZWq.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, 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 { Ref, ComputedRef, ShallowRef, App, InjectionKey, Plugin } from 'vue';
 
 /**
  * Options accepted by `injectForm` when passing an object instead of
@@ -206,71 +206,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 +268,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.
@@ -538,7 +480,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 +540,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 +629,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 +642,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 +653,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 +679,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.
+     */
+    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.
      */
-    registerElement(path: Path, element: HTMLElement, formInstanceId: string): boolean;
-    deregisterElement(path: Path, element: HTMLElement): number;
+    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 +741,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 +779,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 +881,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
@@ -1783,13 +1692,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 +2069,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 +2110,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 +2152,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 +2380,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 { 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 };

package/dist/shared/{attaform.B9Wyhfro.cjs → attaform.D6DCnnQu.mjs}

@@ -1,9 +1,7 @@
-'use strict';
-
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
-const useForm$1 = require('./attaform.D8kliaKw.cjs');
-const index = require('./attaform.DdQN7sgN.cjs');
-const walkFieldMeta = require('./attaform.D6tk90Rc.cjs');
+import { a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.mjs';
+import { u as useForm$2 } from './attaform.CJP3RkGa.mjs';
+import { u as useForm$1 } from './attaform.NLmerepI.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.C09fpdLS.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -14,21 +12,21 @@ function isZodV4SchemaShape(value) {
 
 function useForm(configuration) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new devtoolsShared.InvalidUseFormConfigError();
+    throw new InvalidUseFormConfigError();
   }
   const { schema } = configuration;
   if (isZodV4SchemaShape(schema)) {
-    return index.useForm(configuration);
+    return useForm$1(configuration);
   }
-  return useForm$1.useForm(configuration);
+  return useForm$2(configuration);
 }
 
-const fieldMeta = walkFieldMeta.fieldMetaStore;
+const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {
   const target = schema;
-  const existing = walkFieldMeta.getFieldMetaForSchema(target) ?? {};
+  const existing = getFieldMetaForSchema(target) ?? {};
   const cloned = cloneSchema(schema);
-  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  installingFieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function cloneSchema(schema) {
@@ -40,7 +38,4 @@ function cloneSchema(schema) {
   return new Ctor(candidate._def);
 }
 
-exports.fieldMeta = fieldMeta;
-exports.useForm = useForm;
-exports.withMeta = withMeta;
-//# sourceMappingURL=attaform.B9Wyhfro.cjs.map
+export { fieldMeta as f, useForm as u, withMeta as w };

package/dist/shared/attaform.DhnPb6nK.mjs

@@ -51,4 +51,3 @@ function resolveZodAliasTarget(consumerRootDir, tag, resolveZodAlias, warnState)
 }
 
 export { REWRITABLE_ZOD_SPECIFIER_FILTER as R, isRewritableZodSpecifier as i, resolveZodAliasTarget as r };
-//# sourceMappingURL=attaform.DhnPb6nK.mjs.map

package/dist/shared/attaform.Dq4vWxuG.mjs

@@ -0,0 +1,197 @@
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.wfY8XFvm.mjs';
+import { shallowReactive, getCurrentInstance, inject } from 'vue';
+
+function detectSSR(options = {}) {
+  if (options.ssr !== void 0) return options.ssr;
+  return typeof window === "undefined" && typeof document === "undefined";
+}
+
+const kAttaformRegistry = /* @__PURE__ */ Symbol.for("attaform:registry");
+const kAttaformAncestorWizard = /* @__PURE__ */ Symbol.for(
+  "attaform:ancestor-wizard"
+);
+const kAttaformWizardActiveStepResolver = /* @__PURE__ */ Symbol.for(
+  "attaform:wizard-active-step-resolver"
+);
+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());
+  const consumers = /* @__PURE__ */ new Map();
+  const pendingEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingEviction(key) {
+    const pending = pendingEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingEvictions.delete(key);
+  }
+  function trackConsumer(key) {
+    cancelPendingEviction(key);
+    consumers.set(key, (consumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (consumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        consumers.set(key, remaining);
+        return;
+      }
+      consumers.delete(key);
+      const token = { cancelled: false };
+      pendingEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingEvictions.get(key) !== token) return;
+        pendingEvictions.delete(key);
+        const state = forms.get(key);
+        forms.delete(key);
+        if (state === void 0) return;
+        state.dispose();
+      });
+    };
+  }
+  const wizardConsumers = /* @__PURE__ */ new Map();
+  const pendingWizardEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingWizardEviction(key) {
+    const pending = pendingWizardEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingWizardEvictions.delete(key);
+  }
+  function trackWizardConsumer(key) {
+    cancelPendingWizardEviction(key);
+    wizardConsumers.set(key, (wizardConsumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (wizardConsumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        wizardConsumers.set(key, remaining);
+        return;
+      }
+      wizardConsumers.delete(key);
+      const token = { cancelled: false };
+      pendingWizardEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingWizardEvictions.get(key) !== token) return;
+        pendingWizardEvictions.delete(key);
+        wizards.delete(key);
+      });
+    };
+  }
+  const prefetchEnqueued = /* @__PURE__ */ new Set();
+  const prefetchSkipped = /* @__PURE__ */ new Set();
+  function enqueuePrefetch(key) {
+    prefetchEnqueued.add(key);
+  }
+  function skipPrefetch(key) {
+    prefetchSkipped.add(key);
+  }
+  function shouldPrefetch(key) {
+    return prefetchEnqueued.has(key) && !prefetchSkipped.has(key);
+  }
+  return {
+    forms,
+    wizards,
+    pendingHydration,
+    ssr,
+    defaults,
+    trackConsumer,
+    trackWizardConsumer,
+    enqueuePrefetch,
+    skipPrefetch,
+    shouldPrefetch
+  };
+}
+function useRegistry() {
+  const instance = getCurrentInstance();
+  if (instance === null) {
+    throw new OutsideSetupError();
+  }
+  const registry = inject(kAttaformRegistry, null);
+  if (registry === null) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function getRegistryFromApp(app) {
+  const registry = app._attaform;
+  if (registry === void 0) {
+    throw new RegistryNotInstalledError();
+  }
+  return registry;
+}
+function attachRegistryToApp(app, registry) {
+  app.provide(kAttaformRegistry, registry);
+  app._attaform = registry;
+}
+
+function installAttaformOnApp(app, options, source) {
+  if (app._attaform !== void 0) {
+    return app._attaform;
+  }
+  const registry = createRegistry(options);
+  attachRegistryToApp(app, registry);
+  return registry;
+}
+function ensureAttaformInstalled(app) {
+  return installAttaformOnApp(app, {});
+}
+function createAttaform(options = {}) {
+  const plugin = {
+    install(app) {
+      installAttaformOnApp(app, options);
+    }
+  };
+  return plugin;
+}
+
+const ATTAFORM_STATE_VERSION = 1;
+function renderAttaformState(app) {
+  const registry = getRegistryFromApp(app);
+  const forms = [];
+  for (const [key, state] of registry.forms) {
+    const transientList = [];
+    for (const pk of state.blankPaths) {
+      const d = pathKeyToDotted(pk);
+      if (d !== null) transientList.push(d);
+    }
+    forms.push([
+      key,
+      {
+        form: state.form.value,
+        // The wire shape stays two per-source arrays; the tagged store
+        // splits at the boundary and the client replays each side into
+        // its cell half.
+        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        fields: Array.from(state.fields.entries()),
+        ...transientList.length > 0 ? { blankPaths: transientList } : {}
+      }
+    ]);
+  }
+  return { v: ATTAFORM_STATE_VERSION, forms };
+}
+function hydrateAttaformState(app, payload) {
+  if (!isHydratableEnvelope(payload)) {
+    return;
+  }
+  const registry = getRegistryFromApp(app);
+  for (const [key, data] of payload.forms) {
+    registry.pendingHydration.set(key, data);
+  }
+}
+function isHydratableEnvelope(payload) {
+  return payload !== null && typeof payload === "object" && "v" in payload && payload.v === ATTAFORM_STATE_VERSION && "forms" in payload && Array.isArray(payload.forms);
+}
+
+const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
+
+export { DEVTOOLS_WINDOW_KEY as D, createRegistry as a, kAttaformWizardActiveStepResolver as b, createAttaform as c, kFormContext as d, ensureAttaformInstalled as e, kFormInstanceId as f, getRegistryFromApp as g, hydrateAttaformState as h, kAttaformAncestorWizard as i, kAttaformRegistry as k, renderAttaformState as r, useRegistry as u };

package/dist/shared/attaform.JfSWdEcb.d.mts

@@ -0,0 +1,44 @@
+import { App } from 'vue';
+import { ar as RegisterModelDynamicCustomDirective } from './attaform.Cgu-hdSb.mjs';
+
+/**
+ * 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`. Delivered by the Vite / Nuxt
+ * plugin's compile-time binding, or by `installVRegister(app)`
+ * everywhere else. Most consumers never import it directly, but it's
+ * exposed for advanced integrations that wire directives manually.
+ */
+declare const vRegister: RegisterModelDynamicCustomDirective;
+/**
+ * Register the `v-register` directive app-wide. The one-line setup for
+ * apps whose templates are compiled without Attaform's Vite or Nuxt
+ * plugin — a webpack-family bundler, a no-build / CDN page, or
+ * runtime-compiled templates:
+ *
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { installVRegister } from 'attaform/directive'
+ *
+ * const app = createApp(App)
+ * installVRegister(app)
+ * ```
+ *
+ * Vite and Nuxt consumers don't call this: the build plugin binds each
+ * template's `v-register` to the directive at compile time. Idempotent —
+ * a second call for the same app is a no-op, and an app-level directive
+ * a consumer registered under the same name is left in place.
+ */
+declare function installVRegister(app: App): void;
+
+export { installVRegister as i, vRegister as v };

package/dist/shared/attaform.KvlEedlF.mjs

@@ -19,4 +19,3 @@ function isTransforming(value) {
 }
 
 export { REGISTER_OWNER_MARKER as R, SSR_COMPONENT_HOST_MODIFIER as S, V_REGISTER_COMPILED_MODIFIER as V, isTransforming as a, V_REGISTER_MARKER as b, isRegisterValue as i };
-//# sourceMappingURL=attaform.KvlEedlF.mjs.map