attaform 0.30.0 → 0.31.0

package/dist/dev/shared/{attaform-dev.BQc5QV3Y.mjs → attaform-dev.zlvDr0WB.mjs}

@@ -9,7 +9,7 @@ class InvalidPathError extends AttaformError {
 class InvalidUseFormConfigError extends AttaformError {
   constructor() {
     super(
-      "[attaform] useForm received an invalid configuration (a schema directly, no argument, or no `schema` field). Pass it as `useForm({ schema })` \u2014 the schema is one of several configuration options. See https://attaform.dev/docs/reading-the-form/the-form for the full configuration shape." 
+      "[attaform] useForm received an invalid configuration (a schema directly, no argument, or no `schema` field). Pass it as `useForm({ schema })`: the schema is one of several configuration options. See https://attaform.dev/docs/reading-the-form/the-form for the full configuration shape." 
     );
   }
 }
@@ -57,7 +57,7 @@ class OutsideSetupError extends AttaformError {
 class ReservedFormKeyError extends AttaformError {
   constructor(key) {
     super(
-      `[attaform] Form key "${key}" uses the reserved "__atta:" namespace. Use a different prefix \u2014 "__atta:" is for library-internal synthetic keys (anonymous useForm() calls without an explicit key).` 
+      `[attaform] Form key "${key}" uses the reserved "__atta:" namespace. Use a different prefix: "__atta:" is for library-internal synthetic keys (anonymous useForm() calls without an explicit key).` 
     );
   }
 }

package/dist/dev/zod-v3.mjs

@@ -1,9 +1,9 @@
-export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform-dev.DTrHonpc.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.BisFstxh.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-dev.BQc5QV3Y.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-dev.CQ2rJiAX.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-dev.DUZckyV8.mjs';
-export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D6CLvaQT.mjs';
+export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform-dev.CtyqGia7.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.Caibt7sb.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-dev.zlvDr0WB.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-dev.y9x9Vp9F.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-dev.B1q-x9R9.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.k5X47GMD.mjs';
 
 const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {

package/dist/dev/zod-v4.mjs

@@ -1,9 +1,9 @@
-export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform-dev.BK6Ge2qR.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.BisFstxh.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-dev.BQc5QV3Y.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-dev.CQ2rJiAX.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-dev.DUZckyV8.mjs';
-export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D6CLvaQT.mjs';
+export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform-dev.DJ3nsWw6.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform-dev.Caibt7sb.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-dev.zlvDr0WB.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-dev.y9x9Vp9F.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-dev.B1q-x9R9.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.k5X47GMD.mjs';
 
 const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {

package/dist/dev/zod.mjs

@@ -1,5 +1,5 @@
-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-dev.BQc5QV3Y.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-dev.CQ2rJiAX.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-dev.DUZckyV8.mjs';
-export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.D6CLvaQT.mjs';
-export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform-dev.BcNtyOmf.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-dev.zlvDr0WB.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-dev.y9x9Vp9F.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-dev.B1q-x9R9.mjs';
+export { a as assignKey, i as isRegisterValue, v as vRegister } from './shared/attaform-dev.k5X47GMD.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform-dev.DlaT4xGd.mjs';

package/dist/directive.d.mts

@@ -1,5 +1,5 @@
-export { i as installVRegister, v as vRegister } from './shared/attaform.Clz0ArIi.mjs';
-import { ao as RegisterModelDynamicCustomDirective } from './shared/attaform.bKLzMU0o.mjs';
+export { i as installVRegister, v as vRegister } from './shared/attaform.D9RqPgGu.mjs';
+import { an as RegisterModelDynamicCustomDirective } from './shared/attaform.DZnrDrNb.mjs';
 import 'vue';
 
 /**
@@ -8,11 +8,11 @@ import 'vue';
  * `File[]` (multiple). Storage is the canonical blank shape (`null` /
  * `[]`) when no file is selected, with the path marked in
  * `blankPaths` so the friendly "No value supplied" error surfaces
- * through `derivedBlankErrors` on required-file fields — same channel
+ * through `derivedBlankErrors` on required-file fields, the same channel
  * as required numbers / bigints.
  *
  * The `beforeUpdate` hook keeps the DOM in lockstep with storage by
- * clearing `el.value` when storage transitions to blank — the only
+ * clearing `el.value` when storage transitions to blank, the only
  * programmatic write browsers permit on file inputs.
  */
 declare const vRegisterFile: RegisterModelDynamicCustomDirective;

package/dist/directive.mjs

@@ -1 +1 @@
-export { i as installVRegister, v as vRegister, b as vRegisterFile } from './shared/attaform.B3resMQ1.mjs';
+export { i as installVRegister, v as vRegister, b as vRegisterFile } from './shared/attaform.DxKQsqFZ.mjs';

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.DZnrDrNb.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 = [];
@@ -14,7 +14,7 @@ function createHistoryRuntime(kernel, max) {
     return {
       form: structuralSnapshot(kernel.form.value),
       blankPaths: [...kernel.blankPaths],
-      errorCells: captureErrorCells(kernel.errorCells)
+      errorCells: captureErrorCells(kernel.errorCells())
     };
   }
   const positions = shallowRef([captureSnapshot()]);

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.DAo0QBmS.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType, D as DefaultValuesInput, h as FieldMetaPayload } from './shared/attaform.DZnrDrNb.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 SchemaParseErrorWithData, a0 as SchemaParseErrorWithoutData, a1 as SchemaParseResult, a2 as SchemaParseSuccess, a3 as Segment, a4 as SetValueCallback, a5 as SetValuePayload, a6 as SettledValidationStatus, a7 as SlimPrimitiveKind, a8 as SubmitHandler, a9 as Unset, aa as ValidateOn, ac as ValidationError, ad as ValidationResponse, ae as ValidationResponseWithoutValue, af as ValueOfUnion, ag as WriteMeta, ah as WriteShape, ai as canonicalizePath, aj as isPathPrefix, ak as isUnset, al as parseDottedPath, am as unset } from './shared/attaform.DZnrDrNb.mjs';
+export { v as vRegister } from './shared/attaform.D9RqPgGu.mjs';
+import { S as SupportedRootSchema, b as StorageShape } from './shared/attaform.CRVe8s82.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.CRVe8s82.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 { 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 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.DNPJPOO7.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.C4shmwyJ.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DxKQsqFZ.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.L011tHgJ.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);