attaform 0.16.2 → 0.16.4

package/dist/zod-v3.d.mts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { ae as ValidateOnConfig, F as FormKey, B as OnInvalidSubmitPolicy, W as PersistConfig, x as HistoryConfig, C as CoercionRegistry, G as GenericForm, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, d as UseFormReturnType, n as FieldMetaPayload } from './shared/attaform.0Gxd_OOx.mjs';
-export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform.0Gxd_OOx.mjs';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CVv9Oh0a.mjs';
+import { ag as ValidateOnConfig, F as FormKey, E as OnInvalidSubmitPolicy, X as PersistConfig, y as HistoryConfig, C as CoercionRegistry, G as GenericForm, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, d as UseFormReturnType, o as FieldMetaPayload } from './shared/attaform.CU3JperC.mjs';
+export { ae as Unset, ao as isUnset, aq as unset } from './shared/attaform.CU3JperC.mjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CXMOheyZ.mjs';
 import 'vue';
 
 /**
@@ -163,11 +163,16 @@ declare function isZodSchemaType<K extends keyof ZodTypeMap>(schema: unknown, ex
 /**
  * Field-metadata write/read API for the Zod v3 adapter.
  *
- * Zod 3 has no `z.registry()` mechanism, so we shim one with a
- * module-scoped `WeakMap<ZodTypeAny, FieldMetaPayload>` plus a
- * registry-shaped object exposing `add` / `get` / `has`. The public
- * `withMeta(schema, payload)` write API matches `attaform/zod` so
- * schema authoring reads identically across the two adapters.
+ * 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
@@ -186,9 +191,9 @@ declare function isZodSchemaType<K extends keyof ZodTypeMap>(schema: unknown, ex
 
 /**
  * The shared registry every Attaform-aware Zod 3 schema can register
- * field metadata against. Exposes a registry-shaped surface so that
- * v3 user code can use the same idiom v4 users do (`fieldMeta.add(schema,
- * payload)`); under the hood it's just a `WeakMap`.
+ * field metadata against. Backed by the cross-adapter
+ * `fieldMetaStore` — a payload registered here is visible to the v4
+ * adapter and the unified `attaform/zod` entry, and vice versa.
  */
 type FieldMetaRegistryV3 = {
     /**
@@ -210,7 +215,7 @@ declare const fieldMeta: FieldMetaRegistryV3;
  * and return a clone of `schema` (chainable, with the new metadata).
  * Cross-version with `attaform/zod`'s `withMeta()`.
  *
- * **Why clone, not mutate.** The WeakMap shim keys metadata on the
+ * **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
@@ -228,8 +233,8 @@ declare const fieldMeta: FieldMetaRegistryV3;
  * registers once and surfaces at every path.
  *
  * `schema.register()` does NOT exist on Zod 3 — `withMeta` is the
- * only write API. Register on the inner schema before wrapping;
- * see the "Registration rule" note in this file's header.
+ * only fluent write API. Register on the inner schema before
+ * wrapping; see the "Registration rule" note in this file's header.
  */
 declare function withMeta<S extends z.ZodTypeAny>(schema: S, payload: FieldMetaPayload): S;
 

package/dist/zod-v3.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { ae as ValidateOnConfig, F as FormKey, B as OnInvalidSubmitPolicy, W as PersistConfig, x as HistoryConfig, C as CoercionRegistry, G as GenericForm, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, d as UseFormReturnType, n as FieldMetaPayload } from './shared/attaform.0Gxd_OOx.js';
-export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform.0Gxd_OOx.js';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CWCx2r0x.js';
+import { ag as ValidateOnConfig, F as FormKey, E as OnInvalidSubmitPolicy, X as PersistConfig, y as HistoryConfig, C as CoercionRegistry, G as GenericForm, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, d as UseFormReturnType, o as FieldMetaPayload } from './shared/attaform.CU3JperC.js';
+export { ae as Unset, ao as isUnset, aq as unset } from './shared/attaform.CU3JperC.js';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CCQkY4Ta.js';
 import 'vue';
 
 /**
@@ -163,11 +163,16 @@ declare function isZodSchemaType<K extends keyof ZodTypeMap>(schema: unknown, ex
 /**
  * Field-metadata write/read API for the Zod v3 adapter.
  *
- * Zod 3 has no `z.registry()` mechanism, so we shim one with a
- * module-scoped `WeakMap<ZodTypeAny, FieldMetaPayload>` plus a
- * registry-shaped object exposing `add` / `get` / `has`. The public
- * `withMeta(schema, payload)` write API matches `attaform/zod` so
- * schema authoring reads identically across the two adapters.
+ * 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
@@ -186,9 +191,9 @@ declare function isZodSchemaType<K extends keyof ZodTypeMap>(schema: unknown, ex
 
 /**
  * The shared registry every Attaform-aware Zod 3 schema can register
- * field metadata against. Exposes a registry-shaped surface so that
- * v3 user code can use the same idiom v4 users do (`fieldMeta.add(schema,
- * payload)`); under the hood it's just a `WeakMap`.
+ * field metadata against. Backed by the cross-adapter
+ * `fieldMetaStore` — a payload registered here is visible to the v4
+ * adapter and the unified `attaform/zod` entry, and vice versa.
  */
 type FieldMetaRegistryV3 = {
     /**
@@ -210,7 +215,7 @@ declare const fieldMeta: FieldMetaRegistryV3;
  * and return a clone of `schema` (chainable, with the new metadata).
  * Cross-version with `attaform/zod`'s `withMeta()`.
  *
- * **Why clone, not mutate.** The WeakMap shim keys metadata on the
+ * **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
@@ -228,8 +233,8 @@ declare const fieldMeta: FieldMetaRegistryV3;
  * registers once and surfaces at every path.
  *
  * `schema.register()` does NOT exist on Zod 3 — `withMeta` is the
- * only write API. Register on the inner schema before wrapping;
- * see the "Registration rule" note in this file's header.
+ * only fluent write API. Register on the inner schema before
+ * wrapping; see the "Registration rule" note in this file's header.
  */
 declare function withMeta<S extends z.ZodTypeAny>(schema: S, payload: FieldMetaPayload): S;
 

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.DdnithOf.mjs';
-export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DILbdvfo.mjs';
+export { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.UA19EF3J.mjs';
+export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DyV1O4tI.mjs';
 export { u as useRegister } from './shared/attaform.BfMxsfmE.mjs';
 //# sourceMappingURL=zod-v3.mjs.map

package/dist/zod-v4.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-const index = require('./shared/attaform.DfrYByDj.cjs');
-const useFormContext = require('./shared/attaform.C9Ph2SMx.cjs');
+const index = require('./shared/attaform.keLBaHB6.cjs');
+const useFormContext = require('./shared/attaform.fegmBJaq.cjs');
 const plugin = require('./shared/attaform.rIRYSUI1.cjs');
 
 

package/dist/zod-v4.d.cts

@@ -1,8 +1,7 @@
 import { z } from 'zod';
-import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ae as ValidateOnConfig, d as UseFormReturnType } from './shared/attaform.0Gxd_OOx.cjs';
-export { n as FieldMetaPayload, ac as Unset, am as isUnset, ao as unset } from './shared/attaform.0Gxd_OOx.cjs';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.Dq5BabH1.cjs';
-export { f as fieldMeta, w as withMeta } from './shared/attaform.xIcmqscx.cjs';
+import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ag as ValidateOnConfig, d as UseFormReturnType, o as FieldMetaPayload } from './shared/attaform.CU3JperC.cjs';
+export { ae as Unset, ao as isUnset, aq as unset } from './shared/attaform.CU3JperC.cjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CMRmwGDt.cjs';
 import { a as AttaformError } from './shared/attaform.B7rzpK1U.cjs';
 import 'vue';
 
@@ -100,5 +99,95 @@ declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseForm
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-export { UnsupportedSchemaError, assertZodVersion, kindOf, useForm, zodV4Adapter as zodAdapter };
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * **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
+ *     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.
+ */
+
+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:
+ *
+ *     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.
+ */
+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.
+ */
+declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
+
+export { FieldMetaPayload, UnsupportedSchemaError, assertZodVersion, fieldMeta, kindOf, useForm, withMeta, zodV4Adapter as zodAdapter };
 export type { ZodKind };

package/dist/zod-v4.d.mts

@@ -1,8 +1,7 @@
 import { z } from 'zod';
-import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ae as ValidateOnConfig, d as UseFormReturnType } from './shared/attaform.0Gxd_OOx.mjs';
-export { n as FieldMetaPayload, ac as Unset, am as isUnset, ao as unset } from './shared/attaform.0Gxd_OOx.mjs';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CVv9Oh0a.mjs';
-export { f as fieldMeta, w as withMeta } from './shared/attaform.BAuJTWuT.mjs';
+import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ag as ValidateOnConfig, d as UseFormReturnType, o as FieldMetaPayload } from './shared/attaform.CU3JperC.mjs';
+export { ae as Unset, ao as isUnset, aq as unset } from './shared/attaform.CU3JperC.mjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CXMOheyZ.mjs';
 import { a as AttaformError } from './shared/attaform.B7rzpK1U.mjs';
 import 'vue';
 
