attaform 0.26.0 → 0.27.1

package/dist/zod.d.mts

@@ -1,249 +1,7 @@
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType, D as DefaultValuesInput, q as FieldMetaPayload } from './shared/attaform.DBNjHgNj.mjs';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DBNjHgNj.mjs';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.B71rfNL5.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.B71rfNL5.mjs';
-import { S as SupportedRootSchema$1, U as UnwrapZodRoot, a as StorageShape$1 } from './shared/attaform.DdjDqTah.mjs';
-import { z } from 'zod';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.CEY_WLRJ.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, I as InjectWizardInput, h as InvalidPathError, i as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, j as ReservedFormKeyError, S as SerializedAttaformState, k as SerializedFormData, l as StepSlot, m as SubmitErrorHandlerError, U as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as defaultCoercionRules, G as defaultDisplayState, H as defineCoercion, J as escapeForInlineScript, K as getRegistryFromApp, M as hydrateAttaformState, N as injectForm, P as injectWizard, Q as isRegisterValue, T as kAttaformRegistry, V as lazy, X as makeDefaultDisplayState, Y as renderAttaformState, Z as useRegister, _ as useRegistry, $ as useWizard, a0 as vRegister } from './shared/attaform.kBkYlKP_.mjs';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, F as FormKey, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryConfig, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as PartialFlatPath, S as Path, T as PathKey, V as PendingValidationStatus, W as Primitive, X as ROOT_PATH, Y as ROOT_PATH_KEY, Z as ReactiveValidationStatus, _ as RegisterDirective, $ as RegisterFlatPath, a0 as RegisterOptions, a1 as RegisterSelectModifier, a2 as RegisterTextModifier, a3 as RegisterTransform, a4 as RegisterValue, a5 as Segment, a6 as SetValueCallback, a7 as SetValuePayload, a8 as SettledValidationStatus, a9 as SlimPrimitiveKind, aa as SlimRuntimeOf, ab as SubmitHandler, ac as Unset, U as UseFormConfiguration, a as UseFormReturnType, ad as ValidateOn, ae as ValidateOnConfig, af as ValidationError, ag as ValidationResponse, ah as ValidationResponseWithoutValue, ai as ValueOfUnion, aj as WriteMeta, ak as WriteShape, al as canonicalizePath, am as isPathPrefix, an as isUnset, ao as parseDottedPath, ap as unset } from './shared/attaform.C3WnCDXz.mjs';
+export { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4, fieldMeta, useForm, withMeta } from './index.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.CvVYOvZF.mjs';
 import 'vue';
