attaform 0.19.0 → 0.20.1

package/dist/shared/{attaform.D4I63aBV.d.ts → attaform.DSD85fHb.d.cts}

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { t as FormKey, al as ValidateOnConfig, P as OnInvalidSubmitPolicy, V as PersistConfig, y as HistoryConfig, g as CoercionRegistry } from './attaform.C0uGZQ4M.js';
 
 /**
  * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
@@ -23,23 +22,6 @@ type StorageShape<S extends z.ZodTypeAny> = S extends z.ZodObject<infer Shape> ?
     [K in keyof Shape]-?: Shape[K] extends z.ZodEffects<z.ZodTypeAny> | z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny> ? z.input<Shape[K]> : z.output<Shape[K]>;
 } : z.input<S>;
 
-/**
- * Configuration object for the Zod v3 `useForm` overload. Same
- * shape as the schema-agnostic `UseFormConfiguration`, but with
- * `schema` constrained to a `z.ZodObject` (or wrapped form).
- */
-type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValues, K extends FormKey = FormKey> = ValidateOnConfig & {
-    /** A Zod v3 `ZodObject` schema (or one wrapped in `.optional()` / `.nullable()` / `.default()` / `.refine()`). */
-    schema: Schema extends z.ZodType<unknown> ? UnwrapZodObject<Schema> extends z.ZodObject<z.ZodRawShape> ? Schema : never : never;
-    key?: K;
-    defaultValues?: DefaultValues | (() => DefaultValues) | (() => Promise<DefaultValues>);
-    strict?: boolean;
-    onInvalidSubmit?: OnInvalidSubmitPolicy;
-    persist?: PersistConfig;
-    history?: HistoryConfig;
-    rememberVariants?: boolean;
-    coerce?: boolean | CoercionRegistry;
-};
 /**
  * Peel `.optional()` / `.nullable()` / `.default()` / `.refine()` /
  * `.transform()` wrappers off a Zod v3 schema to reach the inner
@@ -50,4 +32,4 @@ type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValue
  */
 type UnwrapZodObject<T> = T extends z.ZodEffects<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodOptional<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodNullable<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodDefault<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodObject<infer Shape> ? z.ZodObject<Shape> : never;
 
-export type { StorageShape as S, UnwrapZodObject as U, UseFormConfigurationWithZod as a };
+export type { StorageShape as S, UnwrapZodObject as U };

package/dist/shared/{attaform.CBjmobqk.d.cts → attaform.DSD85fHb.d.mts}

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { t as FormKey, al as ValidateOnConfig, P as OnInvalidSubmitPolicy, V as PersistConfig, y as HistoryConfig, g as CoercionRegistry } from './attaform.C0uGZQ4M.cjs';
 
 /**
  * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
@@ -23,23 +22,6 @@ type StorageShape<S extends z.ZodTypeAny> = S extends z.ZodObject<infer Shape> ?
     [K in keyof Shape]-?: Shape[K] extends z.ZodEffects<z.ZodTypeAny> | z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny> ? z.input<Shape[K]> : z.output<Shape[K]>;
 } : z.input<S>;
 
-/**
- * Configuration object for the Zod v3 `useForm` overload. Same
- * shape as the schema-agnostic `UseFormConfiguration`, but with
- * `schema` constrained to a `z.ZodObject` (or wrapped form).
- */
-type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValues, K extends FormKey = FormKey> = ValidateOnConfig & {
-    /** A Zod v3 `ZodObject` schema (or one wrapped in `.optional()` / `.nullable()` / `.default()` / `.refine()`). */
-    schema: Schema extends z.ZodType<unknown> ? UnwrapZodObject<Schema> extends z.ZodObject<z.ZodRawShape> ? Schema : never : never;
-    key?: K;
-    defaultValues?: DefaultValues | (() => DefaultValues) | (() => Promise<DefaultValues>);
-    strict?: boolean;
-    onInvalidSubmit?: OnInvalidSubmitPolicy;
-    persist?: PersistConfig;
-    history?: HistoryConfig;
-    rememberVariants?: boolean;
-    coerce?: boolean | CoercionRegistry;
-};
 /**
  * Peel `.optional()` / `.nullable()` / `.default()` / `.refine()` /
  * `.transform()` wrappers off a Zod v3 schema to reach the inner
@@ -50,4 +32,4 @@ type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValue
  */
 type UnwrapZodObject<T> = T extends z.ZodEffects<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodOptional<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodNullable<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodDefault<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodObject<infer Shape> ? z.ZodObject<Shape> : never;
 
