attaform 0.19.0 → 0.20.1

package/dist/zod-v3.d.mts

@@ -1,10 +1,24 @@
 import { z } from 'zod';
-import { G as GenericForm, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, aj as UseFormReturnType, a9 as SchemaFactoryOptions, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.mjs';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.mjs';
-import { U as UnwrapZodObject, a as UseFormConfigurationWithZod, S as StorageShape } from './shared/attaform.DXYHL99q.mjs';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BtBmfLQN.mjs';
+import { G as GenericForm, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, aj as UseFormReturnType, al as ValidateOnConfig, a9 as SchemaFactoryOptions, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.mjs';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.mjs';
+import { U as UnwrapZodObject, S as StorageShape } from './shared/attaform.DSD85fHb.mjs';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.EMzJcQci.mjs';
 import 'vue';
 
+/**
+ * `FormOf` / `OutOf` / `ReadOf` factor the three identical-shape
+ * conditionals out of the zod-typed `useForm` signature. The bundled
+ * `.d.ts` then carries one alias per shape rather than re-inlining
+ * `z.input<UnwrapZodObject<Schema>> extends GenericForm ? … : never`
+ * four times — the pattern that produces TS2589 ("Type instantiation
+ * is excessively deep") on consumer call sites with complex schemas
+ * (discriminated unions, refines, deep `.register()` chains). Mirrors
+ * the v4 adapter's own `FormOf`/`OutOf`/`ReadOf` aliases verbatim so
+ * v3 and v4 carry the same per-call depth cost.
+ */
+type FormOf<Schema extends z.ZodObject<z.ZodRawShape>> = z.input<UnwrapZodObject<Schema>> extends GenericForm ? z.input<UnwrapZodObject<Schema>> : never;
+type OutOf<Schema extends z.ZodObject<z.ZodRawShape>> = z.output<UnwrapZodObject<Schema>> extends GenericForm ? z.output<UnwrapZodObject<Schema>> : never;
+type ReadOf<Schema extends z.ZodObject<z.ZodRawShape>> = StorageShape<UnwrapZodObject<Schema>> extends GenericForm ? StorageShape<UnwrapZodObject<Schema>> : never;
 /**
  * Create a form bound to a custom `AbstractSchema` adapter.
  *
@@ -43,7 +57,9 @@ declare function useForm<Form extends GenericForm, GetValueFormType extends Gene
  *
  * For Zod v4, import from `attaform/zod` instead.
  */
-declare function useForm<Schema extends z.ZodObject<z.ZodRawShape>, GetValueFormType extends GenericForm = z.output<UnwrapZodObject<Schema>> extends GenericForm ? z.output<UnwrapZodObject<Schema>> : never, K extends FormKey = FormKey>(configuration: UseFormConfigurationWithZod<Schema, DefaultValuesInput<z.input<UnwrapZodObject<Schema>>>, K>): UseFormReturnType<z.input<UnwrapZodObject<Schema>>, GetValueFormType, StorageShape<UnwrapZodObject<Schema>> extends GenericForm ? StorageShape<UnwrapZodObject<Schema>> : never, K>;
+declare function useForm<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+    schema: Schema;
+} & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 /**
  * Narrow accessor type for Zod v3's internal `_def`. Only useful
@@ -117,6 +133,11 @@ type ZodTypeMap = {
     ZodIntersection: z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>;
     ZodLazy: z.ZodLazy<z.ZodTypeAny>;
     ZodNativeEnum: z.ZodNativeEnum<z.EnumLike>;
+    ZodNaN: z.ZodNaN;
+    ZodVoid: z.ZodVoid;
+    ZodAny: z.ZodAny;
+    ZodUnknown: z.ZodUnknown;
+    ZodNever: z.ZodNever;
 };
 /**
  * Type guard for a Zod v3 schema kind. Returns `true` when `schema`
@@ -182,6 +203,11 @@ type FieldMetaRegistryV3 = {
     get(schema: z.ZodTypeAny): FieldMetaPayload | undefined;
     /** True iff a payload has been registered for the schema. */
     has(schema: z.ZodTypeAny): boolean;
+    /**
+     * Drop every registered payload for `schema`. Returns the registry
+     * for chaining; idempotent on a never-registered schema.
+     */
+    remove(schema: z.ZodTypeAny): FieldMetaRegistryV3;
 };
 declare const fieldMeta: FieldMetaRegistryV3;
 /**
@@ -212,5 +238,5 @@ declare const fieldMeta: FieldMetaRegistryV3;
  */
 declare function withMeta<S extends z.ZodTypeAny>(schema: S, payload: FieldMetaPayload): S;
 