-
-/**
- * Type-level Zod-major discriminator for the unified `attaform/zod`
- * entry. The runtime dispatch (`use-form.ts`'s impl) already routes on
- * the schema's shape via `isZodV4SchemaShape`; this is the type-level
- * mirror so the overloads and projection helpers discriminate the same
- * way.
- *
- * Why a structural marker instead of `z.ZodObject`: the unified entry's
- * overloads constrain on `z.ZodObject`, but the published `.d.mts`
- * resolves `z` against whichever single Zod major the consumer
- * installed. In a v3-only install `z.ZodObject` is v3's `ZodObject`
- * (and, lacking its required type arguments, degrades to an `any`-like
- * error type under `skipLibCheck`), so a v3 schema satisfies the v4
- * overload's constraint and binds it — collapsing the read slot to
- * `never`. A Zod v4 schema carries the `_zod` internals brand; a v3
- * schema never does.
- * Intersecting a v4-only constraint or conditional branch with this
- * marker keeps it unreachable for a v3 schema regardless of how `zod`
- * resolves, so v3 schemas fall through to the v3 overload.
- *
- * Distinct from `core/zod-shape.ts`'s runtime `ZodV4Shape` (which reads
- * the public `def` getter): at the type level the stable v4 brand is
- * `_zod.def`, the same internals `StorageShape` (v4) already reads.
- *
- * Pairing requirement: a v4 overload/branch must constrain on
- * `z.ZodObject<z.ZodRawShape> & ZodV4Internals`, NOT bare
- * `z.ZodObject & ZodV4Internals`. In a v3-only install `z.ZodObject`
- * with no type argument is `ZodObject<T, ...>` missing its required
- * arguments — an error type that behaves like `any` under
- * `skipLibCheck`, so `any & ZodV4Internals` collapses back to `any` and
- * the marker stops excluding v3 schemas. Supplying `z.ZodRawShape`
- * keeps it a concrete object type in both majors, so the intersection
- * stays meaningful.
- */
-type ZodV4Internals = {
-    _zod: {
-        def: unknown;
-    };
-};
-
-/**
- * Per-major projection helpers shared by the unified `attaform/zod`
- * entry. Each maps an arbitrary Zod v4 OR v3 object schema to the
- * `GenericForm`-shaped input / output / storage-read projections the
- * form types are parameterised over. The constraint on each alias scopes
- * `S` to one Zod major, so the projection is a direct read with no
- * dispatch in the type body.
- *
- * Hoisted out of `types-unified.ts` and `use-form.ts` so the two entry
- * points share one definition. Internal — consumer code never reaches
- * for these; the overloaded `useForm` already gives full inference at
- * call sites.
- */
-
-/**
- * The schema's own input type, exactly as a consumer would reference it
- * (`z.input<S>`) — NOT routed through `GenericForm` / `UnwrapZodRoot`. This
- * is the reflexive escape arm `AcceptableDefaults` adds to the
- * `defaultValues` slot so a generic form wrapper forwarding `z.input<S>`
- * type-checks under a free `S` (#422). It must stay syntactically identical
- * to what the wrapper forwards: wrapping it in a conditional makes it a
- * deferred conditional that no longer matches the forwarded value under a
- * generic. Wrong-major schemas can't actually bind the slot — they are
- * rejected at the overload's `schema` constraint — so the raw input never
- * widens the slot for the wrong major.
- */
-type V4SchemaInput<S extends SupportedRootSchema> = z.input<S>;
-type V3SchemaInput<S extends SupportedRootSchema$1> = z.input<S>;
-type V4FormOf<S extends SupportedRootSchema> = z.input<S> extends GenericForm ? z.input<S> : never;
-type V4OutOf<S extends SupportedRootSchema> = z.output<S> extends GenericForm ? z.output<S> : never;
-type V4ReadOf<S extends SupportedRootSchema> = StorageShape<S> extends GenericForm ? StorageShape<S> : never;
-type V3FormOf<S extends SupportedRootSchema$1> = z.input<UnwrapZodRoot<S>> extends GenericForm ? z.input<UnwrapZodRoot<S>> : never;
-type V3OutOf<S extends SupportedRootSchema$1> = z.output<UnwrapZodRoot<S>> extends GenericForm ? z.output<UnwrapZodRoot<S>> : never;
-type V3ReadOf<S extends SupportedRootSchema$1> = StorageShape$1<UnwrapZodRoot<S>> extends GenericForm ? StorageShape$1<UnwrapZodRoot<S>> : never;
-
-/**
- * Create a form bound to a Zod v4 schema.
- *
- * ```ts
- * import { useForm } from 'attaform/zod'
- * import { z } from 'zod'
- *
- * const form = useForm({
- *   schema: z.object({
- *     username: z.string().min(2, 'At least 2 characters'),
- *     password: z.string().min(8, 'At least 8 characters'),
- *   }),
- * })
- * ```
- *
- * The constraint intersects `ZodV4Internals` (the v4-only `_zod`
- * brand) so a v3 schema can't bind this overload even when `z`
- * resolves to v3 in a single-major consumer install; v3 schemas fall
- * through to the v3 overload below. See `types-zod-major.ts`.
- */
-declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
-    schema: Schema;
-    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>;
-} & ValidateOnConfig): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
-/**
- * Create a form bound to a Zod v3 schema.
- *
- * ```ts
- * import { useForm } from 'attaform/zod'
- * import { z } from 'zod-v3'
- *
- * const form = useForm({
- *   schema: z.object({
- *     username: z.string().min(2, 'At least 2 characters'),
- *     password: z.string().min(8, 'At least 8 characters'),
- *   }),
- * })
- * ```
- *
- * v3 schemas match this overload; v4 schemas hit the v4 overload
- * above first and never reach here.
- */
-declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
-    schema: Schema;
-    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>;
-} & ValidateOnConfig): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
-
-/**
- * Type-level helpers for the unified `attaform/zod` entry. These give
- * tests and other type-query call sites a deterministic projection
- * over an arbitrary v4 OR v3 schema, sidestepping the brittle
- * instantiation-expression resolution rules TypeScript applies to
- * overloaded functions (`typeof useForm<X>` can pick the wrong
- * overload or the impl signature, depending on whether the type
- * argument is a concrete schema, a generic, or a constraint).
- *
- * The helpers dispatch ONCE per use site via a binary conditional —
- * no stacking, no amplification across the return type. Equivalent
- * to writing `ReturnType<typeof useForm<S>>` but cache-stable across
- * call patterns.
- *
- * Per `inference-first DX`, these helpers are test- and
- * internal-facing. Consumer code shouldn't reach for them — the
- * overloaded `useForm` already gives full inference at call sites.
- */
-
-/**
- * Direct V4 projection — no major-dispatch. Use when the schema's
- * Zod major is known statically (typical for V4 generic helpers like
- * `function setup<S extends z.ZodObject>(s: S)`). TS simplifies the
- * helper cleanly under generic constraints because no conditional
- * is present.
- */
-type UseFormReturnV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
-/**
- * Direct V4 configuration projection. Mirrors `UseFormReturnV4`.
- */
-type UseFormConfigV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig;
-/**
- * Direct V3 projection — no major-dispatch. Use when the schema's
- * Zod major is known statically.
- */
-type UseFormReturnV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey> = UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
-/**
- * Direct V3 configuration projection. Mirrors `UseFormReturnV3`.
- */
-type UseFormConfigV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig;
-/**
- * The return shape of `useForm` for a given Zod schema. Dispatches
- * once on the schema's major version and projects to the matching
- * adapter's `Form` / `Out` / `Read` slots. The dispatch matches the
- * full `SupportedRootSchema` per major, so an object, record, or
- * discriminated-union root all resolve here exactly as the runtime
- * `useForm` overloads accept them.
- *
- * Replaces `ReturnType<typeof useForm<Schema, K>>` in test code with
- * concrete schemas. For generic helpers (`<S extends z.ZodObject>`),
- * use `UseFormReturnV4<S>` directly — TS doesn't simplify
- * conditional types under generic constraints, so the dispatch in
- * this helper stays deferred and TS can't prove return-type
- * compatibility.
- */
-type UseFormReturn<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K> : Schema extends SupportedRootSchema$1 ? UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K> : never;
-/**
- * The configuration parameter shape of `useForm` for a given Zod
- * schema. Mirrors `UseFormReturn`'s dispatch — replaces
- * `Parameters<typeof useForm<Schema, K>>[0]` in test code.
- */
-type UseFormConfig<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig : Schema extends SupportedRootSchema$1 ? Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig : never;
-
-/**
- * Field-metadata write/read API for the unified `attaform/zod` entry.
- *
- * Storage is shared with both adapters via `field-meta-store` — a
- * payload written here is visible to whichever adapter the unified
- * `useForm` dispatches to at runtime, regardless of Zod major. No
- * `zod` runtime import; the type-only `import type` is erased at
- * build, so `attaform/zod` carries no `z.registry` reference even
- * when consumed by a Zod 3 project without the Vite plugin alias.
- *
- * The native v4 chain `schema.register(fieldMeta, payload)` continues
- * to work — Zod 4's `.register()` only calls `.add(this, payload)`
- * structurally, satisfied by the shared store.
- */
-
-type ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>;
-/**
- * The shared registry every Attaform-aware Zod schema can register
- * field metadata against, regardless of major. Same instance the v3
- * and v4 adapter entries expose — write in one place, read from
- * any.
- *
- * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native
- * `schema.register(fieldMeta, payload)` chain type-checks for v4
- * users; the runtime call only needs `.add` structurally, which the
- * shared store provides.
- */
-declare const fieldMeta: ZodFieldMetaRegistry;
-/**
- * Attach `payload` to `schema` in the shared registry and return a
- * clone of `schema` so each call gets its own identity (the registry
- * keys on schema reference, so cloning prevents last-write-wins
- * collisions for sub-schemas reused at multiple paths).
- *
- * Works on both Zod 3 and Zod 4 schemas — branches on the runtime
- * shape of the schema:
- * - Zod 4 schemas expose a public `.clone()` method; we call it.
- * - Zod 3 schemas don't, so we reconstruct via
- *   `new schema.constructor(schema._def)`.
- *
- * Both forms produce a fresh schema with the same effective
- * structure, so the registry slot is unique to this call site.
- */
-declare function withMeta<S>(schema: S, payload: FieldMetaPayload): S;
-
-export { FieldMetaPayload, fieldMeta, useForm, withMeta };
-export type { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4 };
+import './shared/attaform.DRUT703x.mjs';
+import 'zod';