-export type { StorageShape as S, UnwrapZodObject as U, UseFormConfigurationWithZod as a };
+export type { StorageShape as S, UnwrapZodObject as U };

package/dist/shared/{attaform.DXYHL99q.d.mts → attaform.DSD85fHb.d.ts}

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { t as FormKey, al as ValidateOnConfig, P as OnInvalidSubmitPolicy, V as PersistConfig, y as HistoryConfig, g as CoercionRegistry } from './attaform.C0uGZQ4M.mjs';
 
 /**
  * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
@@ -23,23 +22,6 @@ type StorageShape<S extends z.ZodTypeAny> = S extends z.ZodObject<infer Shape> ?
     [K in keyof Shape]-?: Shape[K] extends z.ZodEffects<z.ZodTypeAny> | z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny> ? z.input<Shape[K]> : z.output<Shape[K]>;
 } : z.input<S>;
 
-/**
- * Configuration object for the Zod v3 `useForm` overload. Same
- * shape as the schema-agnostic `UseFormConfiguration`, but with
- * `schema` constrained to a `z.ZodObject` (or wrapped form).
- */
-type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValues, K extends FormKey = FormKey> = ValidateOnConfig & {
-    /** A Zod v3 `ZodObject` schema (or one wrapped in `.optional()` / `.nullable()` / `.default()` / `.refine()`). */
-    schema: Schema extends z.ZodType<unknown> ? UnwrapZodObject<Schema> extends z.ZodObject<z.ZodRawShape> ? Schema : never : never;
-    key?: K;
-    defaultValues?: DefaultValues | (() => DefaultValues) | (() => Promise<DefaultValues>);
-    strict?: boolean;
-    onInvalidSubmit?: OnInvalidSubmitPolicy;
-    persist?: PersistConfig;
-    history?: HistoryConfig;
-    rememberVariants?: boolean;
-    coerce?: boolean | CoercionRegistry;
-};
 /**
  * Peel `.optional()` / `.nullable()` / `.default()` / `.refine()` /
  * `.transform()` wrappers off a Zod v3 schema to reach the inner
@@ -50,4 +32,4 @@ type UseFormConfigurationWithZod<Schema extends z.ZodType<unknown>, DefaultValue
  */
 type UnwrapZodObject<T> = T extends z.ZodEffects<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodOptional<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodNullable<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodDefault<infer Inner> ? UnwrapZodObject<Inner> : T extends z.ZodObject<infer Shape> ? z.ZodObject<Shape> : never;
 
-export type { StorageShape as S, UnwrapZodObject as U, UseFormConfigurationWithZod as a };
+export type { StorageShape as S, UnwrapZodObject as U };

package/dist/shared/{attaform.B7rzpK1U.d.cts → attaform.DkA5J8NW.d.cts}

