attaform 0.30.0 → 0.30.1

package/dist/zod-v4.d.mts

@@ -1,163 +1,163 @@
-import { S as SupportedRootSchema } from './shared/attaform.Rc9u4Vfw.mjs';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.Rc9u4Vfw.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 DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m 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 escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.UGyOK83T.mjs';
-import { F as FormKey, ap as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.bKLzMU0o.mjs';
+import { S as SupportedRootSchema } from './shared/attaform.2FslhB9R.mjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.2FslhB9R.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 DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m 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 escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.BcQwgWaq.mjs';
+import { F as FormKey, ap as SchemaFactoryOptions, h as FieldMetaPayload } from './shared/attaform.Br8EBn5B.mjs';
 import { AbstractSchema } from './abstract.mjs';
-export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, U as UseFormConfiguration, a as UseFormReturnType, ab as ValidateOn, ac as ValidateOnConfig, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.bKLzMU0o.mjs';
-export { v as vRegister } from './shared/attaform.Clz0ArIi.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, U as UseFormConfiguration, a as UseFormReturnType, ab as ValidateOn, ac as ValidateOnConfig, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.Br8EBn5B.mjs';
+export { v as vRegister } from './shared/attaform.L0kUn3vL.mjs';
 import { z } from 'zod';
 import 'vue';
 
 /**
- * Wrap a Zod v4 `ZodObject` schema in an `AbstractSchema` factory.
- *
- * Most consumers never call this directly — `useForm` from
- * `attaform/zod` does the wrapping automatically. Reach for
- * it when you need an adapter outside of `useForm` (e.g. validating
- * data with the same library used elsewhere in the form runtime, or
- * exposing the adapter to a custom integration).
- *
- * The returned factory accepts per-form `SchemaFactoryOptions` (notably
- * `maxRecursionDepth`); the adapter closure bakes them into every
- * downstream walk so a per-form override can lift the cap for that
- * form alone.
- *
- * Throws if the schema isn't Zod v4, or if its root is not a shape
- * that can hold keys. No kind is refused anywhere BELOW the root: a
- * leaf the walkers have no case for is carried opaquely rather than
- * rejected, so a schema a newer Zod can parse is one Attaform can
- * mount. Recursive `z.lazy(...)` is supported — the runtime walks
- * bound their descent via `maxRecursionDepth`.
+ * The Zod v4 adapter: `AbstractSchema` implemented against Zod v4's
+ * public surface. Internal `def.*` access is quarantined to
+ * `introspect.ts` and the modules beside it (default-values,
+ * path-walker, discriminator, errors), leaving this file as the wiring
+ * between them and the `AbstractSchema` contract.
+ *
+ * It holds parity with the v3 adapter on three fronts:
+ * `getDefaultValues`' validate-then-fix loop, delegated to
+ * `default-values.ts`, with a DU-aware first-option fallback for
+ * invalid_type issues; `getSchemasAtPath`' DU-aware path walk; and
+ * `validateAtPath`'s per-branch parse with aggregated errors.
+ */
+
+/**
+ * Wrap a Zod v4 schema in an `AbstractSchema` factory.
+ *
+ * `useForm` from `attaform/zod` does this for you, so reach for it to
+ * use the adapter outside `useForm`: validating data with the same
+ * library the form runtime uses, or handing the adapter to a custom
+ * integration. The factory it returns takes per-form
+ * `SchemaFactoryOptions`, and the adapter closure bakes them into every
+ * downstream walk, so `maxRecursionDepth` can be lifted for one form
+ * alone.
+ *
+ * Throws if the schema is not Zod v4, or if its root cannot hold keys.
+ * No kind is refused anywhere BELOW the root: a leaf the walkers have no
+ * case for is carried opaquely rather than rejected, so a schema a newer
+ * Zod can parse is one Attaform can mount. Recursive `z.lazy(...)`
+ * works, its descent bounded by `maxRecursionDepth`.
  */
 declare function zodV4Adapter<FormSchema extends SupportedRootSchema, Form extends z.input<FormSchema>, GetValueFormType extends z.output<FormSchema> = z.output<FormSchema>>(rootSchema: FormSchema): (formKey: FormKey, options: SchemaFactoryOptions) => AbstractSchema<Form, GetValueFormType>;
 
 /**
- * The single file that reads Zod v4's internal `def` shape. Every other
- * file in the zod-v4 adapter uses these public-shaped accessors — future
- * Zod minor bumps that reshape internals touch only this file.
- *
- * Design principle: treat `schema.def.*` as an unstable surface, even when
- * Zod's docs say otherwise. Each helper returns a narrow, well-typed slice;
- * no adapter code outside this file does shape-based pattern matching on
- * `def`.
+ * The ONE file that reads Zod v4's internal `def` shape. Every other file
+ * in the adapter goes through these public-shaped accessors, so a Zod
+ * minor bump that reshapes internals touches only this file.
+ *
+ * Treat `schema.def.*` as unstable whatever Zod's docs say. Each helper
+ * returns a narrow, well-typed slice, and no adapter code outside this
+ * file pattern-matches on `def`.
  */
 
 /**
- * Stable kind discriminant for a Zod v4 schema. Returned by
- * `kindOf(schema)`. Use when building a custom integration that
- * needs to branch on schema shape — most consumers don't need this.
+ * Stable kind discriminant for a Zod v4 schema, returned by `kindOf`.
+ * Reach for it in a custom integration that branches on schema shape.
  */
 type ZodKind = 'object' | 'array' | 'set' | 'record' | 'tuple' | 'union' | 'discriminated-union' | 'string' | 'number' | 'boolean' | 'bigint' | 'date' | 'enum' | 'literal' | 'null' | 'undefined' | 'any' | 'unknown' | 'optional' | 'nullable' | 'default' | 'pipe' | 'readonly' | 'nan' | 'void' | 'never' | 'lazy' | 'intersection' | 'catch' | 'promise' | 'custom' | 'template-literal' | 'transform' | 'file' | 'nonoptional' | 'success' | 'map' | 'symbol' | 'function';
 /**
- * Inspect a Zod v4 schema and return its `ZodKind`. Returns
- * `'unknown'` for non-Zod inputs and unrecognised shapes.
- *
- * Useful when writing introspection helpers that branch on schema
- * structure (e.g. custom error formatters or doc generators).
+ * The `ZodKind` of a Zod v4 schema; `'unknown'` for a non-Zod input or an
+ * unrecognised shape. Useful in an introspection helper that branches on
+ * structure, a custom error formatter or a doc generator.
  */
 declare function kindOf(schema: unknown): ZodKind;
 /**
- * Verify a schema is Zod v4. Throws a clear error if it's a v3
- * schema mistakenly imported through `attaform/zod`.
- *
- * Most consumers never call this directly — the v4 adapter calls it
- * internally on every schema. Reach for it only when wiring a custom
- * adapter that needs the same guard.
+ * Verify a schema is Zod v4, throwing a clear error for a v3 schema
+ * imported through `attaform/zod` by mistake. The adapter calls it on
+ * every schema; reach for it directly only in a custom adapter that
+ * wants the same guard.
  */
 declare function assertZodVersion(schema: unknown): void;
 
 /**
- * Field-metadata write/read API for the Zod v4 adapter.
- *
- * Storage lives in the shared `field-meta-store` core — every entry
- * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) writes to and
- * reads from the same `WeakMap`s, so a payload registered via any
- * entry surfaces at lookup regardless of which adapter actually runs.
+ * Field-metadata write and read API for the Zod v4 adapter.
  *
- * The native chain `schema.register(fieldMeta, payload)` still works
- * — Zod 4's `.register` calls `registry.add(this, payload)` and
- * returns the schema; the shared store satisfies that structurally.
+ * Storage lives in the shared `core/field-meta-store`, where every entry
+ * (`attaform/zod`, `attaform/zod-v3`, `attaform/zod-v4`) reads and
+ * writes the same `WeakMap`s, so a payload registered through any of
+ * them surfaces at lookup whichever adapter runs. The native chain
+ * `schema.register(fieldMeta, payload)` works too: Zod 4's `.register`
+ * calls `registry.add(this, payload)` and returns the schema, which the
+ * shared store satisfies structurally.
  *
- * **Registration patterns:** both styles work — register on whatever
- * schema reference you assign into the parent's shape, OR on the
- * inner schema before wrapping. The adapter's resolver tries the
- * walker-returned schema first, then falls back to the peeled
- * inner so either ordering hits:
+ * **Registration order does not matter.** Register on the schema
+ * reference assigned into the parent's shape, or on the inner schema
+ * before wrapping:
  *
- *     // both equivalent — registry hits at lookup time
+ *     // equivalent; all four hit at lookup time
  *     withMeta(z.string(), { label: 'Email' }).optional()
  *     withMeta(z.string().optional(), { label: 'Email' })
  *     z.string().optional().register(fieldMeta, { label: 'Email' })
  *     z.string().register(fieldMeta, { label: 'Email' }).optional()
  *
- * The path walker returns the wrapper at terminal positions
- * (`['email']` against `{ email: z.string().optional() }` resolves
- * to `ZodOptional<ZodString>`) and peels at intermediate descent
- * (`['address', 'street']` peels through `address`'s wrapper to
- * reach the inner object). The two-stage lookup covers both leaf
- * and container registrations symmetrically.
+ * The path walker returns the wrapper at a terminal position, so
+ * `['email']` against `{ email: z.string().optional() }` resolves to
+ * `ZodOptional<ZodString>`, and peels at intermediate descent, so
+ * `['address', 'street']` goes through `address`'s wrapper to the inner
+ * object. The resolver tries the walker's schema before the peeled
+ * inner, so the two-stage lookup covers leaf and container
+ * registrations symmetrically.
  */
 
 type ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>;
 /**
- * The shared registry every Attaform-aware Zod 4 schema can register
- * field metadata against. Backed by the cross-adapter
- * `fieldMetaStore` — one module-scoped instance, shared with the v3
- * adapter and the unified `attaform/zod` entry, so a `.register()`
- * chain in one place is read by adapters in another.
- *
- * Consumers extending `FieldMetaPayload` via declaration merging
- * automatically get the richer payload type at every `register` /
- * `add` / `get` call site.
- *
- * **Shared-instance disambiguation.** A single schema instance reused
- * at multiple form paths (e.g. one address schema bound to both
- * `pickup` and `delivery`) can carry distinct metadata per path —
- * even via the canonical `schema.register(fieldMeta, payload)` chain.
- * The shared store keeps a parallel list of every registration; the
- * path-resolver walks the form's schema tree counting per-schema
- * occurrences to pick the right payload for each path. Object
- * literals evaluate left-to-right, so registration order matches
- * tree-walk order, and shared schemas pair their two registrations
- * to the two paths correctly:
+ * The shared registry an Attaform-aware Zod 4 schema registers field
+ * metadata against.
+ *
+ * ```ts
+ * import { fieldMeta } from 'attaform/zod'
+ *
+ * const schema = z.object({
+ *   email: z.string().register(fieldMeta, { label: 'Email address' }),
+ * })
+ * ```
+ *
+ * One module-scoped instance, shared with the v3 adapter and the
+ * unified `attaform/zod` entry, so a `.register()` chain written in one
+ * place is read by an adapter in another. Extending `FieldMetaPayload`
+ * by declaration merging gives the richer payload type at every
+ * `register` / `add` / `get` call site.
+ *
+ * **One schema instance can carry different metadata per path.** Reuse
+ * an address schema at both `pickup` and `delivery` and each keeps its
+ * own label, through the native chain included:
  *
  *     z.object({
  *       pickup: addressSchema.register(fieldMeta, { label: 'Pickup address' }),
  *       delivery: addressSchema.register(fieldMeta, { label: 'Delivery address' }),
  *     })
- *     // form.fields('pickup').label   → 'Pickup address'
- *     // form.fields('delivery').label → 'Delivery address'
- *
- * Schemas reused via `withMeta()` get a fresh clone per call (see
- * `withMeta` below), so they never share a registry slot in the
- * first place.
- *
- * Cast to `z.$ZodRegistry<FieldMetaPayload>` so that
- * `schema.register(fieldMeta, payload)` chains type-check at the call
- * site — Zod 4's `.register()` only calls `.add(this, payload)`
- * structurally, so the cast is sound at runtime.
- *
- * Backed by `installingFieldMetaStore`: every `add` also installs the
- * path-walking resolver into the shared store's builder slot, so the
- * walk's bytes ride this module's import instead of the adapter. A
- * consumer that never registers metadata never ships the walk.
+ *     // form.fields('pickup').label   -> 'Pickup address'
+ *     // form.fields('delivery').label -> 'Delivery address'
+ *
+ * The store keeps a parallel list of every registration, and the
+ * path-resolver walks the form's schema tree counting per-schema
+ * occurrences to pick the right payload per path. Object literals
+ * evaluate left to right, so registration order matches tree-walk order
+ * and the pairing holds. `withMeta()` never reaches this case at all,
+ * since it clones per call.
+ *
+ * The cast to the registry type is what lets `schema.register(fieldMeta,
+ * payload)` type-check at the call site; Zod 4's `.register()` only
+ * calls `.add(this, payload)`, so it is sound at runtime. Every `add`
+ * also installs the path-walking resolver into the shared store's
+ * builder slot, which is what makes the walk's bytes ride this module's
+ * import rather than the adapter: a consumer who never registers
+ * metadata never ships the walk.
  */
 declare const fieldMeta: ZodFieldMetaRegistry;
 /**
- * Attach `payload` to `schema` in the shared `fieldMeta` registry
- * and return `schema` (chainable). Cross-version with `attaform/zod-v3`'s
- * `withMeta()`; user code that uses this helper reads the same on
- * either adapter.
- *
- * Equivalent to `schema.register(fieldMeta, payload)` on Zod 4.
- * Prefer the native chain for v4-only code; reach for `withMeta`
- * when authoring schema modules that may need to compile under both
- * adapters.
- *
- * Registers on the schema reference passed in. See the
- * "Registration rule" note in this file's header — register on the
- * inner schema before wrapping with `.optional()` / `.nullable()` /
- * `.default()` / etc.
+ * Attach `payload` to `schema` in the shared `fieldMeta` registry and
+ * return a chainable CLONE of `schema` carrying it. It matches
+ * `attaform/zod-v3`'s `withMeta()`, so a schema module written with it
+ * reads the same under either adapter.
+ *
+ * For v4-only code prefer the native `schema.register(fieldMeta,
+ * payload)`, which registers on the instance you passed and returns
+ * that same instance. Reach for `withMeta` when the module has to
+ * compile under both adapters, or when one schema instance is reused at
+ * several paths and each needs its own payload: the clone per call is
+ * what gives each call site its own registry slot.
  */
 declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
 

package/dist/zod-v4.mjs

@@ -1,9 +1,9 @@
-export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.BXneBxEj.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.CUfrMK7t.mjs';
+export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.CO918TdU.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.DRsANMok.mjs';
 export { A as AttaformError, 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 canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.CdZIEf7_.mjs';
-export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNJOWjQw.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.BIWicztt.mjs';
 export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.WiGdIqgx.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.B3resMQ1.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.D_f1WgYf.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
 
 const fieldMeta = installingFieldMetaStore;

package/dist/zod.d.mts

@@ -1,8 +1,8 @@
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m 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 escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.UGyOK83T.mjs';
-export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, h as FieldMetaPayload, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, F as FormKey, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, U as UseFormConfiguration, a as UseFormReturnType, ab as ValidateOn, ac as ValidateOnConfig, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.bKLzMU0o.mjs';
-export { v as vRegister } from './shared/attaform.Clz0ArIi.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 DEVTOOLS_WINDOW_KEY, F as FormStatus, f as FormStatusSeed, G as GateMarker, I as InjectWizardInput, g as InvalidPathError, h as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, i as ReservedFormKeyError, S as SerializedAttaformState, j as SerializedFormData, k as StepSlot, l as SubmitErrorHandlerError, U as UseRegisterOptions, m 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 escapeForInlineScript, H as gate, J as getRegistryFromApp, K as hydrateAttaformState, M as injectForm, N as injectWizard, P as isRegisterValue, Q as kAttaformRegistry, T as lazy, V as renderAttaformState, X as useRegister, Y as useRegistry, Z as useWizard } from './shared/attaform.BcQwgWaq.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, D as DefaultValuesInput, e as DefaultValuesShape, f as DisplayState, E as ErrorInput, g as ErrorsProxyShape, h as FieldMetaPayload, i as FieldState, j as FieldStateMap, k as FieldStateMapEntry, l as FlatPath, m as FormErrorRecord, n as FormErrorsSurface, F as FormKey, o as FormMeta, G as GenericForm, H as HandleSubmit, p as HistoryPlugin, I as IsTuple, q as IsUnion, J as JoinSegments, r as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, s as NestedType, O as OnError, t as OnSubmit, P as ParseOptions, u as PartialFlatPath, v as Path, w as PathKey, x as PendingValidationStatus, y as Primitive, R as ROOT_PATH, z as ROOT_PATH_KEY, B as ReactiveValidationStatus, Q as RecordPath, S as RecordValue, T as RegisterDirective, V as RegisterFlatPath, W as RegisterOptions, X as RegisterSelectModifier, Y as RegisterTextModifier, Z as RegisterTransform, _ as RegisterValue, $ as SchemaDefaultsResult, a0 as SchemaParseErrorWithData, a1 as SchemaParseErrorWithoutData, a2 as SchemaParseResult, a3 as SchemaParseSuccess, a4 as Segment, a5 as SetValueCallback, a6 as SetValuePayload, a7 as SettledValidationStatus, a8 as SlimPrimitiveKind, a9 as SubmitHandler, aa as Unset, U as UseFormConfiguration, a as UseFormReturnType, ab as ValidateOn, ac as ValidateOnConfig, ad as ValidationError, ae as ValidationResponse, af as ValidationResponseWithoutValue, ag as ValueOfUnion, ah as WriteMeta, ai as WriteShape, aj as canonicalizePath, ak as isPathPrefix, al as isUnset, am as parseDottedPath, an as unset } from './shared/attaform.Br8EBn5B.mjs';
+export { v as vRegister } from './shared/attaform.L0kUn3vL.mjs';
 export { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4, fieldMeta, useForm, withMeta } from './index.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.Rc9u4Vfw.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.2FslhB9R.mjs';
 import 'vue';
-import './shared/attaform.DRUT703x.mjs';
+import './shared/attaform.B-Tb62qV.mjs';
 import 'zod';

package/dist/zod.mjs

@@ -1,6 +1,6 @@
 export { A as AttaformError, 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 canonicalizePath, i as isPathPrefix, p as parseDottedPath } from './shared/attaform.CdZIEf7_.mjs';
-export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.DNJOWjQw.mjs';
+export { A as AttaformErrorCode, e as escapeForInlineScript, g as gate, i as injectForm, a as injectWizard, b as isUnset, l as lazy, u as unset, d as useRegister, f as useWizard } from './shared/attaform.BIWicztt.mjs';
 export { D as DEVTOOLS_WINDOW_KEY, c as createAttaform, a as createRegistry, g as getRegistryFromApp, h as hydrateAttaformState, k as kAttaformRegistry, r as renderAttaformState, u as useRegistry } from './shared/attaform.WiGdIqgx.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.B3resMQ1.mjs';
-export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.ByWP6kSx.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.D_f1WgYf.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.B2iebkPA.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attaform",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "types": "./dist/index.d.mts",
   "files": [
     "dist",
@@ -129,7 +129,7 @@
     "@commitlint/cli": "^21.0.1",
     "@commitlint/config-conventional": "^21.0.1",
     "@eslint/js": "^10.0.1",
-    "@fast-check/vitest": "^0.4.0",
+    "@fast-check/vitest": "^0.5.0",
     "@nuxt/devtools": "^3.4.2",
     "@nuxt/devtools-kit": "^3.2.0",
     "@nuxt/kit": "^4.4.2",
@@ -141,7 +141,7 @@
     "@types/jsdom": "^30.0.0",
     "@types/node": "^26.5.1",
     "@vitejs/plugin-vue": "^6.0.6",
-    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/coverage-v8": "^5.0.1",
     "@vue/compiler-core": "^3.5.33",
     "@vue/compiler-sfc": "^3.5.33",
     "@vue/devtools-api": "^8.1.1",
@@ -171,7 +171,7 @@
     "typescript-eslint": "^8.59.0",
     "unbuild": "^3.6.1",
     "vite": "^8.3.0",
-    "vitest": "^4.1.11",
+    "vitest": "^5.0.1",
     "vue": "^3.5.33",
     "vue-eslint-parser": "^10.4.0",
     "vue-tsc": "^3.2.7",
@@ -212,8 +212,8 @@
     "build:site": "pnpm --filter attaform-site build",
     "lint": "eslint --cache --concurrency=auto --max-warnings 0 . && pnpm format:check",
     "lint:fix": "eslint --cache --concurrency=auto --max-warnings 0 --fix . && pnpm format",
-    "format": "prettier --write '**/*.{ts,js,vue,css,scss,md,json,yml,yaml}'",
-    "format:check": "prettier --check '**/*.{ts,js,vue,css,scss,md,json,yml,yaml}'",
+    "format": "prettier --write '**/*.{ts,js,mjs,cjs,vue,css,scss,md,json,yml,yaml}'",
+    "format:check": "prettier --check '**/*.{ts,js,mjs,cjs,vue,css,scss,md,json,yml,yaml}'",
     "check": "pnpm check:security-floors && pnpm lint && pnpm typecheck && pnpm check:site && pnpm test && pnpm test:nuxt-ui && pnpm check:size && pnpm check:tarball && pnpm check:eager && pnpm check:bench && pnpm check:coverage",
     "fix": "pnpm lint:fix",
     "typecheck": "tsc --noEmit",
@@ -233,6 +233,7 @@
     "bench:delta": "node scripts/bench-delta.mjs",
     "check:bundled-types": "node scripts/check-bundled-types.mjs",
     "check:doc-snippets": "node scripts/check-doc-snippets.mjs",
+    "check:comment-only": "node scripts/check-comment-only.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 && node scripts/build-bestpractices-json.mjs && git add CHANGELOG.md RELEASES.md docs/scorecard/cii-best-practices-answers.md .bestpractices.json"

package/dist/shared/attaform.Clz0ArIi.d.mts

@@ -1,44 +0,0 @@
-import { App } from 'vue';
-import { ao as RegisterModelDynamicCustomDirective } from './attaform.bKLzMU0o.mjs';
-
-/**
- * The `v-register` directive. Bind a form field to a native input,
- * select, textarea, checkbox, or radio:
- *
- * ```vue
- * <input v-register="form.register('email')" />
- * <select v-register="form.register('country')">
- *   <option value="us">US</option>
- *   <option value="uk">UK</option>
- * </select>
- * ```
- *
- * The directive picks the right binding strategy automatically based
- * on the element's `tagName` and `type`. Delivered by the Vite / Nuxt
- * plugin's compile-time binding, or by `installVRegister(app)`
- * everywhere else. Most consumers never import it directly, but it's
- * exposed for advanced integrations that wire directives manually.
- */
-declare const vRegister: RegisterModelDynamicCustomDirective;
-/**
- * Register the `v-register` directive app-wide. The one-line setup for
- * apps whose templates are compiled without Attaform's Vite or Nuxt
- * plugin — a webpack-family bundler, a no-build / CDN page, or
- * runtime-compiled templates:
- *
- * ```ts
- * import { createApp } from 'vue'
- * import { installVRegister } from 'attaform/directive'
- *
- * const app = createApp(App)
- * installVRegister(app)
- * ```
- *
- * Vite and Nuxt consumers don't call this: the build plugin binds each
- * template's `v-register` to the directive at compile time. Idempotent —
- * a second call for the same app is a no-op, and an app-level directive
- * a consumer registered under the same name is left in place.
- */
-declare function installVRegister(app: App): void;
-
-export { installVRegister as i, vRegister as v };