attaform 0.30.0 → 0.30.1

package/dist/esbuild.d.mts

@@ -50,6 +50,17 @@ interface AttaformEsbuildPlugin {
     name: string;
     setup(build: EsbuildPluginBuild): void;
 }
+/**
+ * esbuild plugin that resolves `attaform` and `attaform/zod` to the one
+ * adapter subpath matching the installed Zod major, so the build ships a
+ * single adapter instead of both.
+ *
+ * ```js
+ * import { attaform } from 'attaform/esbuild'
+ *
+ * await build({ entryPoints: ['src/main.ts'], bundle: true, plugins: [attaform()] })
+ * ```
+ */
 declare function attaform(options?: AttaformEsbuildPluginOptions): AttaformEsbuildPlugin;
 
 export { attaform };

package/dist/esbuild.mjs

@@ -1,4 +1,4 @@
-import { r as resolveZodAliasTarget, R as REWRITABLE_ZOD_SPECIFIER_FILTER } from './shared/attaform.DhnPb6nK.mjs';
+import { r as resolveZodAliasTarget, R as REWRITABLE_ZOD_SPECIFIER_FILTER } from './shared/attaform.BAf3UNn4.mjs';
 
 function attaform(options = {}) {
   const resolveZodAlias = options.resolveZodAlias !== false;

package/dist/history.d.mts

@@ -1,42 +1,13 @@
-import { p as HistoryPlugin } from './shared/attaform.bKLzMU0o.mjs';
+import { p as HistoryPlugin } from './shared/attaform.Br8EBn5B.mjs';
 import 'vue';
 
-/**
- * Bounded undo/redo history for a form, delivered as the `attaform/history`
- * entry: `useForm({ history: historyPlugin({ max }) })`. The plugin object
- * is the delivery seam — `useForm` calls its `attach(kernel)` against the
- * form's store, so the runtime here rides the consumer's own import instead
- * of every form's eager path.
- *
- * Storage is a snapshot ring buffer: `positions` holds one full
- * `HistorySnapshot` per reachable state (oldest → newest) and `cursor`
- * points at the current one. Every form change appends a snapshot (dropping
- * any redo branch past the cursor); `undo()` / `redo()` move the cursor and
- * restore that position's snapshot wholesale. When the buffer exceeds the
- * capacity cap, the oldest position falls off the front (FIFO eviction).
- *
- * Each snapshot carries the form value (deep structural clone), the
- * `blankPaths` set, and both error stores' entries — everything `undo()`
- * needs to restore a position without consulting neighbours.
- *
- * `reset()` is treated as an ordinary mutation: `applyFormReplacement`
- * fires `onFormChange`, the post-reset state lands as a new position, and
- * the pre-reset state stays one undo away. Persistence hydration
- * (`meta.hydration === true`) is the floor — the buffer wipes and reseeds
- * from the post-hydration snapshot, so `undo()` can't reach back into a
- * pre-hydration default the consumer never saw.
- *
- * Field record state (touched / focused / blurred / connected) is
- * deliberately NOT snapshotted. Those flags represent UI interaction
- * history and shouldn't rewind when the user hits undo — a field that
- * was touched stays touched.
- */
+/** Options for `historyPlugin()`, passed as `useForm({ history })`. */
 type HistoryPluginOptions = {
     /**
      * Cap on total reachable positions (the current one plus everything
      * reachable via `undo()` / `redo()`). Default `128`. When a fresh
      * mutation would exceed it, the oldest position is dropped. `0` keeps
-     * no positions beyond the current state — history effectively off,
+     * no positions beyond the current state, so history is effectively off,
      * preserved as an explicit override.
      */
     max?: number;

package/dist/history.mjs

@@ -1,5 +1,5 @@
 import { shallowRef, computed } from 'vue';
-import { n as normalizeNumericOption, D as DEFAULT_HISTORY_MAX_SNAPSHOTS, s as structuralSnapshot } from './shared/attaform.BRDDQeHV.mjs';
+import { n as normalizeNumericOption, D as DEFAULT_HISTORY_MAX_SNAPSHOTS, s as structuralSnapshot } from './shared/attaform.8mfKZCwH.mjs';
 
 function captureErrorCells(map) {
   const out = [];

package/dist/index.d.mts

@@ -1,11 +1,11 @@
-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 { G as GenericForm, F as FormKey, U as UseFormConfiguration, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, h as FieldMetaPayload } from './shared/attaform.bKLzMU0o.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 { G as GenericForm, F as FormKey, U as UseFormConfiguration, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, 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, 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, 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, ab as ValidateOn, 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';
-import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.Rc9u4Vfw.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.Rc9u4Vfw.mjs';
-import { S as SupportedRootSchema$1, a as StorageShape$1 } from './shared/attaform.DRUT703x.mjs';
+export { b as ArrayItem, c as ArrayPath, C as CustomDirectiveRegisterAssignerFn, d as DeepPartial, 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, 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, ab as ValidateOn, 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 { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.2FslhB9R.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.2FslhB9R.mjs';
+import { S as SupportedRootSchema$1, a as StorageShape$1 } from './shared/attaform.B-Tb62qV.mjs';
 import { UnwrapZodRoot } from './zod-v3.mjs';
 import { z } from 'zod';
 import 'vue';
@@ -23,7 +23,7 @@ import 'vue';
  * 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
+ * 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
@@ -38,7 +38,7 @@ import 'vue';
  * `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
+ * 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
@@ -58,23 +58,24 @@ type ZodV4Internals = {
  * `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.
+ * They live here rather than in `types-unified.ts` or `use-form.ts` so
+ * the two entry points share one definition. Internal: the overloaded
+ * `useForm` already infers fully at a call site, so consumer code never
+ * reaches for them.
  */
 
 /**
- * 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.
+ * The schema's own input type exactly as a consumer would write it,
+ * `z.input<S>`, routed through neither `GenericForm` nor
+ * `UnwrapZodRoot`. It 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, which
+ * stops matching the forwarded value under a generic. A wrong-major
+ * schema cannot bind the slot anyway, being rejected at the overload's
+ * `schema` constraint, so the raw input never widens it.
  */
 type V4SchemaInput<S extends SupportedRootSchema> = z.input<S>;
 type V3SchemaInput<S extends SupportedRootSchema$1> = z.input<S>;
@@ -92,18 +93,18 @@ type V3ReadOf<S extends SupportedRootSchema$1> = StorageShape$1<UnwrapZodRoot<S>
  * 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'),
- *   }),
+ * const schema = z.object({
+ *   username: z.string().min(2, 'At least 2 characters'),
+ *   password: z.string().min(8, 'At least 8 characters'),
  * })
+ *
+ * const form = useForm({ schema })
  * ```
  *
- * 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`.
+ * The constraint intersects `ZodV4Internals`, the v4-only `_zod` brand,
+ * so a v3 schema cannot bind this overload even where `z` resolves to v3
+ * in a single-major install; it falls 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;
@@ -116,16 +117,15 @@ declare function useForm<Schema extends SupportedRootSchema & ZodV4Internals, K
  * 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'),
- *   }),
+ * const schema = z.object({
+ *   username: z.string().min(2, 'At least 2 characters'),
+ *   password: z.string().min(8, 'At least 8 characters'),
  * })
+ *
+ * const form = useForm({ schema })
  * ```
  *
- * v3 schemas match this overload; v4 schemas hit the v4 overload
- * above first and never reach here.
+ * A v4 schema binds the overload above and never reaches this one.
  */
 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;
@@ -141,21 +141,21 @@ declare function useForm<Schema extends SupportedRootSchema$1, K extends FormKey
  * 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
+ * The helpers dispatch ONCE per use site through a binary conditional,
+ * so nothing stacks and nothing amplifies across the return type.
+ * Equivalent to `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.
+ * They are test- and internal-facing. Consumer code has no reason to
+ * reach for them: the overloaded `useForm` already infers fully at the
+ * call site.
  */
 
 /**
- * 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
+ * Direct V4 projection, with no major dispatch. Use it when the schema's
+ * Zod major is statically known, the usual case for a V4 generic helper
+ * like `function setup<S extends z.ZodObject>(s: S)`. TS simplifies it
+ * cleanly under a generic constraint because no conditional
  * is present.
  */
 type UseFormReturnV4<Schema extends z.ZodObject, K extends FormKey = FormKey> = UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>;
@@ -166,8 +166,8 @@ type UseFormConfigV4<Schema extends z.ZodObject, K extends FormKey = FormKey> =
     schema: Schema;
 } & ValidateOnConfig;
 /**
- * Direct V3 projection — no major-dispatch. Use when the schema's
- * Zod major is known statically.
+ * Direct V3 projection, with no major dispatch. Use it when the schema's
+ * Zod major is statically known.
  */
 type UseFormReturnV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKey = FormKey> = UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>;
 /**
@@ -184,17 +184,16 @@ type UseFormConfigV3<Schema extends z.ZodObject<z.ZodRawShape>, K extends FormKe
  * 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.
+ * Replaces `ReturnType<typeof useForm<Schema, K>>` in test code holding
+ * concrete schemas. In a generic helper, `<S extends z.ZodObject>`, reach
+ * for `UseFormReturnV4<S>` instead: TS does not simplify a conditional
+ * under a generic constraint, so this helper's dispatch stays deferred
+ * and return-type compatibility cannot be proven.
  */
 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
