attaform 0.15.1 → 0.16.1

package/dist/zod.d.cts

@@ -1,79 +1,40 @@
 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, 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';
+import { U as UseFormConfiguration, G as GenericForm, b as AbstractSchema, 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';
-import { a as AttaformError } from './shared/attaform.BwaYWtMs.cjs';
+export { f as fieldMeta, w as withMeta } from './shared/attaform.xIcmqscx.cjs';
 import 'vue';
 
 /**
- * Wrap a Zod v4 `ZodObject` schema in an `AbstractSchema` factory.
+ * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches
+ * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the
+ * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes
+ * to the v3 wrapper, which already accepts both Zod v3 input and
+ * `AbstractSchema` directly via its built-in shape branch.
  *
- * 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).
+ * This module is the FALLBACK path. Vite consumers see the
+ * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`
+ * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build
+ * time — in that case this dispatch never runs and the consumer
+ * bundle ships only the matching adapter. Other bundlers (and
+ * non-bundled ESM consumption) hit this dispatch instead, paying a
+ * modest size cost for the convenience of a single hello-world import.
  *
- * Throws if the schema isn't Zod v4, or contains kinds the adapter
- * cannot represent (`z.promise`, `z.custom`, `z.templateLiteral`,
- * recursive `z.lazy(...)`).
+ * Power users who want a guaranteed lean bundle on non-Vite tooling
+ * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —
+ * those subpaths are never rewritten and never load the other
+ * adapter.
  */
-declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.infer<FormSchema>>(rootSchema: FormSchema): (formKey: FormKey) => AbstractSchema<Form, Form>;
 
 /**
- * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * Create a form bound to a Zod schema. Accepts both Zod v3 and Zod v4
+ * schemas; the runtime picks the right adapter from the schema's
+ * shape.
  *
- * The error message includes the dotted path of the offending node
- * so you can locate it without traversing the whole schema.
- */
-declare class UnsupportedSchemaError extends AttaformError {
-}
-
-/**
- * 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`.
- */
-
-/**
- * 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.
- */
-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';
-/**
- * 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).
- */
-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.
- */
-declare function assertZodVersion(schema: unknown): void;
-
-/**
- * Zod v4 adapter entry point. Re-exports the adapter + the useForm
- * wrapper that threads zod-v4-specific schema types through
- * useAbstractForm.
- */
-
-/**
- * Create a form bound to a Zod v4 schema.
+ * Type inference targets Zod v4 — the recommended major. Consumers
+ * still on Zod v3 get correct runtime behavior here, but the strongest
+ * TypeScript inference comes from importing `attaform/zod-v3`
+ * directly.
  *
  * ```ts
  * import { useForm } from 'attaform/zod'
@@ -84,100 +45,11 @@ declare function assertZodVersion(schema: unknown): void;
  *     email: z.email(),
  *     password: z.string().min(8),
  *   }),
- *   defaultValues: { email: '' },
  * })
  * ```
- *
- * 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 v3, import from `attaform/zod-v3` instead.
  */
 declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseFormConfiguration<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, AbstractSchema<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>, DeepPartial<DefaultValuesShape<z.output<Schema> extends GenericForm ? z.output<Schema> : never>>>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-/**
- * Field-metadata write/read API for the Zod v4 adapter.
- *
- * Backed by Zod 4's native `z.registry<T>()` mechanism — the schema
- * carries the metadata directly through `schema.register(fieldMeta,
- * payload)` (returns the schema, chainable) or the `withMeta()`
- * helper (same effect, version-agnostic across the v3 / v4 adapter
- * split).
- *
- * **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.
- */
-
-/**
- * The shared registry every Attaform-aware Zod 4 schema can register
- * field metadata against. One module-scoped instance per consumer
- * project — re-exported from `attaform/zod` so user code reads the
- * same registry the runtime does.
- *
- * 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.
- * Internally we maintain a parallel WeakMap of payload LISTS indexed
- * per schema reference, and 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.
- */
-declare const fieldMeta: z.core.$ZodRegistry<FieldMetaPayload, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * 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 };
+export { useForm };

package/dist/zod.d.mts

@@ -1,79 +1,40 @@
 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, 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';