@@ -100,5 +99,95 @@ declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseForm
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-export { UnsupportedSchemaError, assertZodVersion, kindOf, useForm, zodV4Adapter as zodAdapter };
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * **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
+ *     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.
+ */
+
+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:
+ *
+ *     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.
+ */
+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.
+ */
+declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
+
+export { FieldMetaPayload, UnsupportedSchemaError, assertZodVersion, fieldMeta, kindOf, useForm, withMeta, zodV4Adapter as zodAdapter };
 export type { ZodKind };

package/dist/zod-v4.d.ts

@@ -1,8 +1,7 @@
 import { z } from 'zod';
-import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ae as ValidateOnConfig, d as UseFormReturnType } from './shared/attaform.0Gxd_OOx.js';
-export { n as FieldMetaPayload, ac as Unset, am as isUnset, ao as unset } from './shared/attaform.0Gxd_OOx.js';
-export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CWCx2r0x.js';
-export { f as fieldMeta, w as withMeta } from './shared/attaform.ls_7jBYc.js';
+import { F as FormKey, b as AbstractSchema, U as UseFormConfiguration, G as GenericForm, D as DeepPartial, c as DefaultValuesShape, ag as ValidateOnConfig, d as UseFormReturnType, o as FieldMetaPayload } from './shared/attaform.CU3JperC.js';
+export { ae as Unset, ao as isUnset, aq as unset } from './shared/attaform.CU3JperC.js';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.CCQkY4Ta.js';
 import { a as AttaformError } from './shared/attaform.B7rzpK1U.js';
 import 'vue';
 