package/dist/zod.d.ts

@@ -1,249 +1,7 @@
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType, D as DefaultValuesInput, q as FieldMetaPayload } from './shared/attaform.DBNjHgNj.js';
-export { ad as Unset, ao as isUnset, aq as unset } from './shared/attaform.DBNjHgNj.js';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.Be5otUVw.js';
-export { P as PathInput, a as PathOutput } from './shared/attaform.Be5otUVw.js';
-import { S as SupportedRootSchema$1, U as UnwrapZodRoot, a as StorageShape$1 } from './shared/attaform.DdjDqTah.js';
-import { z } from 'zod';
-export { b as AnyForm, c as AttaformErrorCode, C as CompiledStep, F as FormStatus, I as InjectWizardInput, L as LazyMarker, d as StepSlot, U as UseRegisterReturn, e as UseWizardReturnType, W as WizardAggregateError, f as WizardCtx, g as WizardCtxForm, h as WizardOnError, i as WizardOnSubmit, j as WizardOptions, k as WizardPersistFn, l as WizardRestoreFn, m as WizardRestoreState, n as WizardStatusesProxy, o as WizardSubmitContext, t as injectForm, u as injectWizard, w as lazy, x as useRegister, z as useWizard } from './shared/attaform.ceYeVkjn.js';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, I as InjectWizardInput, h as InvalidPathError, i as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, j as ReservedFormKeyError, S as SerializedAttaformState, k as SerializedFormData, l as StepSlot, m as SubmitErrorHandlerError, U as UseRegisterReturn, n as UseWizardReturnType, W as WizardAggregateError, o as WizardCtx, p as WizardCtxForm, q as WizardOnError, r as WizardOnSubmit, s as WizardOptions, t as WizardPersistFn, u as WizardRestoreFn, v as WizardRestoreState, w as WizardStatusesProxy, x as WizardSubmitContext, y as assignKey, z as createAttaform, B as createRegistry, E as defaultCoercionRules, G as defaultDisplayState, H as defineCoercion, J as escapeForInlineScript, K as getRegistryFromApp, M as hydrateAttaformState, N as injectForm, P as injectWizard, Q as isRegisterValue, T as kAttaformRegistry, V as lazy, X as makeDefaultDisplayState, Y as renderAttaformState, Z as useRegister, _ as useRegistry, $ as useWizard, a0 as vRegister } from './shared/attaform.CEXUlUkc.js';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, F as FormKey, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryConfig, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as PartialFlatPath, S as Path, T as PathKey, V as PendingValidationStatus, W as Primitive, X as ROOT_PATH, Y as ROOT_PATH_KEY, Z as ReactiveValidationStatus, _ as RegisterDirective, $ as RegisterFlatPath, a0 as RegisterOptions, a1 as RegisterSelectModifier, a2 as RegisterTextModifier, a3 as RegisterTransform, a4 as RegisterValue, a5 as Segment, a6 as SetValueCallback, a7 as SetValuePayload, a8 as SettledValidationStatus, a9 as SlimPrimitiveKind, aa as SlimRuntimeOf, ab as SubmitHandler, ac as Unset, U as UseFormConfiguration, a as UseFormReturnType, ad as ValidateOn, ae as ValidateOnConfig, af as ValidationError, ag as ValidationResponse, ah as ValidationResponseWithoutValue, ai as ValueOfUnion, aj as WriteMeta, ak as WriteShape, al as canonicalizePath, am as isPathPrefix, an as isUnset, ao as parseDottedPath, ap as unset } from './shared/attaform.C3WnCDXz.js';
+export { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4, fieldMeta, useForm, withMeta } from './index.js';
+export { P as PathInput, a as PathOutput } from './shared/attaform.CC_y1_Ej.js';
 import 'vue';
