attaform 0.30.0 → 0.31.0

package/dist/zod-v3.d.mts

@@ -1,22 +1,21 @@
 import { z } from 'zod';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, aq as AcceptableDefaults, a as UseFormReturnType, ac as ValidateOnConfig, ap as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.bKLzMU0o.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, ap as AcceptableDefaults, a as UseFormReturnType, ab as ValidateOnConfig, ao as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.DZnrDrNb.mjs';
 import { AbstractSchema } from './abstract.mjs';
-export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, ab as ValidateOn, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.bKLzMU0o.mjs';
-import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.DRUT703x.mjs';
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.UGyOK83T.mjs';
-export { v as vRegister } from './shared/attaform.Clz0ArIi.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaParseErrorWithData, a0 as SchemaParseErrorWithoutData, a1 as SchemaParseResult, a2 as SchemaParseSuccess, a3 as Segment, a4 as SetValueCallback, a5 as SetValuePayload, a6 as SettledValidationStatus, a7 as SlimPrimitiveKind, a8 as SubmitHandler, a9 as Unset, aa as ValidateOn, ac as ValidationError, ad as ValidationResponse, ae as ValidationResponseWithoutValue, af as ValueOfUnion, ag as WriteMeta, ah as WriteShape, ai as canonicalizePath, aj as isPathPrefix, ak as isUnset, al as parseDottedPath, am as unset } from './shared/attaform.DZnrDrNb.mjs';
+import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.B-Tb62qV.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.DAo0QBmS.mjs';
+export { v as vRegister } from './shared/attaform.D9RqPgGu.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.
+ * Factor the three identical-shape conditionals out of the zod-typed
+ * `useForm` signature, so the bundled `.d.ts` carries one alias per
+ * shape instead of re-inlining `z.input<UnwrapZodRoot<Schema>> extends
+ * GenericForm ? ... : never` four times. That inlining is what produces
+ * TS2589 ("Type instantiation is excessively deep") at a consumer call
+ * site holding a discriminated union, a refine, or a deep `.register()`
+ * chain. The v4 adapter declares the same three aliases, so both lines
+ * carry the same per-call depth cost.
  */
 type FormOf<Schema extends SupportedRootSchema> = z.input<UnwrapZodRoot<Schema>> extends GenericForm ? z.input<UnwrapZodRoot<Schema>> : never;
 type OutOf<Schema extends SupportedRootSchema> = z.output<UnwrapZodRoot<Schema>> extends GenericForm ? z.output<UnwrapZodRoot<Schema>> : never;
@@ -27,39 +26,39 @@ type ReadOf<Schema extends SupportedRootSchema> = StorageShape<UnwrapZodRoot<Sch
  * ```ts
  * import { useForm } from 'attaform/zod-v3'
  *
- * const form = useForm({ schema: myAdapter, defaultValues: { … } })
+ * const form = useForm({ schema: myAdapter, defaultValues: { name: '' } })
  * ```
  *
- * For Zod schemas, prefer the overload that accepts a `ZodObject`
- * directly — it wraps the adapter automatically. For Zod v4, import
- * from `attaform/zod` instead.
+ * For a Zod schema, prefer the overload that takes the schema directly:
+ * it attaches the adapter for you. For Zod v4, import from
+ * `attaform/zod`.
  */
 declare function useForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<Form, GetValueFormType, AbstractSchema<Form, GetValueFormType>, never, K>, 'defaultValues'> & {
     defaultValues?: AcceptableDefaults<Form, Form>;
 }): UseFormReturnType<Form, GetValueFormType, Form, K>;
 /**
- * Create a form bound to a Zod v3 `ZodObject` schema.
+ * Create a form bound to a Zod v3 schema.
  *
  * ```ts
  * import { useForm } from 'attaform/zod-v3'
  * import { z } from 'zod'
  *
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ * })
+ *
  * const form = useForm({
- *   schema: z.object({
- *     email: z.string().email(),
- *     password: z.string().min(8),
- *   }),
+ *   schema,
  *   defaultValues: { email: '' },
  *   validateOn: 'blur',
  * })
  * ```
  *
- * Returns a form API exposing `register`, `values`, `errors`,
- * `fields`, `setValue`, `handleSubmit`, `meta`, field-array
- * helpers, and more. See `UseFormReturnType` for the full
- * surface.
- *
- * For Zod v4, import from `attaform/zod` instead.
+ * The returned form carries `register`, `values`, `errors`, `fields`,
+ * `setValue`, `handleSubmit`, `meta` and the field-array helpers; see
+ * `UseFormReturnType` for the whole surface. For Zod v4, import from
+ * `attaform/zod`.
  */
 declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
