attaform 0.27.6 → 0.29.0

package/dist/index.cjs

@@ -1,51 +0,0 @@
-'use strict';
-
-const devtoolsShared = require('./shared/attaform.Biytrv0-.cjs');
-const serializeScript = require('./shared/attaform.DrvMscNX.cjs');
-const fieldMeta = require('./shared/attaform.B9Wyhfro.cjs');
-const registerProtocol = require('./shared/attaform.yUrz7C2z.cjs');
-
-
-
-exports.AttaformError = devtoolsShared.AttaformError;
-exports.DEVTOOLS_WINDOW_KEY = devtoolsShared.DEVTOOLS_WINDOW_KEY;
-exports.InvalidPathError = devtoolsShared.InvalidPathError;
-exports.InvalidUseFormConfigError = devtoolsShared.InvalidUseFormConfigError;
-exports.OutsideSetupError = devtoolsShared.OutsideSetupError;
-exports.ROOT_PATH = devtoolsShared.ROOT_PATH;
-exports.ROOT_PATH_KEY = devtoolsShared.ROOT_PATH_KEY;
-exports.RegistryNotInstalledError = devtoolsShared.RegistryNotInstalledError;
-exports.ReservedFormKeyError = devtoolsShared.ReservedFormKeyError;
-exports.SubmitErrorHandlerError = devtoolsShared.SubmitErrorHandlerError;
-exports.assignKey = devtoolsShared.assignKey;
-exports.canonicalizePath = devtoolsShared.canonicalizePath;
-exports.createAttaform = devtoolsShared.createAttaform;
-exports.createRegistry = devtoolsShared.createRegistry;
-exports.getRegistryFromApp = devtoolsShared.getRegistryFromApp;
-exports.hydrateAttaformState = devtoolsShared.hydrateAttaformState;
-exports.isPathPrefix = devtoolsShared.isPathPrefix;
-exports.kAttaformRegistry = devtoolsShared.kAttaformRegistry;
-exports.parseDottedPath = devtoolsShared.parseDottedPath;
-exports.renderAttaformState = devtoolsShared.renderAttaformState;
-exports.useRegistry = devtoolsShared.useRegistry;
-exports.vRegister = devtoolsShared.vRegister;
-exports.AttaformErrorCode = serializeScript.AttaformErrorCode;
-exports.DEFAULT_TIMINGS = serializeScript.DEFAULT_TIMINGS;
-exports.defaultCoercionRules = serializeScript.defaultCoercionRules;
-exports.defaultDisplayState = serializeScript.defaultDisplayState;
-exports.defineCoercion = serializeScript.defineCoercion;
-exports.escapeForInlineScript = serializeScript.escapeForInlineScript;
-exports.gate = serializeScript.gate;
-exports.injectForm = serializeScript.injectForm;
-exports.injectWizard = serializeScript.injectWizard;
-exports.isUnset = serializeScript.isUnset;
-exports.lazy = serializeScript.lazy;
-exports.makeDefaultDisplayState = serializeScript.makeDefaultDisplayState;
-exports.unset = serializeScript.unset;
-exports.useRegister = serializeScript.useRegister;
-exports.useWizard = serializeScript.useWizard;
-exports.fieldMeta = fieldMeta.fieldMeta;
-exports.useForm = fieldMeta.useForm;
-exports.withMeta = fieldMeta.withMeta;
-exports.isRegisterValue = registerProtocol.isRegisterValue;
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.cts

@@ -1,249 +0,0 @@
-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, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard, a3 as vRegister } from './shared/attaform.FmqKO1Ex.cjs';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ae as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, o as FieldMetaPayload } from './shared/attaform.DniawQLP.cjs';
-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, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, 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, ad as ValidateOn, 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.DniawQLP.cjs';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.BGDV42hI.cjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.BGDV42hI.cjs';
-import { S as SupportedRootSchema$1, U as UnwrapZodRoot, a as StorageShape$1 } from './shared/attaform.DRUT703x.cjs';
-import { z } from 'zod';
-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 { DefaultValuesInput, FieldMetaPayload, FormKey, GenericForm, UseFormConfiguration, UseFormReturnType, ValidateOnConfig, fieldMeta, useForm, withMeta };
-export type { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4 };