+import { U as UseFormConfiguration, G as GenericForm, b as AbstractSchema, 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';
-import { a as AttaformError } from './shared/attaform.BwaYWtMs.mjs';
+export { f as fieldMeta, w as withMeta } from './shared/attaform.BAuJTWuT.mjs';
 import 'vue';
 
 /**
- * Wrap a Zod v4 `ZodObject` schema in an `AbstractSchema` factory.
+ * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches
+ * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the
+ * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes
+ * to the v3 wrapper, which already accepts both Zod v3 input and
+ * `AbstractSchema` directly via its built-in shape branch.
  *
- * 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).
+ * This module is the FALLBACK path. Vite consumers see the
+ * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`
+ * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build
+ * time — in that case this dispatch never runs and the consumer
+ * bundle ships only the matching adapter. Other bundlers (and
+ * non-bundled ESM consumption) hit this dispatch instead, paying a
+ * modest size cost for the convenience of a single hello-world import.
  *
- * Throws if the schema isn't Zod v4, or contains kinds the adapter
- * cannot represent (`z.promise`, `z.custom`, `z.templateLiteral`,
- * recursive `z.lazy(...)`).
+ * Power users who want a guaranteed lean bundle on non-Vite tooling
+ * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —
+ * those subpaths are never rewritten and never load the other
+ * adapter.
  */
-declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.infer<FormSchema>>(rootSchema: FormSchema): (formKey: FormKey) => AbstractSchema<Form, Form>;
 
 /**
- * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * Create a form bound to a Zod schema. Accepts both Zod v3 and Zod v4
+ * schemas; the runtime picks the right adapter from the schema's
+ * shape.
  *
- * The error message includes the dotted path of the offending node
- * so you can locate it without traversing the whole schema.
- */
-declare class UnsupportedSchemaError extends AttaformError {
-}
-
-/**
- * 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`.
- */
-
-/**
- * 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.
- */
-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';
-/**
- * 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).
- */
-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.
- */
-declare function assertZodVersion(schema: unknown): void;
-
-/**
- * Zod v4 adapter entry point. Re-exports the adapter + the useForm
- * wrapper that threads zod-v4-specific schema types through
- * useAbstractForm.
- */
-
-/**
- * Create a form bound to a Zod v4 schema.
+ * Type inference targets Zod v4 — the recommended major. Consumers
+ * still on Zod v3 get correct runtime behavior here, but the strongest
+ * TypeScript inference comes from importing `attaform/zod-v3`
+ * directly.
  *
  * ```ts
  * import { useForm } from 'attaform/zod'
@@ -84,100 +45,11 @@ declare function assertZodVersion(schema: unknown): void;
  *     email: z.email(),
  *     password: z.string().min(8),
  *   }),
- *   defaultValues: { email: '' },
  * })
  * ```
- *
- * 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 v3, import from `attaform/zod-v3` instead.
  */
 declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseFormConfiguration<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, AbstractSchema<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>, DeepPartial<DefaultValuesShape<z.output<Schema> extends GenericForm ? z.output<Schema> : never>>>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-/**
- * Field-metadata write/read API for the Zod v4 adapter.
- *
- * Backed by Zod 4's native `z.registry<T>()` mechanism — the schema
- * carries the metadata directly through `schema.register(fieldMeta,
- * payload)` (returns the schema, chainable) or the `withMeta()`
- * helper (same effect, version-agnostic across the v3 / v4 adapter
- * split).
- *
- * **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.
- */
-
-/**
- * The shared registry every Attaform-aware Zod 4 schema can register
- * field metadata against. One module-scoped instance per consumer
- * project — re-exported from `attaform/zod` so user code reads the
- * same registry the runtime does.
- *
- * 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.
- * Internally we maintain a parallel WeakMap of payload LISTS indexed
- * per schema reference, and 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.
- */
-declare const fieldMeta: z.core.$ZodRegistry<FieldMetaPayload, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * 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 };
+export { useForm };

package/dist/zod.d.ts

@@ -1,79 +1,40 @@
 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, 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';