@@ -78,9 +77,9 @@ interface ZodTypeWithInnerType extends z.ZodTypeAny {
     };
 }
 /**
- * The "honest read shape" of a Zod v3 schema — fields under records,
- * arrays, and dynamic boundaries are tagged optional/undefined to
- * reflect the runtime reality that those slots may be missing.
+ * The honest read shape of a Zod v3 schema: a field under a record, an
+ * array or a dynamic boundary is tagged optional or undefined, matching
+ * the runtime reality that the slot may be missing.
  *
  * Used internally by the v3 adapter as the read-side type for
  * `getValue` / `getFieldState`. Not commonly needed in consumer code.
@@ -95,15 +94,12 @@ type TypeWithNullableDynamicKeys<Schema extends z.ZodSchema, CrossedBoundary ext
 z.infer<Schema> | (CrossedBoundary extends true ? undefined : never);
 
 /**
- * Wrap a Zod v3 form-root schema (`ZodObject` or `ZodRecord`) in an
+ * Wrap a Zod v3 form-root schema, a `ZodObject` or `ZodRecord`, in an
  * `AbstractSchema` factory.
  *
- * Most consumers never call this directly — `useForm` from
- * `attaform/zod-v3` does the wrapping automatically. Reach
- * for it only when integrating with a custom code path that needs
- * the adapter outside of `useForm`.
- *
- * Throws if the underlying schema isn't a supported form root.
+ * `useForm` from `attaform/zod-v3` does this for you, so reach for it
+ * only to use the adapter outside `useForm`. Throws if the schema is not
+ * a supported form root.
  */
 declare function zodAdapter<FormSchema extends z.ZodSchema, Form extends z.input<FormSchema>, GetValueFormType extends TypeWithNullableDynamicKeys<FormSchema>>(zodSchema: FormSchema): (formKey: FormKey, options: SchemaFactoryOptions) => AbstractSchema<Form, GetValueFormType>;
 