-export { FieldMetaPayload, UnwrapZodObject, UseFormConfigurationWithZod, fieldMeta, isZodSchemaType, useForm, withMeta, zodAdapter };
+export { FieldMetaPayload, UnwrapZodObject, fieldMeta, isZodSchemaType, useForm, withMeta, zodAdapter };
 export type { TypeWithNullableDynamicKeys, ZodTypeWithInnerType };

package/dist/zod-v3.d.ts

@@ -1,10 +1,24 @@
 import { z } from 'zod';
-import { G as GenericForm, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, aj as UseFormReturnType, a9 as SchemaFactoryOptions, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.js';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.js';
-import { U as UnwrapZodObject, a as UseFormConfigurationWithZod, S as StorageShape } from './shared/attaform.D4I63aBV.js';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BTpuvGec.js';
+import { G as GenericForm, t as FormKey, ai as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, aj as UseFormReturnType, al as ValidateOnConfig, a9 as SchemaFactoryOptions, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.js';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.js';
+import { U as UnwrapZodObject, S as StorageShape } from './shared/attaform.DSD85fHb.js';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.Bh3ACtts.js';
 import 'vue';
 
+/**
+ * `FormOf` / `OutOf` / `ReadOf` factor the three identical-shape
+ * conditionals out of the zod-typed `useForm` signature. The bundled
+ * `.d.ts` then carries one alias per shape rather than re-inlining
+ * `z.input<UnwrapZodObject<Schema>> extends GenericForm ? … : never`
+ * four times — the pattern that produces TS2589 ("Type instantiation
+ * is excessively deep") on consumer call sites with complex schemas
+ * (discriminated unions, refines, deep `.register()` chains). Mirrors
+ * the v4 adapter's own `FormOf`/`OutOf`/`ReadOf` aliases verbatim so
+ * v3 and v4 carry the same per-call depth cost.
+ */
+type FormOf<Schema extends z.ZodObject<z.ZodRawShape>> = z.input<UnwrapZodObject<Schema>> extends GenericForm ? z.input<UnwrapZodObject<Schema>> : never;
+type OutOf<Schema extends z.ZodObject<z.ZodRawShape>> = z.output<UnwrapZodObject<Schema>> extends GenericForm ? z.output<UnwrapZodObject<Schema>> : never;
+type ReadOf<Schema extends z.ZodObject<z.ZodRawShape>> = StorageShape<UnwrapZodObject<Schema>> extends GenericForm ? StorageShape<UnwrapZodObject<Schema>> : never;
 /**
  * Create a form bound to a custom `AbstractSchema` adapter.
  *
@@ -43,7 +57,9 @@ declare function useForm<Form extends GenericForm, GetValueFormType extends Gene
  *
  * For Zod v4, import from `attaform/zod` instead.
  */
-declare function useForm<Schema extends z.ZodObject<z.ZodRawShape>, GetValueFormType extends GenericForm = z.output<UnwrapZodObject<Schema>> extends GenericForm ? z.output<UnwrapZodObject<Schema>> : never, K extends FormKey = FormKey>(configuration: UseFormConfigurationWithZod<Schema, DefaultValuesInput<z.input<UnwrapZodObject<Schema>>>, K>): UseFormReturnType<z.input<UnwrapZodObject<Schema>>, GetValueFormType, StorageShape<UnwrapZodObject<Schema>> extends GenericForm ? StorageShape<UnwrapZodObject<Schema>> : never, K>;
+declare function useForm<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+    schema: Schema;
+} & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 /**
  * Narrow accessor type for Zod v3's internal `_def`. Only useful
@@ -117,6 +133,11 @@ type ZodTypeMap = {
     ZodIntersection: z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>;
     ZodLazy: z.ZodLazy<z.ZodTypeAny>;
     ZodNativeEnum: z.ZodNativeEnum<z.EnumLike>;
+    ZodNaN: z.ZodNaN;
+    ZodVoid: z.ZodVoid;
+    ZodAny: z.ZodAny;
+    ZodUnknown: z.ZodUnknown;
+    ZodNever: z.ZodNever;
 };
 /**
  * Type guard for a Zod v3 schema kind. Returns `true` when `schema`
@@ -182,6 +203,11 @@ type FieldMetaRegistryV3 = {
     get(schema: z.ZodTypeAny): FieldMetaPayload | undefined;
     /** True iff a payload has been registered for the schema. */
     has(schema: z.ZodTypeAny): boolean;
+    /**
+     * Drop every registered payload for `schema`. Returns the registry
+     * for chaining; idempotent on a never-registered schema.
+     */
+    remove(schema: z.ZodTypeAny): FieldMetaRegistryV3;
 };
 declare const fieldMeta: FieldMetaRegistryV3;
 /**
@@ -212,5 +238,5 @@ declare const fieldMeta: FieldMetaRegistryV3;
  */
 declare function withMeta<S extends z.ZodTypeAny>(schema: S, payload: FieldMetaPayload): S;
 