+import { U as UseFormConfiguration, G as GenericForm, b as AbstractSchema, 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';
-import { a as AttaformError } from './shared/attaform.BwaYWtMs.js';
+export { f as fieldMeta, w as withMeta } from './shared/attaform.ls_7jBYc.js';
 import 'vue';
 
 /**
- * Wrap a Zod v4 `ZodObject` schema in an `AbstractSchema` factory.
+ * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches
+ * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the
+ * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes
+ * to the v3 wrapper, which already accepts both Zod v3 input and
+ * `AbstractSchema` directly via its built-in shape branch.
  *
- * 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).
+ * This module is the FALLBACK path. Vite consumers see the
+ * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`
+ * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build
+ * time — in that case this dispatch never runs and the consumer
+ * bundle ships only the matching adapter. Other bundlers (and
+ * non-bundled ESM consumption) hit this dispatch instead, paying a
+ * modest size cost for the convenience of a single hello-world import.
  *
- * Throws if the schema isn't Zod v4, or contains kinds the adapter
- * cannot represent (`z.promise`, `z.custom`, `z.templateLiteral`,
- * recursive `z.lazy(...)`).
+ * Power users who want a guaranteed lean bundle on non-Vite tooling
+ * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —
+ * those subpaths are never rewritten and never load the other
+ * adapter.
  */
-declare function zodV4Adapter<FormSchema extends z.ZodObject, Form extends z.infer<FormSchema>>(rootSchema: FormSchema): (formKey: FormKey) => AbstractSchema<Form, Form>;
 
 /**
- * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, `z.templateLiteral`, or a
- * recursive `z.lazy(...)` that loops back into itself.
+ * Create a form bound to a Zod schema. Accepts both Zod v3 and Zod v4
+ * schemas; the runtime picks the right adapter from the schema's
+ * shape.
  *
- * The error message includes the dotted path of the offending node
- * so you can locate it without traversing the whole schema.
- */
-declare class UnsupportedSchemaError extends AttaformError {
-}
-
-/**
- * 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`.
- */
-
-/**
- * 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.
- */
-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';
-/**
- * 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).
- */
-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.
- */
-declare function assertZodVersion(schema: unknown): void;
-
-/**
- * Zod v4 adapter entry point. Re-exports the adapter + the useForm
- * wrapper that threads zod-v4-specific schema types through
- * useAbstractForm.
- */
-
-/**
- * Create a form bound to a Zod v4 schema.
+ * Type inference targets Zod v4 — the recommended major. Consumers
+ * still on Zod v3 get correct runtime behavior here, but the strongest
+ * TypeScript inference comes from importing `attaform/zod-v3`
+ * directly.
  *
  * ```ts
  * import { useForm } from 'attaform/zod'
@@ -84,100 +45,11 @@ declare function assertZodVersion(schema: unknown): void;
  *     email: z.email(),
  *     password: z.string().min(8),
  *   }),
- *   defaultValues: { email: '' },
  * })
  * ```
- *
- * 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 v3, import from `attaform/zod-v3` instead.
  */
 declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseFormConfiguration<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, AbstractSchema<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>, DeepPartial<DefaultValuesShape<z.output<Schema> extends GenericForm ? z.output<Schema> : never>>>, 'schema' | 'validateOn' | 'debounceMs'> & {
     schema: Schema;
 } & ValidateOnConfig): UseFormReturnType<z.output<Schema> extends GenericForm ? z.output<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>;
 
-/**
- * Field-metadata write/read API for the Zod v4 adapter.
- *
- * Backed by Zod 4's native `z.registry<T>()` mechanism — the schema
- * carries the metadata directly through `schema.register(fieldMeta,
- * payload)` (returns the schema, chainable) or the `withMeta()`
- * helper (same effect, version-agnostic across the v3 / v4 adapter
- * split).
- *
- * **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.
- */
-
-/**
- * The shared registry every Attaform-aware Zod 4 schema can register
- * field metadata against. One module-scoped instance per consumer
- * project — re-exported from `attaform/zod` so user code reads the
- * same registry the runtime does.
- *
- * 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.
- * Internally we maintain a parallel WeakMap of payload LISTS indexed
- * per schema reference, and 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.
- */
-declare const fieldMeta: z.core.$ZodRegistry<FieldMetaPayload, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * 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 };
+export { useForm };