-
-/**
- * Type-level Zod-major discriminator for the unified `attaform/zod`
- * entry. The runtime dispatch (`use-form.ts`'s impl) already routes on
- * the schema's shape via `isZodV4SchemaShape`; this is the type-level
- * mirror so the overloads and projection helpers discriminate the same
- * way.
- *
- * Why a structural marker instead of `z.ZodObject`: the unified entry's
- * overloads constrain on `z.ZodObject`, but the published `.d.mts`
- * resolves `z` against whichever single Zod major the consumer
- * installed. In a v3-only install `z.ZodObject` is v3's `ZodObject`
- * (and, lacking its required type arguments, degrades to an `any`-like
- * error type under `skipLibCheck`), so a v3 schema satisfies the v4
- * overload's constraint and binds it — collapsing the read slot to
- * `never`. A Zod v4 schema carries the `_zod` internals brand; a v3
- * schema never does.
- * Intersecting a v4-only constraint or conditional branch with this
- * marker keeps it unreachable for a v3 schema regardless of how `zod`
- * resolves, so v3 schemas fall through to the v3 overload.
- *
- * Distinct from `core/zod-shape.ts`'s runtime `ZodV4Shape` (which reads
- * the public `def` getter): at the type level the stable v4 brand is
- * `_zod.def`, the same internals `StorageShape` (v4) already reads.
- *
- * Pairing requirement: a v4 overload/branch must constrain on
- * `z.ZodObject<z.ZodRawShape> & ZodV4Internals`, NOT bare
- * `z.ZodObject & ZodV4Internals`. In a v3-only install `z.ZodObject`
- * with no type argument is `ZodObject<T, ...>` missing its required
- * arguments — an error type that behaves like `any` under
- * `skipLibCheck`, so `any & ZodV4Internals` collapses back to `any` and
- * the marker stops excluding v3 schemas. Supplying `z.ZodRawShape`
- * keeps it a concrete object type in both majors, so the intersection
- * stays meaningful.
- */
-type ZodV4Internals = {
-    _zod: {
-        def: unknown;
-    };
-};
-
-/**
- * Per-major projection helpers shared by the unified `attaform/zod`
- * entry. Each maps an arbitrary Zod v4 OR v3 object schema to the
- * `GenericForm`-shaped input / output / storage-read projections the
- * form types are parameterised over. The constraint on each alias scopes
- * `S` to one Zod major, so the projection is a direct read with no
- * dispatch in the type body.
- *
- * Hoisted out of `types-unified.ts` and `use-form.ts` so the two entry
- * points share one definition. Internal — consumer code never reaches
- * for these; the overloaded `useForm` already gives full inference at
- * call sites.
- */
-
-/**
- * The schema's own input type, exactly as a consumer would reference it
- * (`z.input<S>`) — NOT routed through `GenericForm` / `UnwrapZodRoot`. This
- * is the reflexive escape arm `AcceptableDefaults` adds to the
- * `defaultValues` slot so a generic form wrapper forwarding `z.input<S>`
- * type-checks under a free `S` (#422). It must stay syntactically identical
- * to what the wrapper forwards: wrapping it in a conditional makes it a
- * deferred conditional that no longer matches the forwarded value under a
- * generic. Wrong-major schemas can't actually bind the slot — they are
- * rejected at the overload's `schema` constraint — so the raw input never
- * widens the slot for the wrong major.
- */
-type V4SchemaInput<S extends SupportedRootSchema> = z.input<S>;
-type V3SchemaInput<S extends SupportedRootSchema$1> = z.input<S>;
-type V4FormOf<S extends SupportedRootSchema> = z.input<S> extends GenericForm ? z.input<S> : never;
-type V4OutOf<S extends SupportedRootSchema> = z.output<S> extends GenericForm ? z.output<S> : never;
-type V4ReadOf<S extends SupportedRootSchema> = StorageShape<S> extends GenericForm ? StorageShape<S> : never;
-type V3FormOf<S extends SupportedRootSchema$1> = z.input<UnwrapZodRoot<S>> extends GenericForm ? z.input<UnwrapZodRoot<S>> : never;
-type V3OutOf<S extends SupportedRootSchema$1> = z.output<UnwrapZodRoot<S>> extends GenericForm ? z.output<UnwrapZodRoot<S>> : never;
-type V3ReadOf<S extends SupportedRootSchema$1> = StorageShape$1<UnwrapZodRoot<S>> extends GenericForm ? StorageShape$1<UnwrapZodRoot<S>> : never;
-
-/**
- * Create a form bound to a Zod v4 schema.
- *
- * ```ts
- * import { useForm } from 'attaform/zod'
- * import { z } from 'zod'
- *
- * const form = useForm({
- *   schema: z.object({
- *     username: z.string().min(2, 'At least 2 characters'),
- *     password: z.string().min(8, 'At least 8 characters'),
- *   }),
- * })
- * ```
- *
- * The constraint intersects `ZodV4Internals` (the v4-only `_zod`
- * brand) so a v3 schema can't bind this overload even when `z`
- * resolves to v3 in a single-major consumer install; v3 schemas fall
- * through to the v3 overload below. See `types-zod-major.ts`.
- */
-declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
-    schema: Schema;
-    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>;
-} & ValidateOnConfig): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
-/**
- * Create a form bound to a Zod v3 schema.
- *
- * ```ts
- * import { useForm } from 'attaform/zod'
- * import { z } from 'zod-v3'
- *
- * const form = useForm({
- *   schema: z.object({
- *     username: z.string().min(2, 'At least 2 characters'),
- *     password: z.string().min(8, 'At least 8 characters'),
- *   }),
- * })
- * ```
- *
- * v3 schemas match this overload; v4 schemas hit the v4 overload
- * above first and never reach here.
- */
-declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
-    schema: Schema;
-    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>;
-} & ValidateOnConfig): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
-
-/**
- * Type-level helpers for the unified `attaform/zod` entry. These give
- * tests and other type-query call sites a deterministic projection
- * over an arbitrary v4 OR v3 schema, sidestepping the brittle
- * instantiation-expression resolution rules TypeScript applies to
- * overloaded functions (`typeof useForm<X>` can pick the wrong
- * overload or the impl signature, depending on whether the type
- * argument is a concrete schema, a generic, or a constraint).
- *
- * The helpers dispatch ONCE per use site via a binary conditional —
- * no stacking, no amplification across the return type. Equivalent
- * to writing `ReturnType<typeof useForm<S>>` but cache-stable across
- * call patterns.
- *
- * Per `inference-first DX`, these helpers are test- and
- * internal-facing. Consumer code shouldn't reach for them — the
- * overloaded `useForm` already gives full inference at call sites.
- */
-
-/**
- * Direct V4 projection — no major-dispatch. Use when the schema's
- * Zod major is known statically (typical for V4 generic helpers like
- * `function setup<S extends z.ZodObject>(s: S)`). TS simplifies the
- * helper cleanly under generic constraints because no conditional
- * is present.
- */
-type UseFormReturnV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
-/**
- * Direct V4 configuration projection. Mirrors `UseFormReturnV4`.
- */
-type UseFormConfigV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig;
-/**
- * Direct V3 projection — no major-dispatch. Use when the schema's
- * Zod major is known statically.
- */
-type UseFormReturnV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey> = UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
-/**
- * Direct V3 configuration projection. Mirrors `UseFormReturnV3`.
- */
-type UseFormConfigV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey> = Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig;
-/**
- * The return shape of `useForm` for a given Zod schema. Dispatches
- * once on the schema's major version and projects to the matching
- * adapter's `Form` / `Out` / `Read` slots. The dispatch matches the
- * full `SupportedRootSchema` per major, so an object, record, or
- * discriminated-union root all resolve here exactly as the runtime
- * `useForm` overloads accept them.
- *
- * Replaces `ReturnType<typeof useForm<Schema, K>>` in test code with
- * concrete schemas. For generic helpers (`<S extends z.ZodObject>`),
- * use `UseFormReturnV4<S>` directly — TS doesn't simplify
- * conditional types under generic constraints, so the dispatch in
- * this helper stays deferred and TS can't prove return-type
- * compatibility.
- */
-type UseFormReturn<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K> : Schema extends SupportedRootSchema$1 ? UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K> : never;
-/**
- * The configuration parameter shape of `useForm` for a given Zod
- * schema. Mirrors `UseFormReturn`'s dispatch — replaces
- * `Parameters<typeof useForm<Schema, K>>[0]` in test code.
- */
-type UseFormConfig<Schema, K extends FormKey = FormKey> = Schema extends SupportedRootSchema & ZodV4Internals ? Omit<UseFormConfiguration<V4FormOf<Schema>, V4OutOf<Schema>, AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>, DefaultValuesInput<V4FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig : Schema extends SupportedRootSchema$1 ? Omit<UseFormConfiguration<V3FormOf<Schema>, V3OutOf<Schema>, AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>, DefaultValuesInput<V3FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
-    schema: Schema;
-} & ValidateOnConfig : never;
-
-/**
- * Field-metadata write/read API for the unified `attaform/zod` entry.
- *
- * Storage is shared with both adapters via `field-meta-store` — a
- * payload written here is visible to whichever adapter the unified
- * `useForm` dispatches to at runtime, regardless of Zod major. No
- * `zod` runtime import; the type-only `import type` is erased at
- * build, so `attaform/zod` carries no `z.registry` reference even
- * when consumed by a Zod 3 project without the Vite plugin alias.
- *
- * The native v4 chain `schema.register(fieldMeta, payload)` continues
- * to work — Zod 4's `.register()` only calls `.add(this, payload)`
- * structurally, satisfied by the shared store.
- */
-
-type ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>;
-/**
- * The shared registry every Attaform-aware Zod schema can register
- * field metadata against, regardless of major. Same instance the v3
- * and v4 adapter entries expose — write in one place, read from
- * any.
- *
- * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native
- * `schema.register(fieldMeta, payload)` chain type-checks for v4
- * users; the runtime call only needs `.add` structurally, which the
- * shared store provides.
- */
-declare const fieldMeta: ZodFieldMetaRegistry;
-/**
- * Attach `payload` to `schema` in the shared registry and return a
- * clone of `schema` so each call gets its own identity (the registry
- * keys on schema reference, so cloning prevents last-write-wins
- * collisions for sub-schemas reused at multiple paths).
- *
- * Works on both Zod 3 and Zod 4 schemas — branches on the runtime
- * shape of the schema:
- * - Zod 4 schemas expose a public `.clone()` method; we call it.
- * - Zod 3 schemas don't, so we reconstruct via
- *   `new schema.constructor(schema._def)`.
- *
- * Both forms produce a fresh schema with the same effective
- * structure, so the registry slot is unique to this call site.
- */
-declare function withMeta<S>(schema: S, payload: FieldMetaPayload): S;
-
-export { FieldMetaPayload, fieldMeta, useForm, withMeta };
-export type { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4 };
+import './shared/attaform.DRUT703x.js';
+import 'zod';