@@ -163,44 +159,29 @@ type ZodTypeMap = {
 declare function isZodSchemaType<K extends keyof ZodTypeMap>(schema: unknown, expectedType: K): schema is ZodTypeMap[K];
 
 /**
- * Field-metadata write/read API for the Zod v3 adapter.
- *
- * Storage lives in the shared `field-meta-store` core — every entry
- * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) writes to and
- * reads from the same `WeakMap`s, so a payload registered via any
- * entry surfaces at lookup regardless of which adapter actually runs.
- *
- * Zod 3 has no `z.registry()` mechanism, so `fieldMeta` is the
- * shared registry-shaped object exposing `add` / `get` / `has` /
- * `remove`. The public `withMeta(schema, payload)` write API matches
- * `attaform/zod`'s so schema authoring reads identically across the
- * two adapters.
- *
- * **Registration patterns:** both styles work — register on whatever
- * schema reference you assign into the parent's shape, OR on the
- * inner schema before wrapping. The adapter's resolver tries the
- * walker-returned schema first, then falls back to the peeled
- * inner so either ordering hits:
- *
- *     // both equivalent — registry hits at lookup time
+ * Field-metadata write and read API for the Zod v3 adapter.
+ *
+ * Storage lives in the shared `core/field-meta-store`, where every entry
+ * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) reads and
+ * writes the same `WeakMap`s, so a payload registered through any of
+ * them surfaces at lookup whichever adapter runs.
+ *
+ * **Registration order does not matter.** Register on the schema
+ * reference assigned into the parent's shape, or on the inner schema
+ * before wrapping:
+ *
+ *     // equivalent; both hit at lookup time
  *     withMeta(z.string(), { label: 'Email' }).optional()
  *     withMeta(z.string().optional(), { label: 'Email' })
  *
- * The path walker returns the wrapper at terminal positions and
- * peels at intermediate descent. The two-stage lookup covers both
- * leaf and container registrations symmetrically.
+ * The path walker returns the wrapper at a terminal position and peels
+ * at intermediate descent, and the resolver tries the walker's schema
+ * before the peeled inner, so the two-stage lookup covers leaf and
+ * container registrations symmetrically.
  */
 
-/**
- * The shared registry every Attaform-aware Zod 3 schema can register
- * field metadata against. Backed by the cross-adapter store — a
- * payload registered here is visible to the v4 adapter and the
- * unified `attaform/zod` entry, and vice versa. Every `add` also
- * installs the path-walking resolver into the shared store's builder
- * slot, so the walk's bytes ride this module's import instead of the
- * adapter — a consumer that never registers metadata never ships the
- * walk.
- */
+/** The `add` / `get` / `has` / `remove` shape of `fieldMeta`, matching
+ *  Zod 4's `$ZodRegistry` closely enough to read the same either way. */
 type FieldMetaRegistryV3 = {
     /**
      * Register `payload` against `schema`. Returns the registry to
@@ -220,32 +201,45 @@ type FieldMetaRegistryV3 = {
      */
     remove(schema: z.ZodTypeAny): FieldMetaRegistryV3;
 };
+/**
+ * The shared registry an Attaform-aware Zod 3 schema registers field
+ * metadata against.
+ *
+ * ```ts
+ * import { fieldMeta } from 'attaform/zod-v3'
+ *
+ * const email = z.string().email()
+ * fieldMeta.add(email, { label: 'Email address' })
+ * ```
+ *
+ * It is backed by the cross-adapter store, so a payload registered here
+ * is visible to the v4 adapter and to the unified `attaform/zod` entry,
+ * and the reverse. Every `add` also installs the path-walking resolver
+ * into the shared store's builder slot, which is what makes the walk's
+ * bytes ride this module's import rather than the adapter: a consumer
+ * who never registers metadata never ships the walk.
+ */
 declare const fieldMeta: FieldMetaRegistryV3;
 /**
- * Attach `payload` to `schema` in the shared `fieldMeta` registry
- * and return a clone of `schema` (chainable, with the new metadata).
- * Cross-version with `attaform/zod`'s `withMeta()`.
- *
- * **Why clone, not mutate.** The shared store keys metadata on the
- * schema reference. Calling `withMeta` twice on the same instance
- * would overwrite (last-write-wins) — so a sub-schema reused at
- * multiple form paths (e.g. an address schema shared between pickup
- * and delivery) couldn't carry distinct metadata per path.
- *
- * `withMeta` sidesteps the footgun by reconstructing `schema` via
- * its constructor + `_def` — Zod 3 schemas don't expose `.clone()`,
- * but `new schema.constructor(schema._def)` is the equivalent. Each
- * call gets a fresh identity and a fresh registry slot. Existing
- * metadata on the original is merged through, so chaining
- * `withMeta` accumulates payload fields rather than replacing.
- *
- * Inner field schemas (e.g. an object's `.shape.city`) are shared
- * across clones — the def is held by reference — so leaf metadata
- * registers once and surfaces at every path.
- *
- * `schema.register()` does NOT exist on Zod 3 — `withMeta` is the
- * only fluent write API. Register on the inner schema before
- * wrapping; see the "Registration rule" note in this file's header.
+ * Attach `payload` to `schema` in the shared `fieldMeta` registry and
+ * return a chainable CLONE of `schema` carrying the new metadata. Zod 3
+ * has no `schema.register()`, so this is its only fluent write API, and
+ * it matches `attaform/zod`'s `withMeta()`.
+ *
+ * It clones rather than mutates because the store keys metadata on the
+ * schema reference: calling `withMeta` twice on one instance would
+ * overwrite last-write-wins, and a sub-schema reused at several paths,
+ * an address shared between pickup and delivery say, could then carry
+ * only one payload. Zod 3 exposes no `.clone()`, so the reconstruction
+ * goes through `new schema.constructor(schema._def)`. Each call gets a
+ * fresh identity and a fresh registry slot, and existing metadata merges
+ * through, so chaining accumulates payload fields rather than replacing
+ * them.
+ *
+ * An inner field schema, an object's `.shape.city` for instance, is
+ * shared across clones, the def being held by reference, so leaf
+ * metadata registers once and surfaces at every path. See this file's
+ * header for the two equivalent registration orderings.
  */
 declare function withMeta<S extends z.ZodTypeAny>(schema: S, payload: FieldMetaPayload): S;
 

package/dist/zod-v3.mjs

@@ -1,9 +1,9 @@
-export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform.CJ8DpRGj.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.CUfrMK7t.mjs';
+export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform.LUPC-2Qg.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.DL2nl_QR.mjs';
 export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.CdZIEf7_.mjs';
-export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNJOWjQw.mjs';
-export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.WiGdIqgx.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.B3resMQ1.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNPJPOO7.mjs';
+export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.C4shmwyJ.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DxKQsqFZ.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
 
 const fieldMeta = installingFieldMetaStore;

package/dist/zod-v4.d.mts

@@ -1,163 +1,165 @@
-import { S as SupportedRootSchema } from './shared/attaform.Rc9u4Vfw.mjs';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.Rc9u4Vfw.mjs';
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.UGyOK83T.mjs';
-import { F as FormKey, ap as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.bKLzMU0o.mjs';
+import { S as SupportedRootSchema } from './shared/attaform.CRVe8s82.mjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.CRVe8s82.mjs';
+import { F as FormKey, ao as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.DZnrDrNb.mjs';
 import { AbstractSchema } from './abstract.mjs';
-export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, U as UseFormConfiguration, a as UseFormReturnType, ab as ValidateOn, ac as ValidateOnConfig, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.bKLzMU0o.mjs';
-export { v as vRegister } from './shared/attaform.Clz0ArIi.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaParseErrorWithData, a0 as SchemaParseErrorWithoutData, a1 as SchemaParseResult, a2 as SchemaParseSuccess, a3 as Segment, a4 as SetValueCallback, a5 as SetValuePayload, a6 as SettledValidationStatus, a7 as SlimPrimitiveKind, a8 as SubmitHandler, a9 as Unset, U as UseFormConfiguration, a as UseFormReturnType, aa as ValidateOn, ab as ValidateOnConfig, ac as ValidationError, ad as ValidationResponse, ae as ValidationResponseWithoutValue, af as ValueOfUnion, ag as WriteMeta, ah as WriteShape, ai as canonicalizePath, aj as isPathPrefix, ak as isUnset, al as parseDottedPath, am as unset } from './shared/attaform.DZnrDrNb.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.DAo0QBmS.mjs';
+export { v as vRegister } from './shared/attaform.D9RqPgGu.mjs';
 import { z } from 'zod';
 import 'vue';
 
 /**
- * Wrap a Zod v4 `ZodObject` schema in an `AbstractSchema` factory.
- *
- * Most consumers never call this directly — `useForm` from
- * `attaform/zod` does the wrapping automatically. Reach for
- * it when you need an adapter outside of `useForm` (e.g. validating
- * data with the same library used elsewhere in the form runtime, or
- * exposing the adapter to a custom integration).
- *
- * The returned factory accepts per-form `SchemaFactoryOptions` (notably
- * `maxRecursionDepth`); the adapter closure bakes them into every
- * downstream walk so a per-form override can lift the cap for that
- * form alone.
- *
- * Throws if the schema isn't Zod v4, or if its root is not a shape
- * that can hold keys. No kind is refused anywhere BELOW the root: a
- * leaf the walkers have no case for is carried opaquely rather than
- * rejected, so a schema a newer Zod can parse is one Attaform can
- * mount. Recursive `z.lazy(...)` is supported — the runtime walks
- * bound their descent via `maxRecursionDepth`.
+ * The Zod v4 adapter: `AbstractSchema` implemented against Zod v4's
+ * public surface. Internal `def.*` access is quarantined to
+ * `introspect.ts` and the modules beside it (default-values,
+ * path-walker, discriminator, errors), leaving this file as the wiring
+ * between them and the `AbstractSchema` contract.
+ *
+ * It holds parity with the v3 adapter on four fronts:
+ * `getDefaultValues`' derivation, delegated to `default-values.ts`
+ * (the default walk, then the DU-aware structural repair walk when
+ * constraints are supplied, parsing nothing); `validateSync`'s one
+ * synchronous parse of the real schema for the construction verdict;
+ * `getSchemasAtPath`' DU-aware path walk; and `validateAtPath`'s
+ * per-branch parse with aggregated errors.
+ */
+
+/**
+ * Wrap a Zod v4 schema in an `AbstractSchema` factory.
+ *
+ * `useForm` from `attaform/zod` does this for you, so reach for it to
+ * use the adapter outside `useForm`: validating data with the same
+ * library the form runtime uses, or handing the adapter to a custom
+ * integration. The factory it returns takes per-form
+ * `SchemaFactoryOptions`, and the adapter closure bakes them into every
+ * downstream walk, so `maxRecursionDepth` can be lifted for one form
+ * alone.
+ *
+ * Throws if the schema is not Zod v4, or if its root cannot hold keys.
+ * No kind is refused anywhere BELOW the root: a leaf the walkers have no
+ * case for is carried opaquely rather than rejected, so a schema a newer
+ * Zod can parse is one Attaform can mount. Recursive `z.lazy(...)`
+ * works, its descent bounded by `maxRecursionDepth`.
  */
 declare function zodV4Adapter<FormSchema extends SupportedRootSchema, Form extends z.input<FormSchema>, GetValueFormType extends z.output<FormSchema> = z.output<FormSchema>>(rootSchema: FormSchema): (formKey: FormKey, options: SchemaFactoryOptions) => AbstractSchema<Form, GetValueFormType>;
 
 /**
- * The single file that reads Zod v4's internal `def` shape. Every other
- * file in the zod-v4 adapter uses these public-shaped accessors — future
- * Zod minor bumps that reshape internals touch only this file.
- *
- * Design principle: treat `schema.def.*` as an unstable surface, even when
- * Zod's docs say otherwise. Each helper returns a narrow, well-typed slice;
- * no adapter code outside this file does shape-based pattern matching on
- * `def`.
+ * The ONE file that reads Zod v4's internal `def` shape. Every other file
+ * in the adapter goes through these public-shaped accessors, so a Zod
+ * minor bump that reshapes internals touches only this file.
+ *
+ * Treat `schema.def.*` as unstable whatever Zod's docs say. Each helper
+ * returns a narrow, well-typed slice, and no adapter code outside this
+ * file pattern-matches on `def`.
  */
 
 /**
- * Stable kind discriminant for a Zod v4 schema. Returned by
- * `kindOf(schema)`. Use when building a custom integration that
- * needs to branch on schema shape — most consumers don't need this.
+ * Stable kind discriminant for a Zod v4 schema, returned by `kindOf`.
+ * Reach for it in a custom integration that branches on schema shape.
  */
 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' | 'nonoptional' | 'success' | 'map' | 'symbol' | 'function';
 /**
- * Inspect a Zod v4 schema and return its `ZodKind`. Returns
- * `'unknown'` for non-Zod inputs and unrecognised shapes.
- *
- * Useful when writing introspection helpers that branch on schema
- * structure (e.g. custom error formatters or doc generators).
+ * The `ZodKind` of a Zod v4 schema; `'unknown'` for a non-Zod input or an
+ * unrecognised shape. Useful in an introspection helper that branches on
+ * structure, a custom error formatter or a doc generator.
  */
 declare function kindOf(schema: unknown): ZodKind;
 /**
- * Verify a schema is Zod v4. Throws a clear error if it's a v3
- * schema mistakenly imported through `attaform/zod`.
- *
- * Most consumers never call this directly — the v4 adapter calls it
- * internally on every schema. Reach for it only when wiring a custom
- * adapter that needs the same guard.
+ * Verify a schema is Zod v4, throwing a clear error for a v3 schema
+ * imported through `attaform/zod` by mistake. The adapter calls it on
+ * every schema; reach for it directly only in a custom adapter that
+ * wants the same guard.
  */
 declare function assertZodVersion(schema: unknown): void;
 
 /**
- * Field-metadata write/read API for the Zod v4 adapter.
- *
- * Storage lives in the shared `field-meta-store` core — every entry
- * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) writes to and
- * reads from the same `WeakMap`s, so a payload registered via any
- * entry surfaces at lookup regardless of which adapter actually runs.
+ * Field-metadata write and read API for the Zod v4 adapter.
  *
- * The native chain `schema.register(fieldMeta, payload)` still works
- * — Zod 4's `.register` calls `registry.add(this, payload)` and
- * returns the schema; the shared store satisfies that structurally.
+ * Storage lives in the shared `core/field-meta-store`, where every entry
+ * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) reads and
+ * writes the same `WeakMap`s, so a payload registered through any of
+ * them surfaces at lookup whichever adapter runs. The native chain
+ * `schema.register(fieldMeta, payload)` works too: Zod 4's `.register`
+ * calls `registry.add(this, payload)` and returns the schema, which the
+ * shared store satisfies structurally.
  *
- * **Registration patterns:** both styles work — register on whatever
- * schema reference you assign into the parent's shape, OR on the
- * inner schema before wrapping. The adapter's resolver tries the
- * walker-returned schema first, then falls back to the peeled
- * inner so either ordering hits:
+ * **Registration order does not matter.** Register on the schema
+ * reference assigned into the parent's shape, or on the inner schema
+ * before wrapping:
  *
- *     // both equivalent — registry hits at lookup time
+ *     // equivalent; all four hit at lookup time
  *     withMeta(z.string(), { label: 'Email' }).optional()
  *     withMeta(z.string().optional(), { label: 'Email' })
  *     z.string().optional().register(fieldMeta, { label: 'Email' })
  *     z.string().register(fieldMeta, { label: 'Email' }).optional()
  *
- * The path walker returns the wrapper at terminal positions
- * (`['email']` against `{ email: z.string().optional() }` resolves
- * to `ZodOptional<ZodString>`) and peels at intermediate descent
- * (`['address', 'street']` peels through `address`'s wrapper to
- * reach the inner object). The two-stage lookup covers both leaf
- * and container registrations symmetrically.
+ * The path walker returns the wrapper at a terminal position, so
+ * `['email']` against `{ email: z.string().optional() }` resolves to
+ * `ZodOptional<ZodString>`, and peels at intermediate descent, so
+ * `['address', 'street']` goes through `address`'s wrapper to the inner
+ * object. The resolver tries the walker's schema before the peeled
+ * inner, so the two-stage lookup covers leaf and container
+ * registrations symmetrically.
  */
 
 type ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>;
 /**
- * The shared registry every Attaform-aware Zod 4 schema can register
- * field metadata against. Backed by the cross-adapter
- * `fieldMetaStore` — one module-scoped instance, shared with the v3
- * adapter and the unified `attaform/zod` entry, so a `.register()`
- * chain in one place is read by adapters in another.
- *
- * Consumers extending `FieldMetaPayload` via declaration merging
- * automatically get the richer payload type at every `register` /
- * `add` / `get` call site.
- *
- * **Shared-instance disambiguation.** A single schema instance reused
- * at multiple form paths (e.g. one address schema bound to both
- * `pickup` and `delivery`) can carry distinct metadata per path —
- * even via the canonical `schema.register(fieldMeta, payload)` chain.
- * The shared store keeps a parallel list of every registration; the
- * path-resolver walks the form's schema tree counting per-schema
- * occurrences to pick the right payload for each path. Object
- * literals evaluate left-to-right, so registration order matches
- * tree-walk order, and shared schemas pair their two registrations
- * to the two paths correctly:
+ * The shared registry an Attaform-aware Zod 4 schema registers field
+ * metadata against.
+ *
+ * ```ts
+ * import { fieldMeta } from 'attaform/zod'
+ *
+ * const schema = z.object({
+ *   email: z.string().register(fieldMeta, { label: 'Email address' }),
+ * })
+ * ```
+ *
+ * One module-scoped instance, shared with the v3 adapter and the
+ * unified `attaform/zod` entry, so a `.register()` chain written in one
+ * place is read by an adapter in another. Extending `FieldMetaPayload`
+ * by declaration merging gives the richer payload type at every
+ * `register` / `add` / `get` call site.
+ *
+ * **One schema instance can carry different metadata per path.** Reuse
+ * an address schema at both `pickup` and `delivery` and each keeps its
+ * own label, through the native chain included:
  *
  *     z.object({
  *       pickup: addressSchema.register(fieldMeta, { label: 'Pickup address' }),
  *       delivery: addressSchema.register(fieldMeta, { label: 'Delivery address' }),
  *     })
- *     // form.fields('pickup').label   → 'Pickup address'
- *     // form.fields('delivery').label → 'Delivery address'
- *
- * Schemas reused via `withMeta()` get a fresh clone per call (see
- * `withMeta` below), so they never share a registry slot in the
- * first place.
- *
- * Cast to `z.$ZodRegistry<FieldMetaPayload>` so that
- * `schema.register(fieldMeta, payload)` chains type-check at the call
- * site — Zod 4's `.register()` only calls `.add(this, payload)`
- * structurally, so the cast is sound at runtime.
- *
- * Backed by `installingFieldMetaStore`: every `add` also installs the
- * path-walking resolver into the shared store's builder slot, so the
- * walk's bytes ride this module's import instead of the adapter. A
- * consumer that never registers metadata never ships the walk.
+ *     // form.fields('pickup').label   -> 'Pickup address'
+ *     // form.fields('delivery').label -> 'Delivery address'
+ *
+ * The store keeps a parallel list of every registration, and the
+ * path-resolver walks the form's schema tree counting per-schema
+ * occurrences to pick the right payload per path. Object literals
+ * evaluate left to right, so registration order matches tree-walk order
+ * and the pairing holds. `withMeta()` never reaches this case at all,
+ * since it clones per call.
+ *
+ * The cast to the registry type is what lets `schema.register(fieldMeta,
+ * payload)` type-check at the call site; Zod 4's `.register()` only
+ * calls `.add(this, payload)`, so it is sound at runtime. Every `add`
+ * also installs the path-walking resolver into the shared store's
+ * builder slot, which is what makes the walk's bytes ride this module's
+ * import rather than the adapter: a consumer who never registers
+ * metadata never ships the walk.
  */
 declare const fieldMeta: ZodFieldMetaRegistry;
 /**
- * Attach `payload` to `schema` in the shared `fieldMeta` registry
- * and return `schema` (chainable). Cross-version with `attaform/zod-v3`'s
- * `withMeta()`; user code that uses this helper reads the same on
- * either adapter.
- *
- * Equivalent to `schema.register(fieldMeta, payload)` on Zod 4.
- * Prefer the native chain for v4-only code; reach for `withMeta`
- * when authoring schema modules that may need to compile under both
- * adapters.
- *
- * Registers on the schema reference passed in. See the
- * "Registration rule" note in this file's header — register on the
- * inner schema before wrapping with `.optional()` / `.nullable()` /
- * `.default()` / etc.
+ * Attach `payload` to `schema` in the shared `fieldMeta` registry and
+ * return a chainable CLONE of `schema` carrying it. It matches
+ * `attaform/zod-v3`'s `withMeta()`, so a schema module written with it
+ * reads the same under either adapter.
+ *
+ * For v4-only code prefer the native `schema.register(fieldMeta,
+ * payload)`, which registers on the instance you passed and returns
+ * that same instance. Reach for `withMeta` when the module has to
+ * compile under both adapters, or when one schema instance is reused at
+ * several paths and each needs its own payload: the clone per call is
+ * what gives each call site its own registry slot.
  */
 declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
 

package/dist/zod-v4.mjs

@@ -1,9 +1,9 @@
-export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.BXneBxEj.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.CUfrMK7t.mjs';
+export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.BWUn8Kjy.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.DL2nl_QR.mjs';
 export { A as AttaformError, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.CdZIEf7_.mjs';
-export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNJOWjQw.mjs';
-export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.WiGdIqgx.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.B3resMQ1.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNPJPOO7.mjs';
+export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.C4shmwyJ.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DxKQsqFZ.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
 
 const fieldMeta = installingFieldMetaStore;