package/dist/index.d.ts

@@ -1,249 +0,0 @@
-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, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard, a3 as vRegister } from './shared/attaform.F2Q8iv38.js';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ae as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, o as FieldMetaPayload } from './shared/attaform.DniawQLP.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, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, 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, ad as ValidateOn, 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.DniawQLP.js';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.Fp3sCrVs.js';
-export { P as PathInput, a as PathOutput } from './shared/attaform.Fp3sCrVs.js';
-import { S as SupportedRootSchema$1, U as UnwrapZodRoot, a as StorageShape$1 } from './shared/attaform.DRUT703x.js';
-import { z } from 'zod';
-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 { DefaultValuesInput, FieldMetaPayload, FormKey, GenericForm, UseFormConfiguration, UseFormReturnType, ValidateOnConfig, fieldMeta, useForm, withMeta };
-export type { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4 };

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/nuxt.cjs

@@ -1,84 +0,0 @@
-'use strict';
-
-const node_module = require('node:module');
-const node_path = require('node:path');
-const node_url = require('node:url');
-const kit = require('@nuxt/kit');
-const vite = require('./vite.cjs');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-const pkgVersion = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('nuxt.cjs', document.baseURI).href)))("../package.json").version;
-function isResolvableForVite(specifier, consumerRootDir) {
-  const consumerURL = node_url.pathToFileURL(node_path.join(consumerRootDir, "package.json")).href;
-  return canResolve(specifier, consumerURL) || canResolve(specifier, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('nuxt.cjs', document.baseURI).href)));
-}
-function canResolve(specifier, fromURL) {
-  try {
-    undefined(specifier, fromURL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var nuxt_default = kit.defineNuxtModule({
-  meta: {
-    name: "Attaform",
-    configKey: "attaform",
-    version: pkgVersion,
-    docs: "https://attaform.dev/docs",
-    compatibility: {
-      nuxt: ">=3.0.0"
-    }
-  },
-  defaults: {},
-  setup(_options, nuxt) {
-    var _a, _b;
-    kit.addVitePlugin(vite.attaform({ resolveZodAlias: _options.resolveZodAlias !== false }));
-    const runtimePublic = nuxt.options.runtimeConfig.public;
-    runtimePublic["attaform"] = {
-      defaults: _options.defaults ?? {},
-      version: pkgVersion
-    };
-    (_a = nuxt.options.vite).optimizeDeps ?? (_a.optimizeDeps = {});
-    (_b = nuxt.options.vite.optimizeDeps).include ?? (_b.include = []);
-    const include = nuxt.options.vite.optimizeDeps.include;
-    for (const spec of ["@vue/devtools-api", "zod"]) {
-      if (!isResolvableForVite(spec, nuxt.options.rootDir)) continue;
-      if (!include.includes(spec)) include.push(spec);
-    }
-    const resolver = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('nuxt.cjs', document.baseURI).href)));
-    if (_options.autoImports !== false) {
-      kit.addImports(vite.attaformAutoImports);
-    }
-    kit.addPlugin({
-      src: resolver.resolve("./runtime/plugins/attaform")
-    });
-    if (nuxt.options.dev) {
-      nuxt.hook("ready", async () => {
-        try {
-          const { addCustomTab } = await import('@nuxt/devtools-kit');
-          addCustomTab({
-            name: "attaform",
-            title: "Attaform",
-            // Brand mark — purple square with a white "A" silhouette,
-            // matching `apps/site/public/favicon.svg`. Served by the
-            // `attaform/vite` middleware at the same `/_attaform_devtools`
-            // route family (sibling to the panel HTML). A real URL
-            // renders reliably across Nuxt DevTools versions where
-            // `data:` URIs don't.
-            icon: "/_attaform_devtools/icon.svg",
-            view: {
-              type: "iframe",
-              src: "/_attaform_devtools",
-              persistent: true
-            }
-          });
-        } catch {
-        }
-      });
-    }
-  }
-});
-
-module.exports = nuxt_default;
-//# sourceMappingURL=nuxt.cjs.map