package/dist/zod.mjs

@@ -1,43 +1,5 @@
-import { a as InvalidUseFormConfigError } from './shared/attaform.DGhIix5D.mjs';
-import { u as useForm$2 } from './shared/attaform.CSXDW2tO.mjs';
-import { u as useForm$1 } from './shared/attaform.DSOIz08n.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.CXVmZtFq.mjs';
-export { A as AttaformErrorCode, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, c as useRegister, d as useWizard } from './shared/attaform.BoYqnIPI.mjs';
-
-function isZodV4SchemaShape(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const def = value.def;
-  if (typeof def !== "object" || def === null) return false;
-  return typeof def.type === "string";
-}
-
-function useForm(configuration) {
-  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new InvalidUseFormConfigError();
-  }
-  const { schema } = configuration;
-  if (isZodV4SchemaShape(schema)) {
-    return useForm$1(configuration);
-  }
-  return useForm$2(configuration);
-}
-
-const fieldMeta = fieldMetaStore;
-function withMeta(schema, payload) {
-  const target = schema;
-  const existing = getFieldMetaForSchema(target) ?? {};
-  const cloned = cloneSchema(schema);
-  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);
-}
-
-export { fieldMeta, useForm, withMeta };
+export { A as AttaformError, D as DEVTOOLS_WINDOW_KEY, I as InvalidPathError, a as InvalidUseFormConfigError, O as OutsideSetupError, R as ROOT_PATH, b as ROOT_PATH_KEY, c as RegistryNotInstalledError, d as ReservedFormKeyError, S as SubmitErrorHandlerError, e as assignKey, f as canonicalizePath, g as createAttaform, h as createRegistry, i as getRegistryFromApp, j as hydrateAttaformState, k as isPathPrefix, l as kAttaformRegistry, p as parseDottedPath, r as renderAttaformState, u as useRegistry, v as vRegister } from './shared/attaform.Da8EdI2t.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, h as useRegister, j as useWizard } from './shared/attaform.CyQxTOdX.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.DkD0DR7R.mjs';
+export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
 //# sourceMappingURL=zod.mjs.map