-export { FieldMetaPayload, UnwrapZodObject, UseFormConfigurationWithZod, fieldMeta, isZodSchemaType, useForm, withMeta, zodAdapter };
+export { FieldMetaPayload, UnwrapZodObject, fieldMeta, isZodSchemaType, useForm, withMeta, zodAdapter };
 export type { TypeWithNullableDynamicKeys, ZodTypeWithInnerType };

package/dist/zod-v3.mjs

@@ -1,4 +1,4 @@
-export { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.CiMqJHDm.mjs';
-export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, m as useWizard } from './shared/attaform.BTi-PsHr.mjs';
-export { J as useRegister } from './shared/attaform.CrpjyXdO.mjs';
+export { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.D6CwqkPx.mjs';
+export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, p as useWizard } from './shared/attaform.BqZuwLTK.mjs';
+export { G as useRegister } from './shared/attaform.BKozEdTr.mjs';
 //# sourceMappingURL=zod-v3.mjs.map

package/dist/zod-v4.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-const index = require('./shared/attaform.JBx8cfMA.cjs');
-const injectWizard = require('./shared/attaform.C1msmO2v.cjs');
-const paths = require('./shared/attaform.BqEfHpVB.cjs');
+const index = require('./shared/attaform.BrrXNmfK.cjs');
+const injectWizard = require('./shared/attaform.DLnE5bZa.cjs');
+const paths = require('./shared/attaform.BPy-4qRx.cjs');
 
 
 

package/dist/zod-v4.d.cts

@@ -1,9 +1,9 @@
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.QvygsFGh.cjs';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.ePUcKxId.cjs';
-import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.cjs';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.cjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.GbDo_lJi.cjs';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.D5-1XGQU.cjs';
+import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.cjs';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.cjs';
 import { z } from 'zod';
-import { a as AttaformError } from './shared/attaform.B7rzpK1U.cjs';
+import { a as AttaformError } from './shared/attaform.DkA5J8NW.cjs';
 import 'vue';
 
 /**
@@ -29,11 +29,15 @@ declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.inp
 
 /**
  * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * represent: `z.promise`, `z.custom`, or `z.templateLiteral`.
  *
  * The error message includes the dotted path of the offending node
  * so you can locate it without traversing the whole schema.
+ *
+ * Recursive `z.lazy(...)` is supported, not unsupported: the
+ * construction-time walk stops descending on the second encounter
+ * of the same getter, and downstream walks cap their descent via
+ * `maxRecursionDepth`.
  */
 declare class UnsupportedSchemaError extends AttaformError {
 }