@@ -105,22 +105,6 @@ declare class ReservedFormKeyError extends AttaformError {
  * `console.warn` so a deployed third-party app shipping the
  * anti-pattern doesn't hard-crash.
  */
-/**
- * Thrown when `register(path, { persist: true })` or `form.persist(path)`
- * targets a path whose name matches a sensitive-data heuristic
- * (password, cvv, ssn, token, etc.) without an explicit
- * `acknowledgeSensitive: true` override.
- *
- * Sensitive data in client-side storage (localStorage, sessionStorage,
- * IndexedDB) is a compliance risk — it survives logouts, is readable
- * by any same-origin script, and is unencrypted at rest.
- *
- * Fix: pass `acknowledgeSensitive: true` to confirm the persistence
- * is intentional, or persist the data server-side instead.
- */
-declare class SensitivePersistFieldError extends AttaformError {
-    constructor(path: ReadonlyArray<string | number> | string);
-}
 /**
  * Thrown when persistence is misconfigured in a way that would either
  * (a) silently drop writes, or (b) namespace storage under a
@@ -152,4 +136,4 @@ declare class AnonPersistError extends AttaformError {
     });
 }
 
-export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SensitivePersistFieldError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c, SubmitErrorHandlerError as d };
+export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SubmitErrorHandlerError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c };

package/dist/shared/{attaform.B7rzpK1U.d.mts → attaform.DkA5J8NW.d.mts}

@@ -105,22 +105,6 @@ declare class ReservedFormKeyError extends AttaformError {
  * `console.warn` so a deployed third-party app shipping the
  * anti-pattern doesn't hard-crash.
  */
-/**
- * Thrown when `register(path, { persist: true })` or `form.persist(path)`
- * targets a path whose name matches a sensitive-data heuristic
- * (password, cvv, ssn, token, etc.) without an explicit
- * `acknowledgeSensitive: true` override.
- *
- * Sensitive data in client-side storage (localStorage, sessionStorage,
- * IndexedDB) is a compliance risk — it survives logouts, is readable
- * by any same-origin script, and is unencrypted at rest.
- *
- * Fix: pass `acknowledgeSensitive: true` to confirm the persistence
- * is intentional, or persist the data server-side instead.
- */
-declare class SensitivePersistFieldError extends AttaformError {
-    constructor(path: ReadonlyArray<string | number> | string);
-}
 /**
  * Thrown when persistence is misconfigured in a way that would either
  * (a) silently drop writes, or (b) namespace storage under a
@@ -152,4 +136,4 @@ declare class AnonPersistError extends AttaformError {
     });
 }
 
-export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SensitivePersistFieldError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c, SubmitErrorHandlerError as d };
+export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SubmitErrorHandlerError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c };

package/dist/shared/{attaform.B7rzpK1U.d.ts → attaform.DkA5J8NW.d.ts}

@@ -105,22 +105,6 @@ declare class ReservedFormKeyError extends AttaformError {
  * `console.warn` so a deployed third-party app shipping the
  * anti-pattern doesn't hard-crash.
  */
-/**
- * Thrown when `register(path, { persist: true })` or `form.persist(path)`
- * targets a path whose name matches a sensitive-data heuristic
- * (password, cvv, ssn, token, etc.) without an explicit
- * `acknowledgeSensitive: true` override.
- *
- * Sensitive data in client-side storage (localStorage, sessionStorage,
- * IndexedDB) is a compliance risk — it survives logouts, is readable
- * by any same-origin script, and is unencrypted at rest.
- *
- * Fix: pass `acknowledgeSensitive: true` to confirm the persistence
- * is intentional, or persist the data server-side instead.
- */
-declare class SensitivePersistFieldError extends AttaformError {
-    constructor(path: ReadonlyArray<string | number> | string);
-}
 /**
  * Thrown when persistence is misconfigured in a way that would either
  * (a) silently drop writes, or (b) namespace storage under a
@@ -152,4 +136,4 @@ declare class AnonPersistError extends AttaformError {
     });
 }
 
-export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SensitivePersistFieldError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c, SubmitErrorHandlerError as d };
+export { AnonPersistError as A, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SubmitErrorHandlerError as S, AttaformError as a, InvalidUseFormConfigError as b, ReservedFormKeyError as c };

package/dist/shared/{attaform.CJ-e9gYI.d.ts → attaform.Dl5kDY-A.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.C0uGZQ4M.js';
+import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.SfhU0OEY.js';
 
 /**
  * The shape `form.values.<key>` returns at runtime.

package/dist/shared/{attaform.CRNA0vrd.d.mts → attaform.DoKXru-a.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.C0uGZQ4M.mjs';
+import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.SfhU0OEY.mjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.

package/dist/shared/{attaform.BtBmfLQN.d.mts → attaform.EMzJcQci.d.mts}

@@ -1,4 +1,4 @@
-import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, aa as Segment, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.C0uGZQ4M.mjs';
+import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.SfhU0OEY.mjs';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -61,7 +61,7 @@ type FormStatus = {
  * entry carries the formKey + path tuple so consumers can route to the
  * offending field from a wizard-wide error summary.
  */
-type AggregateError = {
+type WizardAggregateError = {
     readonly formKey: FormKey;
     readonly path: ReadonlyArray<string | number>;
     readonly message: string;
@@ -213,7 +213,7 @@ type WizardOnSubmit = (ctx: WizardSubmitContext) => void | Promise<void>;
  * validation and activation failures (`atta:activation-failed`). Sync
  * or async; the returned promise gates `wizard.submitting`.
  */
-type WizardOnError = (errors: readonly AggregateError[]) => void | Promise<void>;
+type WizardOnError = (errors: readonly WizardAggregateError[]) => void | Promise<void>;
 /**
  * Options for `useWizard({ steps, … })`. `steps` is the only required
  * field; the rest are optional and default sensibly for the common
@@ -439,7 +439,7 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly count: number;
     readonly statuses: WizardStatusesProxy<Record<string, FormStatus>>;
     readonly allValues: Readonly<Record<FormKey, unknown>>;
-    readonly allErrors: Readonly<Record<FormKey, readonly AggregateError[]>>;
+    readonly allErrors: Readonly<Record<FormKey, readonly WizardAggregateError[]>>;
     readonly progress: number;
     readonly canAdvance: boolean;
     readonly canGoBack: boolean;
@@ -701,6 +701,15 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * plain-value forms. Read by `form.rehydrate()`.
      */
     readonly defaultValuesFactory: Ref<(() => unknown | Promise<unknown>) | undefined>;
+    /**
+     * `true` when this store carries an SSR prefetch queue (server path
+     * where `state.activate()` must enqueue intent before deciding
+     * whether to fire). The flag lets `buildFormApi` skip the lazy
+     * activation gate for forms with no factory AND no SSR prefetch —
+     * the common client-side case where `gated()` is otherwise pure
+     * reactive overhead on every public method call.
+     */
+    readonly hasSsrPrefetch: boolean;
     /**
      * `true` once the form's effective defaults have been applied —
      * sync `defaultValues` at construction, or async factory whose
@@ -797,6 +806,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * answer.
      */
     pathHasAsyncValidation(path: Path): boolean;
+    /**
+     * Precomputed-key shortcut for `pathHasAsyncValidation`. The
+     * canonical key is required and must correspond to `segments`; the
+     * helper skips the `canonicalizePath` round-trip so descendant-walk
+     * loops (whose Map iteration already yields the canonical key) can
+     * read the async-gate verdict without a per-leaf canonicalize.
+     */
+    pathHasAsyncValidationByKey(key: PathKey, segments: Path): boolean;
     /**
      * Per-path counter of in-flight field-level validation runs.
      * `field.validating` on `FieldState` mirrors
@@ -852,14 +869,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     arrayElementKey(path: Path): string;
     reset(nextDefaultValues?: DeepPartial<WriteShape<F>>): void;
     resetField(path: Path): void;
-    /**
-     * Wipe `path` (or the whole form when `path === ''`) to the
-     * schema's "appropriate nullish value" — the underlying type's
-     * empty/falsy concrete, with `.default()` / `.catch()` wrappers
-     * INTENTIONALLY skipped. Sugar for
-     * `setValueAtPath(path, schema.getEmptyValueAtPath(path))`.
-     */
-    clear(path: Path): boolean;
     setSchemaErrorsForPath(path: Path, errors: ValidationError[]): void;
     setAllSchemaErrors(errors: readonly ValidationError[]): void;
     clearSchemaErrors(path?: Path): void;
@@ -912,7 +921,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     markFocused(path: Path, focused: boolean, meta?: {
         readonly instance?: WriteMeta['instance'];
     }): void;
-    markTouched(path: Path): void;
     /**
      * Flip `interacted: true` on a leaf — the sticky value-mutation flag.
      * Driven by the directive's input listeners (via the RegisterValue's
@@ -945,6 +953,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * 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
+     * skips the `canonicalizePath` round-trip so descendant-walk loops
+     * (whose Map iteration already yields the canonical key) can read
+     * the pristine verdict without a per-leaf canonicalize.
+     */
+    isPristineAtPathByKey(key: PathKey, segments: Path): boolean;
     /**
      * Whether any tracked array under `path` has changed shape — a reorder,
      * insert, or removal — relative to its construction/reset baseline. The
@@ -1086,7 +1102,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * Resolved sensitive-path predicate for THIS form. Honors the
      * cascade (`useForm({ sensitiveNames })` > global default >
      * library `DEFAULT_SENSITIVE_NAMES`). Used by:
-     *  - persistence enforcement (`enforceSensitiveCheck` at write time);
+     *  - the persistence opt-in gate (`allowSensitivePersist`);
      *  - the multi-tab sync module (outbound strip + inbound reject);
      *  - DevTools edit rejection;
      *  - any future surface that needs to flag "this path holds
@@ -1097,14 +1113,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * resolved-config surface.
      */
     readonly isSensitivePath: (path: Path | PathKey | string) => boolean;
-    /**
-     * Single-segment variant of `isSensitivePath`. Used by the DevTools
-     * redact walk to short-circuit whole subtrees the moment any
-     * ancestor segment matches — saving an O(leaves × ancestors) regex
-     * sweep per timeline event. Resolved from the same `sensitiveNames`
-     * cascade as `isSensitivePath`.
-     */
-    readonly segmentMatchesSensitive: (segment: Segment) => boolean;
     /**
      * Canonical path keys explicitly opted OUT of multi-tab sync by
      * `register(path, { multiTab: false })`. The sync module's outbound
@@ -1428,6 +1436,83 @@ type InjectFormInput = {
  */
 declare function injectForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form>(input?: FormKey | InjectFormInput): UseFormReturnType<Form, GetValueFormType> | null;
 
+/**
+ * Re-bind a parent's `v-register` onto an inner native element. Use
+ * inside a component that wraps a single form field whose root is
+ * NOT the input itself (e.g. a labelled-row that renders `<label>`
+ * around the input).
+ *
+ * ```vue
+ * <!-- Parent -->
+ * <MyInput v-register="form.register('email')" />
+ *
+ * <!-- MyInput.vue -->
+ * <script setup lang="ts">
+ *   import { useRegister } from 'attaform'
+ *   const rv = useRegister()
+ *   // rv.path / rv.segments / rv.formKey / rv.formInstanceId / rv.innerRef
+ *   // are all reachable directly — no `.value` unwrap.
+ * </script>
+ *
+ * <template>
+ *   <label class="field">
+ *     <span>Email</span>
+ *     <input v-register="rv" />
+ *   </label>
+ * </template>
+ * ```
+ *
+ * Returns a hybrid Proxy: it answers `__v_isRef` / `.value` like a
+ * Vue `Ref<RegisterValue | undefined>` (so templates auto-unwrap
+ * correctly and `v-register="rv"` feeds the underlying RV to the
+ * directive — preserving the directive's path-migration diff across
+ * renders), AND every other property read pierces to the captured
+ * RV's field (so `rv.path` works directly in script setup). Reads
+ * inside reactive scopes (`computed` / `watchEffect`) track the
+ * underlying `shallowRef`, so `rv.path` re-runs when the parent
+ * rebinds to a different path.
+ *
+ * Unbound state: when the parent didn't pass `v-register`, every
+ * piercing read returns `undefined` at runtime, and the return type
+ * surfaces this honestly as `UseRegisterReturn<V> | undefined`.
+ * Consumers defend with optional chaining (`rv?.formKey`,
+ * `rv?.segments`); the directive accepts `undefined` peacefully (its
+ * binding value type is already `RegisterValue<V> | undefined`), so
+ * `v-register="rv"` works whether or not a parent has bound. The
+ * composable's `onMounted` warn fires once per instance to surface
+ * the misuse case at runtime.
+ *
+ * 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
+ * binding is conclusive misuse. The warn does NOT fire on every read
+ * of the proxy, and is intentionally silent under SSR
+ * (`renderToString` skips `onMounted`); the CSR hydration pass
+ * surfaces the same diagnostic without double-counting through Nuxt's
+ * `dev:ssr-logs` channel.
+ *
+ * When the wrapper's root IS the input itself, Vue's attribute
+ * fallthrough handles the binding and `useRegister` is unnecessary.
+ * For wrappers that bind multiple fields (compound forms), use
+ * `injectForm<Form>(key?)` and call `ctx.register(...)` directly.
+ */
+
+/**
+ * Return type of `useRegister()`. Hybrid of `RegisterValue<V>` (so
+ * `rv.path` / `rv.segments` / `rv.formKey` etc. work directly in
+ * script setup) and `Ref<RegisterValue<V> | undefined>` (so Vue's
+ * template auto-unwrap surfaces the underlying RV to `v-register`
+ * and the directive's path-migration diff sees the real RV across
+ * renders).
+ *
+ * The two surfaces don't clash at the type level: `RegisterValue`
+ * doesn't carry a `value` field, and `Ref<T>`'s `value: T` becomes
+ * 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;
+
 /**
  * Multistep-form orchestrator built around an ordered list of step slots.
  * Each slot resolves to a participating form: an existing `useForm`
@@ -1543,83 +1628,6 @@ declare function injectWizard(input?: string | InjectWizardInput): UseWizardRetu
  */
 declare function lazy<Ctx = WizardCtx>(resolve: (ctx: Ctx) => AnyForm | string | undefined): LazyMarker<Ctx>;
 
-/**
- * Re-bind a parent's `v-register` onto an inner native element. Use
- * inside a component that wraps a single form field whose root is
- * NOT the input itself (e.g. a labelled-row that renders `<label>`
- * around the input).
- *
- * ```vue
- * <!-- Parent -->
- * <MyInput v-register="form.register('email')" />
- *
- * <!-- MyInput.vue -->
- * <script setup lang="ts">
- *   import { useRegister } from 'attaform'
- *   const rv = useRegister()
- *   // rv.path / rv.segments / rv.formKey / rv.formInstanceId / rv.innerRef
- *   // are all reachable directly — no `.value` unwrap.
- * </script>
- *
- * <template>
- *   <label class="field">
- *     <span>Email</span>
- *     <input v-register="rv" />
- *   </label>
- * </template>
- * ```
- *
- * Returns a hybrid Proxy: it answers `__v_isRef` / `.value` like a
- * Vue `Ref<RegisterValue | undefined>` (so templates auto-unwrap
- * correctly and `v-register="rv"` feeds the underlying RV to the
- * directive — preserving the directive's path-migration diff across
- * renders), AND every other property read pierces to the captured
- * RV's field (so `rv.path` works directly in script setup). Reads
- * inside reactive scopes (`computed` / `watchEffect`) track the
- * underlying `shallowRef`, so `rv.path` re-runs when the parent
- * rebinds to a different path.
- *
- * Unbound state: when the parent didn't pass `v-register`, every
- * piercing read returns `undefined` at runtime, and the return type
- * surfaces this honestly as `UseRegisterReturn<V> | undefined`.
- * Consumers defend with optional chaining (`rv?.formKey`,
- * `rv?.segments`); the directive accepts `undefined` peacefully (its
- * binding value type is already `RegisterValue<V> | undefined`), so
- * `v-register="rv"` works whether or not a parent has bound. The
- * composable's `onMounted` warn fires once per instance to surface
- * the misuse case at runtime.
- *
- * 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
- * binding is conclusive misuse. The warn does NOT fire on every read
- * of the proxy, and is intentionally silent under SSR
- * (`renderToString` skips `onMounted`); the CSR hydration pass
- * surfaces the same diagnostic without double-counting through Nuxt's
- * `dev:ssr-logs` channel.
- *
- * When the wrapper's root IS the input itself, Vue's attribute
- * fallthrough handles the binding and `useRegister` is unnecessary.
- * For wrappers that bind multiple fields (compound forms), use
- * `injectForm<Form>(key?)` and call `ctx.register(...)` directly.
- */
-
-/**
- * Return type of `useRegister()`. Hybrid of `RegisterValue<V>` (so
- * `rv.path` / `rv.segments` / `rv.formKey` etc. work directly in
- * script setup) and `Ref<RegisterValue<V> | undefined>` (so Vue's
- * template auto-unwrap surfaces the underlying RV to `v-register`
- * and the directive's path-migration diff sees the real RV across
- * renders).
- *
- * The two surfaces don't clash at the type level: `RegisterValue`
- * doesn't carry a `value` field, and `Ref<T>`'s `value: T` becomes
- * 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;
-
 /**
  * Stable identifiers for library-emitted `ValidationError` codes.
  *
@@ -1680,5 +1688,5 @@ declare const AttaformErrorCode: {
 };
 type AttaformErrorCode = (typeof AttaformErrorCode)[keyof typeof AttaformErrorCode];
 
-export { AttaformErrorCode as b, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
-export type { AggregateError as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardCtx as W, AnyForm as a, AttaformRegistry as c, SerializedFormData as d, StepSlot as e, UseWizardReturnType as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };
+export { AttaformErrorCode as a, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
+export type { AnyForm as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardAggregateError as W, AttaformRegistry as b, SerializedFormData as c, StepSlot as d, UseWizardReturnType as e, WizardCtx as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };

package/dist/shared/attaform.EZG6fOFb.mjs

@@ -0,0 +1,35 @@
+import { r as getRegistryFromApp, C as pathKeyToDotted } from './attaform.BKozEdTr.mjs';
+
+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,
+        schemaErrors: Array.from(state.schemaErrors.entries()),
+        userErrors: Array.from(state.userErrors.entries()),
+        fields: Array.from(state.fields.entries()),
+        ...transientList.length > 0 ? { blankPaths: transientList } : {}
+      }
+    ]);
+  }
+  return { forms };
+}
+function hydrateAttaformState(app, payload) {
+  const registry = getRegistryFromApp(app);
+  for (const [key, data] of payload.forms) {
+    registry.pendingHydration.set(key, data);
+  }
+}
+
+const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
+
+export { DEVTOOLS_WINDOW_KEY as D, hydrateAttaformState as h, renderAttaformState as r };
+//# sourceMappingURL=attaform.EZG6fOFb.mjs.map

package/dist/shared/attaform.EZG6fOFb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.EZG6fOFb.mjs","sources":["../../src/runtime/core/serialize.ts","../../src/runtime/core/devtools-shared.ts"],"sourcesContent":["import type { App } from 'vue'\nimport type { FormKey } from '../types/types-api'\nimport { pathKeyToDotted, type PathKey } from './paths'\nimport { getRegistryFromApp, type SerializedFormData } from './registry'\n\n/**\n * Serialised snapshot of every form in a Vue app, produced by\n * `renderAttaformState` and consumed by `hydrateAttaformState`.\n *\n * JSON-safe — pass to `JSON.stringify`, `devalue`, or any other\n * serialiser before embedding in your SSR payload.\n */\nexport type SerializedAttaformState = {\n  /** Tuples of `[formKey, snapshot]` for every form in the app. */\n  readonly forms: ReadonlyArray<readonly [FormKey, SerializedFormData]>\n}\n\n/**\n * Snapshot every form on a Vue app for SSR. Call from your server\n * entry after rendering the app:\n *\n * ```ts\n * import { renderToString } from '@vue/server-renderer'\n * import { renderAttaformState, escapeForInlineScript } from 'attaform'\n *\n * const html = await renderToString(app)\n * const state = renderAttaformState(app)\n * const payload = escapeForInlineScript(JSON.stringify(state))\n *\n * return `\n *   ${html}\n *   <script>window.__ATTAFORM_STATE__ = ${payload}</script>\n * `\n * ```\n *\n * Pair with `hydrateAttaformState` on the client to restore the\n * forms in their server-rendered state. Nuxt users don't need this —\n * `attaform/nuxt` wires SSR automatically.\n */\nexport function renderAttaformState(app: App): SerializedAttaformState {\n  const registry = getRegistryFromApp(app)\n  const forms: Array<readonly [FormKey, SerializedFormData]> = []\n  for (const [key, state] of registry.forms) {\n    // Skip the blank field when the set is empty so the\n    // wire payload stays minimal for forms that don't use it. The\n    // optional shape on the consuming side handles the absence\n    // cleanly (defaults to \"no blank paths\"). PathKey → dotted at\n    // the boundary so the wire shape matches the rest of the\n    // public path notation.\n    const transientList: string[] = []\n    for (const pk of state.blankPaths) {\n      const d = pathKeyToDotted(pk as PathKey)\n      if (d !== null) transientList.push(d)\n    }\n    forms.push([\n      key,\n      {\n        form: state.form.value,\n        schemaErrors: Array.from(state.schemaErrors.entries()),\n        userErrors: Array.from(state.userErrors.entries()),\n        fields: Array.from(state.fields.entries()),\n        ...(transientList.length > 0 ? { blankPaths: transientList } : {}),\n      },\n    ])\n  }\n  return { forms }\n}\n\n/**\n * Restore forms from a server-rendered snapshot on the client. Call\n * from your client entry before mounting:\n *\n * ```ts\n * import { createApp } from 'vue'\n * import { createAttaform, hydrateAttaformState } from 'attaform'\n *\n * const app = createApp(App).use(createAttaform())\n * hydrateAttaformState(app, window.__ATTAFORM_STATE__)\n * app.mount('#app')\n * ```\n *\n * The next `useForm({ key })` call for each serialised form picks up\n * the snapshot transparently — no further action is required.\n */\nexport function hydrateAttaformState(app: App, payload: SerializedAttaformState): void {\n  const registry = getRegistryFromApp(app)\n  for (const [key, data] of payload.forms) {\n    registry.pendingHydration.set(key, data)\n  }\n}\n","/**\n * Shared building blocks for Attaform's two devtools surfaces — the Vue\n * DevTools (Chrome-extension) inspector wired up in `./devtools.ts`, and\n * the Nuxt DevTools (overlay) panel wired up via `../../nuxt.ts` +\n * `../pages/_attaform_devtools.vue`.\n *\n * Houses the window-bridge contract both surfaces consume so a new\n * bridge field lands in one file. Both surfaces render RAW form values\n * by design — DevTools is a dev-only surface, and redaction across every\n * place a value surfaces is impractical security theater rather than a\n * real safeguard.\n */\nimport type { AttaformRegistry } from './registry'\n\n/**\n * Property key on `window` that the Nuxt-side dev plugin attaches the\n * bridge object to. The iframe-mounted overlay panel reads\n * `window.parent[DEVTOOLS_WINDOW_KEY]` to reach the host app's registry.\n *\n * Underscored + namespaced to make accidental collision with consumer\n * globals vanishingly unlikely. Stable across versions — bumping it\n * would silently disconnect older library builds from newer overlay\n * panels in the same browser tab during a library upgrade.\n */\nexport const DEVTOOLS_WINDOW_KEY = '__attaform_devtools__'\n\n/**\n * Shape of the object the host plugin attaches to `window` in dev mode.\n * The iframe overlay panel reads this to discover the live registry and\n * render its forms.\n *\n * Single-registry assumption: the latest `createAttaform()` install\n * wins. Multi-app pages (rare; typically only seen in micro-frontend\n * setups) will only see one app's forms in the panel. Documented but\n * not actively supported — the alternative (a Set of registries with\n * union-rendering) is a future call if a real consumer hits it.\n */\nexport interface AttaformDevtoolsBridge {\n  registry: AttaformRegistry\n  /**\n   * The library version, surfaced in the panel's footer for support /\n   * bug-report context. Read from `package.json` at host-plugin init.\n   */\n  version: string\n}\n\ndeclare global {\n  interface Window {\n    [DEVTOOLS_WINDOW_KEY]?: AttaformDevtoolsBridge\n  }\n}\n"],"names":[],"mappings":";;AAuCO,SAAS,oBAAoB,GAAA,EAAmC;AACrE,EAAA,MAAM,QAAA,GAAW,mBAAmB,GAAG,CAAA;AACvC,EAAA,MAAM,QAAuD,EAAC;AAC9D,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,SAAS,KAAA,EAAO;AAOzC,IAAA,MAAM,gBAA0B,EAAC;AACjC,IAAA,KAAA,MAAW,EAAA,IAAM,MAAM,UAAA,EAAY;AACjC,MAAA,MAAM,CAAA,GAAI,gBAAgB,EAAa,CAAA;AACvC,MAAA,IAAI,CAAA,KAAM,IAAA,EAAM,aAAA,CAAc,IAAA,CAAK,CAAC,CAAA;AAAA,IACtC;AACA,IAAA,KAAA,CAAM,IAAA,CAAK;AAAA,MACT,GAAA;AAAA,MACA;AAAA,QACE,IAAA,EAAM,MAAM,IAAA,CAAK,KAAA;AAAA,QACjB,cAAc,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,YAAA,CAAa,SAAS,CAAA;AAAA,QACrD,YAAY,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,SAAS,CAAA;AAAA,QACjD,QAAQ,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,SAAS,CAAA;AAAA,QACzC,GAAI,cAAc,MAAA,GAAS,CAAA,GAAI,EAAE,UAAA,EAAY,aAAA,KAAkB;AAAC;AAClE,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,EAAE,KAAA,EAAM;AACjB;AAkBO,SAAS,oBAAA,CAAqB,KAAU,OAAA,EAAwC;AACrF,EAAA,MAAM,QAAA,GAAW,mBAAmB,GAAG,CAAA;AACvC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,QAAQ,KAAA,EAAO;AACvC,IAAA,QAAA,CAAS,gBAAA,CAAiB,GAAA,CAAI,GAAA,EAAK,IAAI,CAAA;AAAA,EACzC;AACF;;ACjEO,MAAM,mBAAA,GAAsB;;;;"}

package/dist/shared/{attaform.QvygsFGh.d.cts → attaform.GbDo_lJi.d.cts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.C0uGZQ4M.cjs';
+import { G as GenericForm, q as FlatPath, B as NestedType, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType } from './attaform.SfhU0OEY.cjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.