package/dist/zod.mjs.map

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

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "attaform",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [
-    "dist"
+    "dist",
+    "skills",
+    "bin"
   ],
+  "bin": {
+    "attaform": "./bin/attaform.mjs"
+  },
   "sideEffects": false,
   "engines": {
     "node": ">=22.0.0"
@@ -75,6 +80,10 @@
       "types": "./dist/zod-v4.d.mts",
       "import": "./dist/zod-v4.mjs"
     },
+    "./abstract": {
+      "types": "./dist/abstract.d.mts",
+      "import": "./dist/abstract.mjs"
+    },
     "./types": {
       "types": "./dist/index.d.mts"
     }
@@ -203,6 +212,7 @@
     "check:coverage": "node scripts/run-with-webstorage-flag.mjs vitest run --coverage",
     "check:bench": "node scripts/check-bench.mjs",
     "check:bundled-types": "node scripts/check-bundled-types.mjs",
+    "check:doc-snippets": "node scripts/check-doc-snippets.mjs",
     "check:site": "pnpm dev:prepare && pnpm --filter attaform-site typecheck",
     "fallow": "DO_NOT_TRACK=1 FALLOW_TELEMETRY=0 npx --yes fallow@2.88.3 --score",
     "version": "node scripts/promote-changelog.mjs && (node scripts/generate-release-notes.mjs || echo '[version] release-notes step failed; continuing') && node scripts/sync-doc-versions.mjs && git add CHANGELOG.md RELEASES.md docs/scorecard/cii-best-practices-answers.md"