@@ -54,7 +58,7 @@ declare class UnsupportedSchemaError extends AttaformError {
  * `kindOf(schema)`. Use when building a custom integration that
  * needs to branch on schema shape — most consumers don't need this.
  */
-type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file';
+type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file' | 'map' | 'symbol' | 'function';
 /**
  * Inspect a Zod v4 schema and return its `ZodKind`. Returns
  * `'unknown'` for non-Zod inputs and unrecognised shapes.

package/dist/zod-v4.d.mts

@@ -1,9 +1,9 @@
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.CRNA0vrd.mjs';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BtBmfLQN.mjs';
-import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.mjs';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.mjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.DoKXru-a.mjs';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.EMzJcQci.mjs';
+import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.mjs';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.mjs';
 import { z } from 'zod';
-import { a as AttaformError } from './shared/attaform.B7rzpK1U.mjs';
+import { a as AttaformError } from './shared/attaform.DkA5J8NW.mjs';
 import 'vue';
 
 /**
@@ -29,11 +29,15 @@ declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.inp
 
 /**
  * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * represent: `z.promise`, `z.custom`, or `z.templateLiteral`.
  *
  * The error message includes the dotted path of the offending node
  * so you can locate it without traversing the whole schema.
+ *
+ * Recursive `z.lazy(...)` is supported, not unsupported: the
+ * construction-time walk stops descending on the second encounter
+ * of the same getter, and downstream walks cap their descent via
+ * `maxRecursionDepth`.
  */
 declare class UnsupportedSchemaError extends AttaformError {
 }
@@ -54,7 +58,7 @@ declare class UnsupportedSchemaError extends AttaformError {
  * `kindOf(schema)`. Use when building a custom integration that
  * needs to branch on schema shape — most consumers don't need this.
  */
-type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file';
+type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file' | 'map' | 'symbol' | 'function';
 /**
  * Inspect a Zod v4 schema and return its `ZodKind`. Returns
  * `'unknown'` for non-Zod inputs and unrecognised shapes.

package/dist/zod-v4.d.ts

@@ -1,9 +1,9 @@
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.CJ-e9gYI.js';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BTpuvGec.js';
-import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.js';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.js';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.Dl5kDY-A.js';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.Bh3ACtts.js';
+import { t as FormKey, a9 as SchemaFactoryOptions, A as AbstractSchema, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.js';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.js';
 import { z } from 'zod';
-import { a as AttaformError } from './shared/attaform.B7rzpK1U.js';
+import { a as AttaformError } from './shared/attaform.DkA5J8NW.js';
 import 'vue';
 
 /**
@@ -29,11 +29,15 @@ declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.inp
 
 /**
  * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * represent: `z.promise`, `z.custom`, or `z.templateLiteral`.
  *
  * The error message includes the dotted path of the offending node
  * so you can locate it without traversing the whole schema.
+ *
+ * Recursive `z.lazy(...)` is supported, not unsupported: the
+ * construction-time walk stops descending on the second encounter
+ * of the same getter, and downstream walks cap their descent via
+ * `maxRecursionDepth`.
  */
 declare class UnsupportedSchemaError extends AttaformError {
 }
@@ -54,7 +58,7 @@ declare class UnsupportedSchemaError extends AttaformError {
  * `kindOf(schema)`. Use when building a custom integration that
  * needs to branch on schema shape — most consumers don't need this.
  */
-type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file';
+type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file' | 'map' | 'symbol' | 'function';
 /**
  * Inspect a Zod v4 schema and return its `ZodKind`. Returns
  * `'unknown'` for non-Zod inputs and unrecognised shapes.

package/dist/zod-v4.mjs

@@ -1,4 +1,4 @@
-export { U as UnsupportedSchemaError, a as assertZodVersion, f as fieldMeta, k as kindOf, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.a3uBo-gw.mjs';
-export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, m as useWizard } from './shared/attaform.BTi-PsHr.mjs';
-export { J as useRegister } from './shared/attaform.CrpjyXdO.mjs';
+export { U as UnsupportedSchemaError, a as assertZodVersion, f as fieldMeta, k as kindOf, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.iWo9soNX.mjs';
+export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, p as useWizard } from './shared/attaform.BqZuwLTK.mjs';
+export { G as useRegister } from './shared/attaform.BKozEdTr.mjs';
 //# sourceMappingURL=zod-v4.mjs.map

package/dist/zod.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-const paths = require('./shared/attaform.BqEfHpVB.cjs');
-const useForm$1 = require('./shared/attaform.OznWyOPy.cjs');
-const index = require('./shared/attaform.JBx8cfMA.cjs');
-const injectWizard = require('./shared/attaform.C1msmO2v.cjs');
-const fieldMetaStore = require('./shared/attaform.C8CyvYa_.cjs');
+const paths = require('./shared/attaform.BPy-4qRx.cjs');
+const useForm$1 = require('./shared/attaform.BCBxTyMC.cjs');
+const index = require('./shared/attaform.BrrXNmfK.cjs');
+const walkSlimPrimitives = require('./shared/attaform.DHRWn-cu.cjs');
+const injectWizard = require('./shared/attaform.DLnE5bZa.cjs');
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -24,12 +24,12 @@ function useForm(configuration) {
   return useForm$1.useForm(configuration);
 }
 
-const fieldMeta = fieldMetaStore.fieldMetaStore;
+const fieldMeta = walkSlimPrimitives.fieldMetaStore;
 function withMeta(schema, payload) {
   const target = schema;
-  const existing = fieldMetaStore.getFieldMetaForSchema(target) ?? {};
+  const existing = walkSlimPrimitives.getFieldMetaForSchema(target) ?? {};
   const cloned = cloneSchema(schema);
-  fieldMetaStore.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  walkSlimPrimitives.fieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function cloneSchema(schema) {

package/dist/zod.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"zod.cjs","sources":["../src/runtime/core/zod-shape.ts","../src/runtime/adapters/unified/use-form.ts","../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport type { z } from 'zod'\nimport type { z as zV3 } from 'zod-v3'\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type { StorageShape as StorageShapeV4 } from '../zod-v4/types-storage-shape'\nimport type { StorageShape as StorageShapeV3 } from '../zod-v3/types-storage-shape'\nimport type { UnwrapZodObject } from '../zod-v3/types-zod-adapter'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { DefaultValuesInput, GenericForm } from '../../types/types-core'\n\n// ───────────────────────────────────────────────────────────────────\n// Per-major projection helpers. Each overload's constraint scopes the\n// Schema to one Zod major, so the projection is a direct read — no\n// dispatch in the type body. Mirrors the direct adapter shapes so the\n// unified entry pays the same per-call depth cost as a direct import.\n// ───────────────────────────────────────────────────────────────────\n\ntype V4FormOf<S extends z.ZodObject> = z.input<S> extends GenericForm ? z.input<S> : never\ntype V4OutOf<S extends z.ZodObject> = z.output<S> extends GenericForm ? z.output<S> : never\ntype V4ReadOf<S extends z.ZodObject> =\n  StorageShapeV4<S> extends GenericForm ? StorageShapeV4<S> : never\n\ntype V3FormOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  zV3.input<UnwrapZodObject<S>> extends GenericForm ? zV3.input<UnwrapZodObject<S>> : never\ntype V3OutOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  zV3.output<UnwrapZodObject<S>> extends GenericForm ? zV3.output<UnwrapZodObject<S>> : never\ntype V3ReadOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  StorageShapeV3<UnwrapZodObject<S>> extends GenericForm\n    ? StorageShapeV3<UnwrapZodObject<S>>\n    : never\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v4 schemas match this overload first via their structural `def`\n * field. v3 schemas fall through to the v3 overload below.\n */\nexport function useForm<Schema extends z.ZodObject, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      DefaultValuesInput<V4FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends zV3.ZodObject<zV3.ZodRawShape>, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      DefaultValuesInput<V3FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["InvalidUseFormConfigError","useFormV4","useFormV3","fieldMetaStore","getFieldMetaForSchema"],"mappings":";;;;;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACwFO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,+BAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,kBAAU,aAAgD,CAAA;AACnE;;AC9GO,MAAM,SAAA,GAAYC;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAWC,oCAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAAD,6BAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;;;;;;;;;;;"}
+{"version":3,"file":"zod.cjs","sources":["../src/runtime/core/zod-shape.ts","../src/runtime/adapters/unified/use-form.ts","../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport type { z } from 'zod'\nimport type { z as zV3 } from 'zod-v3'\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type { StorageShape as StorageShapeV4 } from '../zod-v4/types-storage-shape'\nimport type { StorageShape as StorageShapeV3 } from '../zod-v3/types-storage-shape'\nimport type { UnwrapZodObject } from '../zod-v3/types-zod-adapter'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { DefaultValuesInput, GenericForm } from '../../types/types-core'\n\n// ───────────────────────────────────────────────────────────────────\n// Per-major projection helpers. Each overload's constraint scopes the\n// Schema to one Zod major, so the projection is a direct read — no\n// dispatch in the type body. Mirrors the direct adapter shapes so the\n// unified entry pays the same per-call depth cost as a direct import.\n// ───────────────────────────────────────────────────────────────────\n\ntype V4FormOf<S extends z.ZodObject> = z.input<S> extends GenericForm ? z.input<S> : never\ntype V4OutOf<S extends z.ZodObject> = z.output<S> extends GenericForm ? z.output<S> : never\ntype V4ReadOf<S extends z.ZodObject> =\n  StorageShapeV4<S> extends GenericForm ? StorageShapeV4<S> : never\n\ntype V3FormOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  zV3.input<UnwrapZodObject<S>> extends GenericForm ? zV3.input<UnwrapZodObject<S>> : never\ntype V3OutOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  zV3.output<UnwrapZodObject<S>> extends GenericForm ? zV3.output<UnwrapZodObject<S>> : never\ntype V3ReadOf<S extends zV3.ZodObject<zV3.ZodRawShape>> =\n  StorageShapeV3<UnwrapZodObject<S>> extends GenericForm\n    ? StorageShapeV3<UnwrapZodObject<S>>\n    : never\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v4 schemas match this overload first via their structural `def`\n * field. v3 schemas fall through to the v3 overload below.\n */\nexport function useForm<Schema extends z.ZodObject, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      DefaultValuesInput<V4FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends zV3.ZodObject<zV3.ZodRawShape>, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      DefaultValuesInput<V3FormOf<Schema>>,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["InvalidUseFormConfigError","useFormV4","useFormV3","fieldMetaStore","getFieldMetaForSchema"],"mappings":";;;;;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACwFO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,+BAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,kBAAU,aAAgD,CAAA;AACnE;;AC9GO,MAAM,SAAA,GAAYC;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAWC,wCAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAAD,iCAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;;;;;;;;;;;"}

package/dist/zod.d.cts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { S as StorageShape } from './shared/attaform.QvygsFGh.cjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.QvygsFGh.cjs';
-import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.CBjmobqk.cjs';
-import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.cjs';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.cjs';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.ePUcKxId.cjs';
+import { S as StorageShape } from './shared/attaform.GbDo_lJi.cjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.GbDo_lJi.cjs';
+import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.DSD85fHb.cjs';
+import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.cjs';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.cjs';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.D5-1XGQU.cjs';
 import 'vue';
 
 /**

package/dist/zod.d.mts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { S as StorageShape } from './shared/attaform.CRNA0vrd.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.CRNA0vrd.mjs';
-import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.DXYHL99q.mjs';
-import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.mjs';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.mjs';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BtBmfLQN.mjs';
+import { S as StorageShape } from './shared/attaform.DoKXru-a.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.DoKXru-a.mjs';
+import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.DSD85fHb.mjs';
+import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.mjs';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.mjs';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.EMzJcQci.mjs';
 import 'vue';
 
 /**

package/dist/zod.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { S as StorageShape } from './shared/attaform.CJ-e9gYI.js';
-export { P as PathInput, a as PathOutput } from './shared/attaform.CJ-e9gYI.js';
-import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.D4I63aBV.js';
-import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.C0uGZQ4M.js';
-export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.C0uGZQ4M.js';
-export { A as AggregateError, a as AnyForm, b as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, e as StepSlot, U as UseRegisterReturn, f as UseWizardReturnType, W as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.BTpuvGec.js';
+import { S as StorageShape } from './shared/attaform.Dl5kDY-A.js';
+export { P as PathInput, a as PathOutput } from './shared/attaform.Dl5kDY-A.js';
+import { U as UnwrapZodObject, S as StorageShape$1 } from './shared/attaform.DSD85fHb.js';
+import { t as FormKey, ai as UseFormConfiguration, G as GenericForm, A as AbstractSchema, j as DefaultValuesInput, al as ValidateOnConfig, aj as UseFormReturnType, F as FieldMetaPayload } from './shared/attaform.SfhU0OEY.js';
+export { ah as Unset, au as isUnset, aw as unset } from './shared/attaform.SfhU0OEY.js';
+export { A as AnyForm, a as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.Bh3ACtts.js';
 import 'vue';
 
 /**

package/dist/zod.mjs

@@ -1,9 +1,9 @@
-import { c as InvalidUseFormConfigError } from './shared/attaform.CrpjyXdO.mjs';
-export { J as useRegister } from './shared/attaform.CrpjyXdO.mjs';
-import { u as useForm$2 } from './shared/attaform.CiMqJHDm.mjs';
-import { u as useForm$1 } from './shared/attaform.a3uBo-gw.mjs';
-export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, m as useWizard } from './shared/attaform.BTi-PsHr.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.D13GMFgK.mjs';
+import { d as InvalidUseFormConfigError } from './shared/attaform.BKozEdTr.mjs';
+export { G as useRegister } from './shared/attaform.BKozEdTr.mjs';
+import { u as useForm$2 } from './shared/attaform.D6CwqkPx.mjs';
+import { u as useForm$1 } from './shared/attaform.iWo9soNX.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.tVkmQh5w.mjs';
+export { A as AttaformErrorCode, i as injectForm, c as injectWizard, f as isUnset, l as lazy, u as unset, p as useWizard } from './shared/attaform.BqZuwLTK.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attaform",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [
@@ -115,6 +115,7 @@
     "changelogen": "^0.6.2",
     "cheerio": "^1.2.0",
     "chokidar-cli": "^3.0.0",
+    "devalue": "^5.8.1",
     "eslint": "^10.2.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",