@@ -100,5 +99,95 @@ declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseForm
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-export { UnsupportedSchemaError, assertZodVersion, kindOf, useForm, zodV4Adapter as zodAdapter };
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * **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
+ *     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.
+ */
+
+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:
+ *
+ *     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.
+ */
+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.
+ */
+declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
+
+export { FieldMetaPayload, UnsupportedSchemaError, assertZodVersion, fieldMeta, kindOf, useForm, withMeta, zodV4Adapter as zodAdapter };
 export type { ZodKind };

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.CvOXSpCb.mjs';
-export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DILbdvfo.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.g7rfuXdz.mjs';
+export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DyV1O4tI.mjs';
 export { u as useRegister } from './shared/attaform.BfMxsfmE.mjs';
 //# sourceMappingURL=zod-v4.mjs.map

package/dist/zod.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
 const plugin = require('./shared/attaform.rIRYSUI1.cjs');
-const useForm$1 = require('./shared/attaform.Bp1c-uGF.cjs');
-const index = require('./shared/attaform.DfrYByDj.cjs');
-const useFormContext = require('./shared/attaform.C9Ph2SMx.cjs');
+const useForm$1 = require('./shared/attaform.Dd_pWnmn.cjs');
+const index = require('./shared/attaform.keLBaHB6.cjs');
+const useFormContext = require('./shared/attaform.fegmBJaq.cjs');
+const fieldMetaStore = require('./shared/attaform.C8CyvYa_.cjs');
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -23,12 +24,29 @@ function useForm(configuration) {
   return useForm$1.useForm(configuration);
 }
 
