attaform 0.16.2 → 0.16.3

package/dist/shared/{attaform.0Gxd_OOx.d.ts → attaform._EqYNPYF.d.ts}

@@ -2,14 +2,22 @@ import { Ref, ObjectDirective, ComputedRef } from 'vue';
 
 /**
  * Schema-attached field metadata — the shared types used by both Zod
- * adapters (`attaform/zod` for v4 and `attaform/zod-v3` for v3) so a
- * consumer's data flow reads the same shape regardless of adapter.
- *
- * The Zod 4 adapter creates a typed `z.registry<FieldMetaPayload>()`
- * and writes through `schema.register(fieldMeta, payload)` (native) or
- * the `withMeta(schema, payload)` helper. The Zod 3 adapter has no
- * native registry — it shims a `WeakMap<ZodTypeAny, FieldMetaPayload>`
- * with the same write API via `withMeta`.
+ * adapters and the unified `attaform/zod` entry so a consumer's data
+ * flow reads the same shape regardless of which path runs at lookup.
+ *
+ * Storage lives in the cross-adapter `field-meta-store` core: a pair
+ * of WeakMaps (single-payload for last-write-wins reads, list-of-
+ * payloads for shared-schema disambiguation). Every entry's
+ * `fieldMeta` re-exports the same registry-shaped object, so
+ * `withMeta`/`fieldMeta.add` writes from one entry surface at lookup
+ * through any other.
+ *
+ * `withMeta(schema, payload)` clones the schema before registering,
+ * so each call gets fresh identity (the WeakMap keys on reference).
+ * The cloning strategy depends on the major: Zod 4 schemas use the
+ * native `.clone()`, Zod 3 schemas reconstruct via constructor +
+ * `_def`. The unified entry's `withMeta` runtime-branches on which
+ * one is in play.
  *
  * Reads are unified through `AbstractSchema.getFieldMetaAtPath(path)`,
  * which returns a fully-resolved `ResolvedFieldMeta` (label /
@@ -844,8 +852,8 @@ type AbstractSchema<Form, GetValueFormType> = {
      * Return the resolved field metadata for the schema node at `path`
      * — label, description, placeholder, plus the full registered
      * payload as `meta` for consumer-augmented keys. Reads through the
-     * adapter's metadata mechanism (Zod 4: `z.registry()`; Zod 3:
-     * a WeakMap shim) and applies these one-way fallbacks:
+     * shared cross-adapter field-meta store and applies these one-way
+     * fallbacks:
      *
      *   - `label`:       registry payload → `humanize(lastSegment)`
      *   - `description`: registry payload → `schema.description`
@@ -2071,9 +2079,9 @@ type FieldState<Value = unknown> = {
     readonly blank: boolean;
     /**
      * Presentational label for this field. Resolves through the
-     * adapter's metadata mechanism — Zod 4's `z.registry()` (typed
-     * payload via `schema.register(fieldMeta, {...})` or the
-     * `withMeta()` helper); Zod 3's WeakMap shim — and falls back to
+     * shared cross-adapter field-meta store — written via
+     * `schema.register(fieldMeta, {...})` (Zod 4 native chain) or the
+     * `withMeta()` helper (works on both majors) — and falls back to
      * a humanized form of the path's last segment when nothing has
      * been registered. Always a string.
      *

package/dist/shared/{attaform.CWCx2r0x.d.ts → attaform.lFNwBcA3.d.ts}

@@ -1,4 +1,4 @@
-import { G as GenericForm, F as FormKey, d as UseFormReturnType, R as RegisterValue } from './attaform.0Gxd_OOx.js';
+import { G as GenericForm, F as FormKey, d as UseFormReturnType, R as RegisterValue } from './attaform._EqYNPYF.js';
 import { Ref } from 'vue';
 
 /**

package/dist/zod-v3.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const useForm = require('./shared/attaform.Bp1c-uGF.cjs');
+const useForm = require('./shared/attaform.KrNw10aW.cjs');
 const useFormContext = require('./shared/attaform.C9Ph2SMx.cjs');
 const plugin = require('./shared/attaform.rIRYSUI1.cjs');
 

package/dist/zod-v3.d.cts

@@ -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.cjs';
-export { 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';
+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._EqYNPYF.cjs';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.cjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.DLnKT7wk.cjs';
 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.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 { 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._EqYNPYF.mjs';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.mjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.Bls_kFR6.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 { 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._EqYNPYF.js';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.js';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.lFNwBcA3.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 { f as fieldMeta, i as isZodSchemaType, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.CFA6y0KF.mjs';
 export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DILbdvfo.mjs';
 export { u as useRegister } from './shared/attaform.BfMxsfmE.mjs';
 //# sourceMappingURL=zod-v3.mjs.map

package/dist/zod-v4.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const index = require('./shared/attaform.DfrYByDj.cjs');
+const index = require('./shared/attaform.DGuGGNg9.cjs');
 const useFormContext = require('./shared/attaform.C9Ph2SMx.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, ae as ValidateOnConfig, d as UseFormReturnType, n as FieldMetaPayload } from './shared/attaform._EqYNPYF.cjs';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.cjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.DLnKT7wk.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, ae as ValidateOnConfig, d as UseFormReturnType, n as FieldMetaPayload } from './shared/attaform._EqYNPYF.mjs';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.mjs';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.Bls_kFR6.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, ae as ValidateOnConfig, d as UseFormReturnType, n as FieldMetaPayload } from './shared/attaform._EqYNPYF.js';
+export { ac as Unset, am as isUnset, ao as unset } from './shared/attaform._EqYNPYF.js';
+export { A as AttaformErrorCode, i as injectForm, u as useRegister } from './shared/attaform.lFNwBcA3.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 { U as UnsupportedSchemaError, a as assertZodVersion, f as fieldMeta, k as kindOf, u as useForm, w as withMeta, z as zodAdapter } from './shared/attaform.XYOMTvuO.mjs';
 export { A as AttaformErrorCode, i as injectForm, a as isUnset, u as unset } from './shared/attaform.DILbdvfo.mjs';
 export { u as useRegister } from './shared/attaform.BfMxsfmE.mjs';
 //# sourceMappingURL=zod-v4.mjs.map