+ * schema. Same dispatch as `UseFormReturn`; it 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'> & {
@@ -206,24 +205,23 @@ type UseFormConfig<Schema, K extends FormKey = FormKey> = Schema extends Support
 /**
  * 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
+ * Storage is shared with both adapters through `core/field-meta-store`,
+ * so a payload written here is visible to whichever adapter the unified
+ * `useForm` dispatches to at runtime, whatever the 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.
+ * The native v4 chain `schema.register(fieldMeta, payload)` works too:
+ * Zod 4's `.register()` only calls `.add(this, payload)` structurally,
+ * which the shared store satisfies.
  */
 
 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.
+ * The shared registry an Attaform-aware Zod schema registers field
+ * metadata against, whatever its major. The 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
@@ -242,8 +240,7 @@ declare const fieldMeta: ZodFieldMetaRegistry;
  * 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:
+ * Works on a Zod 3 or a Zod 4 schema, branching on runtime shape:
  * - 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)`.

package/dist/index.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/dist/nuxt.d.mts

@@ -17,8 +17,9 @@ import * as _nuxt_schema from '@nuxt/schema';
 interface AttaformModuleOptions {
     /**
      * Forwarded to `attaform/vite`'s `resolveZodAlias` option.
-     * Default `true` — `attaform` and `attaform/zod` imports are rewritten
-     * at build time to either `attaform/zod-v3` or `attaform/zod-v4`, based
+     * Default `true`, so `attaform` and `attaform/zod` imports are
+     * rewritten at build time to `attaform/zod-v3` or `attaform/zod-v4`,
+     * based
      * on the consumer's installed Zod major. Set to `false` to bypass
      * the rewrite and ship the runtime-dispatch unified entry instead.
      */
@@ -46,7 +47,7 @@ type AttaformRuntimeConfig = {
     /**
      * Library version, read from the package's own `package.json` at
      * module setup. Surfaced to the runtime plugin so the DevTools
-     * overlay panel can render a version pill — single source of truth
+     * overlay panel can render a version pill. One source of truth, so it
      * matches the `meta.version` Nuxt DevTools sees in the Modules panel.
      */
     version: string;

package/dist/nuxt.mjs

@@ -60,12 +60,9 @@ var nuxt_default = defineNuxtModule({
           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.
+            // Served by the `attaform/vite` middleware, sibling to the
+            // panel HTML. A real URL renders reliably across Nuxt
+            // DevTools versions where `data:` URIs do not.
             icon: "/_attaform_devtools/icon.svg",
             view: {
               type: "iframe",

package/dist/rollup.d.mts

@@ -29,6 +29,17 @@ interface AttaformRollupPlugin {
         id: string;
     } | null> | null;
 }
+/**
+ * Rollup plugin that resolves `attaform` and `attaform/zod` to the one
+ * adapter subpath matching the installed Zod major, so the build ships a
+ * single adapter instead of both.
+ *
+ * ```js
+ * import { attaform } from 'attaform/rollup'
+ *
+ * export default { plugins: [attaform()] }
+ * ```
+ */
 declare function attaform(options?: AttaformRollupPluginOptions): AttaformRollupPlugin;
 
 export { attaform };

package/dist/rollup.mjs

@@ -1,4 +1,4 @@
-import { r as resolveZodAliasTarget, i as isRewritableZodSpecifier } from './shared/attaform.DhnPb6nK.mjs';
+import { r as resolveZodAliasTarget, i as isRewritableZodSpecifier } from './shared/attaform.BAf3UNn4.mjs';
 
 function attaform(options = {}) {
   const resolveZodAlias = options.resolveZodAlias !== false;

package/dist/rspack.d.mts

@@ -1,7 +1,8 @@
 import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './shared/attaform.C9fPTxjB.mjs';
 
 /**
- * `attaform/rspack` — Rspack plugin that rewrites `attaform/zod` imports
+ * `attaform/rspack`, the Rspack plugin that rewrites `attaform/zod`
+ * imports
  * to the single matching adapter subpath (`attaform/zod-v3` or
  * `attaform/zod-v4`) at build time, based on the consumer's installed Zod
  * major. Without it, Rspack ships both adapters because the unified
@@ -20,16 +21,12 @@ import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './sha
  * so this shares its body with `attaform/webpack` via
  * `createWebpackFamilyPlugin`; only the diagnostic tag differs.
  *
- * This plugin only does the adapter rewrite. The Vue SFC `v-register`
- * transforms that `attaform/vite` wires (load-bearing for SSR initial
- * render) are `@vitejs/plugin-vue`-specific and do not transfer; a
- * non-Vite consumer that needs them wires `attaform/transforms` into
- * their Vue compiler separately. The `v-register` directive itself is
- * also delivered by the Vite plugin's compile-time binding, so outside
- * that pipeline register it once per app:
- *
- *   import { installVRegister } from 'attaform/directive'
- *   installVRegister(app)
+ * The adapter rewrite is all this plugin does. Two things
+ * `attaform/vite` also provides do NOT transfer, because both are
+ * `@vitejs/plugin-vue`-specific: wire `attaform/transforms` into your
+ * Vue compiler for the SSR-critical template transforms, and register
+ * the directive once per app with `installVRegister(app)` from
+ * `attaform/directive`.
  *
  * Zero-dep: the plugin imports nothing from `@rspack/core` (it taps the
  * resolve hook the compiler injects at the consumer's build).
@@ -39,6 +36,17 @@ import { W as WebpackFamilyPlugin, a as WebpackFamilyPluginOptions } from './sha
 type AttaformRspackPluginOptions = WebpackFamilyPluginOptions;
 /** The structural shape Rspack requires of the plugin. */
 type AttaformRspackPlugin = WebpackFamilyPlugin;
+/**
+ * Rspack plugin that resolves `attaform/zod` to the one adapter subpath
+ * matching the installed Zod major, so the build ships a single adapter
+ * instead of both.
+ *
+ * ```js
+ * import { attaform } from 'attaform/rspack'
+ *
+ * export default { plugins: [attaform()] }
+ * ```
+ */
 declare function attaform(options?: AttaformRspackPluginOptions): AttaformRspackPlugin;
 
 export { attaform };

package/dist/rspack.mjs

@@ -1,4 +1,4 @@
-import { c as createWebpackFamilyPlugin } from './shared/attaform.v0fQtWyA.mjs';
+import { c as createWebpackFamilyPlugin } from './shared/attaform.B1rH9ht6.mjs';
 
 function attaform(options = {}) {
   return createWebpackFamilyPlugin("attaform/rspack", options);

package/dist/runtime/components/AttaformDevtoolsPanel.vue

@@ -5,7 +5,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   // can resolve through the consumer's node_modules → `dist/index.mjs`,
   // rather than through brittle relative paths into the rollup-bundled
   // shared chunks (which mkdist doesn't co-locate). Type-only imports of
-  // internal types stay relative — they're erased at compile time and
+  // internal types stay relative: they're erased at compile time and
   // don't need to resolve at the consumer's runtime.
   import { type AttaformDevtoolsBridge, canonicalizePath, type Segment } from 'attaform'
   import type { FormStore } from '../core/create-form-store'
@@ -18,7 +18,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   }>()
 
   // Cross-iframe reactivity bridge. Vue's reactivity system is module-
-  // scoped — the host's `@vue/reactivity` instance and the panel's are
+  // scoped: the host's `@vue/reactivity` instance and the panel's are
   // different copies of the same module, each with its own targetMap.
   // When the panel reads `host.form.value` in a `computed`, the proxy's
   // get trap runs in the host's tracking context (the function lives
@@ -31,7 +31,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   // (`onFormChange` / `onSubmitSuccess` / `onReset`), plus a 250ms
   // polling fallback for state that changes outside those events (user
   // errors via `setErrors`, submit-lifecycle flags). The panel's
-  // own reactivity then re-evaluates everything in one pass — cheap
+  // own reactivity then re-evaluates everything in one pass, cheap
   // because the underlying reads are direct property accesses.
   const updateTick = ref(0)
 
@@ -120,7 +120,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   }
 
   /**
-   * Render a JS value as a debug-friendly string with no masking —
+   * Render a JS value as a debug-friendly string with no masking,
    * `null` / `undefined` show as their literal names, booleans and
    * numbers as-is, strings bare (no surrounding quotes), everything
    * else JSON-stringified. Devtools is for inspecting state, not for
@@ -169,13 +169,13 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   /**
    * Raw field data at the selected path, composed from `FormStore`
    * primitives. The callable `form.fields(path)` proxy lives on the
-   * public `useForm` return, not on `FormStore` — the bridge exposes
+   * public `useForm` return, not on `FormStore`: the bridge exposes
    * the store, so we synthesise the same data from `fields.get(key)`
    * + the error Maps + an inline value walk.
    *
    * Returns the raw `FieldRecord` (updatedAt / focused / blurred /
    * touched / connected) rather than the wrapped `FieldState`
-   * surface. Sufficient for inspection — the full aggregated
+   * surface. Sufficient for inspection: the full aggregated
    * FieldState would require either lifting the surface-proxy into
    * `FormStore` (architectural change) or rebuilding the aggregation
    * walker in the panel (duplication).
@@ -211,7 +211,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
           | undefined) ?? null
 
       // Inline path walk (avoids importing path-walker through the
-      // bridge — it lives in the host's shared chunk).
+      // bridge: it lives in the host's shared chunk).
       let value: unknown = form.form.value
       for (const seg of path) {
         if (value === null || typeof value !== 'object') {
@@ -259,7 +259,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
       const { segments: canonicalPath } = canonicalizePath(rawPath as readonly Segment[])
       form.setValueAtPath(canonicalPath, next)
       // The host's setValueAtPath fires `onFormChange` listeners, which
-      // bumps our updateTick (see subscribeForm) — that refreshes the
+      // bumps our updateTick (see subscribeForm): that refreshes the
       // panel's view of the new value on the next microtask.
     } catch (err) {
       // Surface cross-iframe write failures (e.g., type-instance checks
@@ -285,7 +285,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
 
   /**
    * Hard cap on the in-memory event log. Sized for a debugging session,
-   * not an audit log — older events fall off the back when capacity
+   * not an audit log, older events fall off the back when capacity
    * fills. Tunable later if real consumers ask for more.
    */
   const MAX_TIMELINE_EVENTS = 200
@@ -325,7 +325,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
 
   function subscribeForm(key: FormKey, form: FormStore<GenericForm>): void {
     if (subscribers.has(key)) return
-    // Deep-clone the form value at the moment of fire — FormStore
+    // Deep-clone the form value at the moment of fire, FormStore
     // mutates form data in place, so a stored reference would update
     // every existing timeline entry whenever the form changed again
     // ("type a, delete a, both timeline events show the empty value"
@@ -336,7 +336,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
       try {
         return structuredClone(form.form.value)
       } catch {
-        // Non-cloneable values (functions, Symbols, Vue refs, etc.) —
+        // Non-cloneable values (functions, Symbols, Vue refs, etc.),
         // fall back to the live reference. Worst case: that one entry
         // still shows the current state, same as before this fix.
         return form.form.value
@@ -379,7 +379,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
   )
 
   // Polling fallback for state that changes outside the `onFormChange` /
-  // `onSubmitSuccess` / `onReset` event surface — user errors injected
+  // `onSubmitSuccess` / `onReset` event surface, user errors injected
   // via `setErrors`, submit-lifecycle flags between events, or
   // new forms registered in the host's registry. 120ms is faster than
   // a human can notice between an input event and a visible panel

package/dist/runtime/components/DevtoolsValueTree.vue

@@ -100,7 +100,7 @@ import { computed, nextTick, ref } from 'vue'
     // Array indices arrive as stringified numbers from `Object.entries` /
     // `array.map`. Coerce back to numbers when the parent is an array
     // so `canonicalizePath` on the consumer side gets a structured Path
-    // with the right shape — `["users", 0, "name"]`, not
+    // with the right shape, `["users", 0, "name"]`, not
     // `["users", "0", "name"]`.
     if (type.value === 'array') return [...path.value, Number(rawKey)]
     return [...path.value, rawKey]
@@ -159,7 +159,7 @@ import { computed, nextTick, ref } from 'vue'
 
   // Selection (Field-state inspector hook). Canonical key uses JSON-
   // serialised path-array form so two arrays with the same shape produce
-  // the same string — direct equality check.
+  // the same string, direct equality check.
   const ownKey = computed(() => JSON.stringify(path.value))
   const isSelected = computed(
     () =>