+const fieldMeta = fieldMetaStore.fieldMetaStore;
+function withMeta(schema, payload) {
+  const target = schema;
+  const existing = fieldMetaStore.getFieldMetaForSchema(target) ?? {};
+  const cloned = cloneSchema(schema);
+  fieldMetaStore.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function cloneSchema(schema) {
+  const candidate = schema;
+  if (typeof candidate.clone === "function") {
+    return candidate.clone();
+  }
+  const Ctor = candidate.constructor;
+  return new Ctor(candidate._def);
+}
+
 exports.useRegister = plugin.useRegister;
-exports.fieldMeta = index.fieldMeta;
-exports.withMeta = index.withMeta;
 exports.AttaformErrorCode = useFormContext.AttaformErrorCode;
 exports.injectForm = useFormContext.injectForm;
 exports.isUnset = useFormContext.isUnset;
 exports.unset = useFormContext.unset;
+exports.fieldMeta = fieldMeta;
 exports.useForm = useForm;
+exports.withMeta = withMeta;
 //# sourceMappingURL=zod.cjs.map

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"],"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 * 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 { 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 {\n  AbstractSchema,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { DeepPartial, DefaultValuesShape, GenericForm } from '../../types/types-core'\n\n/**\n * Create a form bound to a Zod schema. Accepts both Zod v3 and Zod v4\n * schemas; the runtime picks the right adapter from the schema's\n * shape.\n *\n * Type inference targets Zod v4 — the recommended major. Consumers\n * still on Zod v3 get correct runtime behavior here, but the strongest\n * TypeScript inference comes from importing `attaform/zod-v3`\n * directly.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     email: z.email(),\n *     password: z.string().min(8),\n *   }),\n * })\n * ```\n */\nexport function useForm<Schema extends z.ZodObject>(\n  configuration: Omit<\n    UseFormConfiguration<\n      z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n      z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n      AbstractSchema<\n        z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n        z.output<Schema> extends GenericForm ? z.output<Schema> : never\n      >,\n      DeepPartial<\n        DefaultValuesShape<z.output<Schema> extends GenericForm ? z.output<Schema> : never>\n      >\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<\n  z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n  z.output<Schema> extends GenericForm ? z.output<Schema> : never\n> {\n  // Foot-gun guard mirrors the typed wrappers'.\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4<Schema>>[0]) as ReturnType<\n      typeof useForm<Schema>\n    >\n  }\n  // Anything else (Zod v3 schema, custom AbstractSchema, schema\n  // factory) goes through the v3 wrapper, which already accepts both\n  // Zod v3 input and AbstractSchema directly via its existing shape\n  // branch. Cast through unknown — the unified entry's TS surface\n  // tracks v4, but the runtime accepts the broader shape.\n  return useFormV3(configuration as never) as unknown as ReturnType<typeof useForm<Schema>>\n}\n"],"names":["InvalidUseFormConfigError","useFormV4","useFormV3"],"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;;ACUO,SAAS,QACd,aAAA,EAiBA;AAEA,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,gCAAA,EAA0B;AAAA,EACtC;AAEA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAwD,CAAA;AAAA,EAG3E;AAMA,EAAA,OAAOC,kBAAU,aAAsB,CAAA;AACzC;;;;;;;;;;;"}
+{"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 * 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 { 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 {\n  AbstractSchema,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { DeepPartial, DefaultValuesShape, GenericForm } from '../../types/types-core'\n\n/**\n * Create a form bound to a Zod schema. Accepts both Zod v3 and Zod v4\n * schemas; the runtime picks the right adapter from the schema's\n * shape.\n *\n * Type inference targets Zod v4 — the recommended major. Consumers\n * still on Zod v3 get correct runtime behavior here, but the strongest\n * TypeScript inference comes from importing `attaform/zod-v3`\n * directly.\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 */\nexport function useForm<Schema extends z.ZodObject>(\n  configuration: Omit<\n    UseFormConfiguration<\n      z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n      z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n      AbstractSchema<\n        z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n        z.output<Schema> extends GenericForm ? z.output<Schema> : never\n      >,\n      DeepPartial<\n        DefaultValuesShape<z.output<Schema> extends GenericForm ? z.output<Schema> : never>\n      >\n    >,\n    'schema' | 'validateOn' | 'debounceMs'\n  > & { schema: Schema } & ValidateOnConfig\n): UseFormReturnType<\n  z.output<Schema> extends GenericForm ? z.output<Schema> : never,\n  z.output<Schema> extends GenericForm ? z.output<Schema> : never\n> {\n  // Foot-gun guard mirrors the typed wrappers'.\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4<Schema>>[0]) as ReturnType<\n      typeof useForm<Schema>\n    >\n  }\n  // Anything else (Zod v3 schema, custom AbstractSchema, schema\n  // factory) goes through the v3 wrapper, which already accepts both\n  // Zod v3 input and AbstractSchema directly via its existing shape\n  // branch. Cast through unknown — the unified entry's TS surface\n  // tracks v4, but the runtime accepts the broader shape.\n  return useFormV3(configuration as never) as unknown as ReturnType<typeof useForm<Schema>>\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;;ACUO,SAAS,QACd,aAAA,EAiBA;AAEA,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAIA,gCAAA,EAA0B;AAAA,EACtC;AAEA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOC,cAAU,aAAwD,CAAA;AAAA,EAG3E;AAMA,EAAA,OAAOC,kBAAU,aAAsB,CAAA;AACzC;;AC3DO,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;;;;;;;;;;;"}