attaform 0.28.0 → 0.29.0

package/dist/transforms.d.mts

@@ -1,27 +1,5 @@
 import { NodeTransform } from '@vue/compiler-core';
 
-/**
- * Vue compiler node transform that bridges `v-register` into the
- * downstream binding shapes its consumers expect:
- *
- *   - `<select v-register>` — injects `:value` (single-select) and
- *     per-`<option>` `:selected` so the runtime directive can pre-mark
- *     selected options at SSR time.
- *   - `<MyComponent v-register>` and kebab-case custom-element hosts
- *     — injects a `:registerValue` bridge prop so `useRegister` inside
- *     the child sees the parent's RegisterValue (the binding the audit
- *     called out as the transform's "fires on every component" path),
- *     and marks any parent-authored slotted `<option>`s with `:selected`
- *     the same way the native path does, so a `<select>` wrapped in a
- *     styled component keeps its SSR-selected option (#394).
- *
- * Wired automatically by `attaform/vite` and `attaform/nuxt`. Use
- * directly only when integrating with a custom bundler.
- *
- * Renamed from `selectNodeTransform` (DIR-F6): the original name read
- * as a `<select>`-only transform, but the component-bridge path is
- * load-bearing for every `useRegister` consumer.
- */
 declare const componentBridgeTransform: NodeTransform;
 
 /**

package/dist/transforms.mjs

@@ -1 +1 @@
-export { c as componentBridgeTransform, i as inputTextAreaNodeTransform, r as redundantBindingWarnTransform, v as vRegisterHintTransform, a as vRegisterPreambleTransform } from './shared/attaform.Cs2Rbdlo.mjs';
+export { c as componentBridgeTransform, i as inputTextAreaNodeTransform, r as redundantBindingWarnTransform, v as vRegisterHintTransform, a as vRegisterPreambleTransform } from './shared/attaform.BK0cgu2K.mjs';

package/dist/vite.d.mts

@@ -21,16 +21,25 @@ import { Plugin } from 'vite';
  * the auto-imports at `/zod` costs the consumer nothing and earns the
  * lean bundle for free.
  *
+ * The bar for a slot: a form author calls it directly from inside a
+ * component's `setup`. That is why `useRegister` is here. It is the only
+ * way to write a custom input wrapper, and it opens with
+ * `getCurrentInstance()`, so a component's `setup` is the one place it
+ * can be called at all.
+ *
  * Deliberately absent (reach for these with an explicit import):
  *   - `useAbstractForm` — the schema-agnostic escape hatch on
  *     `attaform/abstract`, an advanced surface, not the default form.
  *   - `createAttaform` — the plugin install, a setup-level one-liner that
  *     belongs beside the app bootstrap, not in every component's scope.
- *   - `useRegister` and the serialize helpers — low-level plumbing.
+ *   - `unset` / `isUnset` and the serialize helpers: plain values and
+ *     functions with no component affinity, equally at home in a store, a
+ *     util module, or a server route. `unset` is also too generic a name
+ *     to spend on every app's global scope.
  *
- * A name earns a slot here only if a form author calls it directly on a
- * normal page. The manifest test pins the set so a casual addition of a
- * setup-level symbol to the global scope fails loudly.
+ * The manifest test pins the set so a casual addition of a setup-level
+ * symbol to the global scope fails loudly, and `auto-import-docs.test.ts`
+ * pins the prose that enumerates it.
  */
 /**
  * One auto-imported binding: the exported `name` and the module it is

package/dist/vite.mjs

@@ -1,5 +1,5 @@
 import { r as resolveZodAliasTarget, i as isRewritableZodSpecifier } from './shared/attaform.DhnPb6nK.mjs';
-import { a as vRegisterPreambleTransform, r as redundantBindingWarnTransform, c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform } from './shared/attaform.Cs2Rbdlo.mjs';
+import { a as vRegisterPreambleTransform, r as redundantBindingWarnTransform, c as componentBridgeTransform, i as inputTextAreaNodeTransform, v as vRegisterHintTransform } from './shared/attaform.BK0cgu2K.mjs';
 import { parse, babelParse } from '@vue/compiler-sfc';
 import { NodeTypes } from '@vue/compiler-core';
 
@@ -11,7 +11,8 @@ const attaformAutoImports = [
   { name: "fieldMeta", from: "attaform/zod" },
   { name: "withMeta", from: "attaform/zod" },
   { name: "lazy", from: "attaform/zod" },
-  { name: "gate", from: "attaform/zod" }
+  { name: "gate", from: "attaform/zod" },
+  { name: "useRegister", from: "attaform/zod" }
 ];
 const attaformAutoImportsMap = attaformAutoImports.reduce((map, entry) => {
   const names = map[entry.from] ?? [];

package/dist/zod-v3.d.mts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { G as GenericForm, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, as as AcceptableDefaults, a as UseFormReturnType, af as ValidateOnConfig, at as SchemaFactoryOptions, o as FieldMetaPayload } from './shared/attaform.Cgu-hdSb.mjs';
-export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RegisterDirective, a0 as RegisterFlatPath, a1 as RegisterOptions, a2 as RegisterSelectModifier, a3 as RegisterTextModifier, a4 as RegisterTransform, a5 as RegisterValue, a6 as Segment, a7 as SetValueCallback, a8 as SetValuePayload, a9 as SettledValidationStatus, aa as SlimPrimitiveKind, ab as SlimRuntimeOf, ac as SubmitHandler, ad as Unset, ae as ValidateOn, ag as ValidationError, ah as ValidationResponse, ai as ValidationResponseWithoutValue, aj as ValueOfUnion, ak as WriteMeta, al as WriteShape, am as canonicalizePath, an as isPathPrefix, ao as isUnset, ap as parseDottedPath, aq as unset } from './shared/attaform.Cgu-hdSb.mjs';
+import { G as GenericForm, F as FormKey, U as UseFormConfiguration, av as AcceptableDefaults, a as UseFormReturnType, ah as ValidateOnConfig, au as SchemaFactoryOptions, o as FieldMetaPayload } from './shared/attaform.CsoeRi3P.mjs';
+import { AbstractSchema } from './abstract.mjs';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RecordPath, a0 as RecordValue, a1 as RegisterDirective, a2 as RegisterFlatPath, a3 as RegisterOptions, a4 as RegisterSelectModifier, a5 as RegisterTextModifier, a6 as RegisterTransform, a7 as RegisterValue, a8 as Segment, a9 as SetValueCallback, aa as SetValuePayload, ab as SettledValidationStatus, ac as SlimPrimitiveKind, ad as SlimRuntimeOf, ae as SubmitHandler, af as Unset, ag as ValidateOn, ai as ValidationError, aj as ValidationResponse, ak as ValidationResponseWithoutValue, al as ValueOfUnion, am as WriteMeta, an as WriteShape, ao as canonicalizePath, ap as isPathPrefix, aq as isUnset, ar as parseDottedPath, as as unset } from './shared/attaform.CsoeRi3P.mjs';
 import { S as SupportedRootSchema, U as UnwrapZodRoot, a as StorageShape } from './shared/attaform.DRUT703x.mjs';
-export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard } from './shared/attaform.D5V4tZWq.mjs';
-export { v as vRegister } from './shared/attaform.JfSWdEcb.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterOptions, o as UseRegisterReturn, p as UseWizardReturnType, W as WizardAggregateError, q as WizardCtx, r as WizardCtxForm, s as WizardOnError, t as WizardOnSubmit, u as WizardOptions, v as WizardPersistFn, w as WizardRestoreFn, x as WizardRestoreState, y as WizardStatusesProxy, z as WizardSubmitContext, B as assignKey, E as createAttaform, H as createRegistry, J as defaultCoercionRules, K as defaultDisplayState, M as defineCoercion, N as escapeForInlineScript, P as gate, Q as getRegistryFromApp, T as hydrateAttaformState, V as injectForm, X as injectWizard, Y as isRegisterValue, Z as kAttaformRegistry, _ as lazy, $ as makeDefaultDisplayState, a0 as renderAttaformState, a1 as useRegister, a2 as useRegistry, a3 as useWizard } from './shared/attaform.DDtqHYv1.mjs';
+export { v as vRegister } from './shared/attaform.axHXVQO7.mjs';
 import 'vue';
 
 /**
@@ -114,6 +115,7 @@ type ZodTypeMap = {
     ]>;
     ZodArray: z.ZodArray<z.ZodTypeAny>;
     ZodSet: z.ZodSet<z.ZodTypeAny>;
+    ZodMap: z.ZodMap<z.ZodTypeAny, z.ZodTypeAny>;
     ZodRecord: z.ZodRecord<z.ZodTypeAny, z.ZodTypeAny>;
     ZodDefault: z.ZodDefault<z.ZodTypeAny>;
     ZodOptional: z.ZodOptional<z.ZodTypeAny>;

package/dist/zod-v3.mjs

@@ -1,9 +1,9 @@
-export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform.CJP3RkGa.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.C09fpdLS.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.wfY8XFvm.mjs';
-export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.B8k8JrmK.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.Dq4vWxuG.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.uLbun31C.mjs';
+export { i as isZodSchemaType, u as useForm, z as zodAdapter } from './shared/attaform.D1fnTifF.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.B0dKL8ST.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.CZYt_5N_.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.CZMAYwSK.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.D0x-qSXm.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DffRL5pP.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';
 
 const fieldMeta = installingFieldMetaStore;

package/dist/zod-v4.d.mts

@@ -1,10 +1,10 @@
-import { S as SupportedRootSchema } from './shared/attaform.B4VkS43-.mjs';
-export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.B4VkS43-.mjs';
-import { c as AttaformError } from './shared/attaform.D5V4tZWq.mjs';
-export { a as AnyForm, b as AttaformDevtoolsBridge, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard } from './shared/attaform.D5V4tZWq.mjs';
-import { F as FormKey, at as SchemaFactoryOptions, A as AbstractSchema, o as FieldMetaPayload } from './shared/attaform.Cgu-hdSb.mjs';
-export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RegisterDirective, a0 as RegisterFlatPath, a1 as RegisterOptions, a2 as RegisterSelectModifier, a3 as RegisterTextModifier, a4 as RegisterTransform, a5 as RegisterValue, a6 as Segment, a7 as SetValueCallback, a8 as SetValuePayload, a9 as SettledValidationStatus, aa as SlimPrimitiveKind, ab as SlimRuntimeOf, ac as SubmitHandler, ad as Unset, U as UseFormConfiguration, a as UseFormReturnType, ae as ValidateOn, af as ValidateOnConfig, ag as ValidationError, ah as ValidationResponse, ai as ValidationResponseWithoutValue, aj as ValueOfUnion, ak as WriteMeta, al as WriteShape, am as canonicalizePath, an as isPathPrefix, ao as isUnset, ap as parseDottedPath, aq as unset } from './shared/attaform.Cgu-hdSb.mjs';
-export { v as vRegister } from './shared/attaform.JfSWdEcb.mjs';
+import { S as SupportedRootSchema } from './shared/attaform.CIWLMY-R.mjs';
+export { P as PathInput, a as PathOutput, u as useForm } from './shared/attaform.CIWLMY-R.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterOptions, o as UseRegisterReturn, p as UseWizardReturnType, W as WizardAggregateError, q as WizardCtx, r as WizardCtxForm, s as WizardOnError, t as WizardOnSubmit, u as WizardOptions, v as WizardPersistFn, w as WizardRestoreFn, x as WizardRestoreState, y as WizardStatusesProxy, z as WizardSubmitContext, B as assignKey, E as createAttaform, H as createRegistry, J as defaultCoercionRules, K as defaultDisplayState, M as defineCoercion, N as escapeForInlineScript, P as gate, Q as getRegistryFromApp, T as hydrateAttaformState, V as injectForm, X as injectWizard, Y as isRegisterValue, Z as kAttaformRegistry, _ as lazy, $ as makeDefaultDisplayState, a0 as renderAttaformState, a1 as useRegister, a2 as useRegistry, a3 as useWizard } from './shared/attaform.DDtqHYv1.mjs';
+import { F as FormKey, au as SchemaFactoryOptions, o as FieldMetaPayload } from './shared/attaform.CsoeRi3P.mjs';
+import { AbstractSchema } from './abstract.mjs';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RecordPath, a0 as RecordValue, a1 as RegisterDirective, a2 as RegisterFlatPath, a3 as RegisterOptions, a4 as RegisterSelectModifier, a5 as RegisterTextModifier, a6 as RegisterTransform, a7 as RegisterValue, a8 as Segment, a9 as SetValueCallback, aa as SetValuePayload, ab as SettledValidationStatus, ac as SlimPrimitiveKind, ad as SlimRuntimeOf, ae as SubmitHandler, af as Unset, U as UseFormConfiguration, a as UseFormReturnType, ag as ValidateOn, ah as ValidateOnConfig, ai as ValidationError, aj as ValidationResponse, ak as ValidationResponseWithoutValue, al as ValueOfUnion, am as WriteMeta, an as WriteShape, ao as canonicalizePath, ap as isPathPrefix, aq as isUnset, ar as parseDottedPath, as as unset } from './shared/attaform.CsoeRi3P.mjs';
+export { v as vRegister } from './shared/attaform.axHXVQO7.mjs';
 import { z } from 'zod';
 import 'vue';
 
@@ -22,28 +22,15 @@ import 'vue';
  * downstream walk so a per-form override can lift the cap without
  * touching the app-level default.
  *
- * Throws if the schema isn't Zod v4 or contains kinds the adapter
- * cannot represent (`z.promise`, `z.custom`, `z.templateLiteral`).
- * Recursive `z.lazy(...)` is supported — the runtime walks bound their
- * descent via `maxRecursionDepth`.
+ * 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`.
  */
 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>;
 
-/**
- * Thrown when a Zod schema includes a kind the form library cannot
- * represent: `z.promise`, `z.custom`, or `z.templateLiteral`.
- *
- * The error message includes the dotted path of the offending node
- * so you can locate it without traversing the whole schema.
- *
- * Recursive `z.lazy(...)` is supported, not unsupported: the
- * construction-time walk stops descending on the second encounter
- * of the same getter, and downstream walks cap their descent via
- * `maxRecursionDepth`.
- */
-declare class UnsupportedSchemaError extends AttaformError {
-}
-
 /**
  * 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
@@ -174,5 +161,5 @@ declare const fieldMeta: ZodFieldMetaRegistry;
  */
 declare function withMeta<S extends z.ZodType>(schema: S, payload: FieldMetaPayload): S;
 
-export { AttaformError, FieldMetaPayload, FormKey, UnsupportedSchemaError, assertZodVersion, fieldMeta, kindOf, withMeta, zodV4Adapter as zodAdapter };
+export { FieldMetaPayload, FormKey, assertZodVersion, fieldMeta, kindOf, withMeta, zodV4Adapter as zodAdapter };
 export type { ZodKind };

package/dist/zod-v4.mjs

@@ -1,9 +1,9 @@
-export { U as UnsupportedSchemaError, a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.NLmerepI.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.C09fpdLS.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.wfY8XFvm.mjs';
-export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.B8k8JrmK.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.Dq4vWxuG.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.uLbun31C.mjs';
+export { a as assertZodVersion, k as kindOf, u as useForm, z as zodAdapter } from './shared/attaform.C2MVyuxC.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './shared/attaform.B0dKL8ST.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.CZYt_5N_.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.CZMAYwSK.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.D0x-qSXm.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DffRL5pP.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 DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterReturn, o as UseWizardReturnType, W as WizardAggregateError, p as WizardCtx, q as WizardCtxForm, r as WizardOnError, s as WizardOnSubmit, t as WizardOptions, u as WizardPersistFn, v as WizardRestoreFn, w as WizardRestoreState, x as WizardStatusesProxy, y as WizardSubmitContext, z as assignKey, B as createAttaform, E as createRegistry, H as defaultCoercionRules, J as defaultDisplayState, K as defineCoercion, M as escapeForInlineScript, N as gate, P as getRegistryFromApp, Q as hydrateAttaformState, T as injectForm, V as injectWizard, X as isRegisterValue, Y as kAttaformRegistry, Z as lazy, _ as makeDefaultDisplayState, $ as renderAttaformState, a0 as useRegister, a1 as useRegistry, a2 as useWizard } from './shared/attaform.D5V4tZWq.mjs';
-export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, F as FormKey, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RegisterDirective, a0 as RegisterFlatPath, a1 as RegisterOptions, a2 as RegisterSelectModifier, a3 as RegisterTextModifier, a4 as RegisterTransform, a5 as RegisterValue, a6 as Segment, a7 as SetValueCallback, a8 as SetValuePayload, a9 as SettledValidationStatus, aa as SlimPrimitiveKind, ab as SlimRuntimeOf, ac as SubmitHandler, ad as Unset, U as UseFormConfiguration, a as UseFormReturnType, ae as ValidateOn, af as ValidateOnConfig, ag as ValidationError, ah as ValidationResponse, ai as ValidationResponseWithoutValue, aj as ValueOfUnion, ak as WriteMeta, al as WriteShape, am as canonicalizePath, an as isPathPrefix, ao as isUnset, ap as parseDottedPath, aq as unset } from './shared/attaform.Cgu-hdSb.mjs';
-export { v as vRegister } from './shared/attaform.JfSWdEcb.mjs';
+export { a as AnyForm, b as AttaformDevtoolsBridge, c as AttaformError, d as AttaformErrorCode, e as AttaformPluginOptions, A as AttaformRegistry, C as CompiledStep, D as DEFAULT_TIMINGS, f as DEVTOOLS_WINDOW_KEY, g as DisplayTimings, F as FormStatus, h as FormStatusSeed, G as GateMarker, I as InjectWizardInput, i as InvalidPathError, j as InvalidUseFormConfigError, L as LazyMarker, O as OutsideSetupError, R as RegistryNotInstalledError, k as ReservedFormKeyError, S as SerializedAttaformState, l as SerializedFormData, m as StepSlot, n as SubmitErrorHandlerError, U as UseRegisterOptions, o as UseRegisterReturn, p as UseWizardReturnType, W as WizardAggregateError, q as WizardCtx, r as WizardCtxForm, s as WizardOnError, t as WizardOnSubmit, u as WizardOptions, v as WizardPersistFn, w as WizardRestoreFn, x as WizardRestoreState, y as WizardStatusesProxy, z as WizardSubmitContext, B as assignKey, E as createAttaform, H as createRegistry, J as defaultCoercionRules, K as defaultDisplayState, M as defineCoercion, N as escapeForInlineScript, P as gate, Q as getRegistryFromApp, T as hydrateAttaformState, V as injectForm, X as injectWizard, Y as isRegisterValue, Z as kAttaformRegistry, _ as lazy, $ as makeDefaultDisplayState, a0 as renderAttaformState, a1 as useRegister, a2 as useRegistry, a3 as useWizard } from './shared/attaform.DDtqHYv1.mjs';
+export { b as ArrayItem, c as ArrayPath, d as AttaformDefaults, C as CoercionEntry, e as CoercionRegistry, f as CoercionResult, g as CustomDirectiveRegisterAssignerFn, h as DeepPartial, D as DefaultValuesInput, i as DefaultValuesResponse, j as DefaultValuesShape, k as DisplayCtx, l as DisplayMachine, m as DisplayState, E as ErrorInput, n as ErrorsProxyShape, o as FieldMetaPayload, p as FieldState, q as FieldStateMap, r as FieldStateMapEntry, s as FlatPath, t as FormErrorRecord, u as FormErrorsSurface, F as FormKey, v as FormMeta, G as GenericForm, w as GetDisplayState, H as HandleSubmit, x as HistoryPlugin, I as IsTuple, y as IsUnion, J as JoinSegments, z as Json, K as KeyofUnion, L as LiftedValueShape, M as MetaTrackerValue, N as NestedReadType, B as NestedType, O as OnError, P as OnInvalidSubmitPolicy, Q as OnSubmit, R as ParseOptions, S as PartialFlatPath, T as Path, V as PathKey, W as PendingValidationStatus, X as Primitive, Y as ROOT_PATH, Z as ROOT_PATH_KEY, _ as ReactiveValidationStatus, $ as RecordPath, a0 as RecordValue, a1 as RegisterDirective, a2 as RegisterFlatPath, a3 as RegisterOptions, a4 as RegisterSelectModifier, a5 as RegisterTextModifier, a6 as RegisterTransform, a7 as RegisterValue, a8 as Segment, a9 as SetValueCallback, aa as SetValuePayload, ab as SettledValidationStatus, ac as SlimPrimitiveKind, ad as SlimRuntimeOf, ae as SubmitHandler, af as Unset, U as UseFormConfiguration, a as UseFormReturnType, ag as ValidateOn, ah as ValidateOnConfig, ai as ValidationError, aj as ValidationResponse, ak as ValidationResponseWithoutValue, al as ValueOfUnion, am as WriteMeta, an as WriteShape, ao as canonicalizePath, ap as isPathPrefix, aq as isUnset, ar as parseDottedPath, as as unset } from './shared/attaform.CsoeRi3P.mjs';
+export { v as vRegister } from './shared/attaform.axHXVQO7.mjs';
 export { UseFormConfig, UseFormConfigV3, UseFormConfigV4, UseFormReturn, UseFormReturnV3, UseFormReturnV4, fieldMeta, useForm, withMeta } from './index.mjs';
-export { P as PathInput, a as PathOutput } from './shared/attaform.B4VkS43-.mjs';
+export { P as PathInput, a as PathOutput } from './shared/attaform.CIWLMY-R.mjs';
 import 'vue';
 import './shared/attaform.DRUT703x.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.wfY8XFvm.mjs';
-export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.B8k8JrmK.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.Dq4vWxuG.mjs';
-export { a as assignKey, v as vRegister } from './shared/attaform.uLbun31C.mjs';
-export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.D6DCnnQu.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.CZYt_5N_.mjs';
+export { A as AttaformErrorCode, D as DEFAULT_TIMINGS, d as defaultCoercionRules, a as defaultDisplayState, b as defineCoercion, e as escapeForInlineScript, g as gate, i as injectForm, c as injectWizard, f as isUnset, l as lazy, m as makeDefaultDisplayState, u as unset, j as useRegister, k as useWizard } from './shared/attaform.CZMAYwSK.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.D0x-qSXm.mjs';
+export { a as assignKey, v as vRegister } from './shared/attaform.DffRL5pP.mjs';
+export { f as fieldMeta, u as useForm, w as withMeta } from './shared/attaform.BndjUUYX.mjs';
 export { i as isRegisterValue } from './shared/attaform.KvlEedlF.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attaform",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "types": "./dist/index.d.mts",
   "files": [
     "dist",
@@ -130,17 +130,18 @@
     "@commitlint/config-conventional": "^21.0.1",
     "@eslint/js": "^10.0.1",
     "@fast-check/vitest": "^0.4.0",
+    "@nuxt/devtools": "^3.4.2",
     "@nuxt/devtools-kit": "^3.2.0",
     "@nuxt/kit": "^4.4.2",
     "@nuxt/schema": "^4.4.2",
     "@nuxt/test-utils": "^4.0.2",
-    "@nuxt/ui": "^4.8.0",
+    "@nuxt/ui": "^4.11.1",
     "@rollup/plugin-alias": "^6.0.0",
     "@size-limit/preset-small-lib": "^12.1.0",
-    "@types/jsdom": "^28.0.1",
-    "@types/node": "^25.6.0",
+    "@types/jsdom": "^30.0.0",
+    "@types/node": "^26.5.1",
     "@vitejs/plugin-vue": "^6.0.6",
-    "@vitest/coverage-v8": "^4.1.5",
+    "@vitest/coverage-v8": "^4.1.11",
     "@vue/compiler-core": "^3.5.33",
     "@vue/compiler-sfc": "^3.5.33",
     "@vue/devtools-api": "^8.1.1",
@@ -157,19 +158,20 @@
     "fast-check": "^4.7.0",
     "globals": "^17.5.0",
     "husky": "^9.1.7",
-    "jsdom": "^29.0.2",
+    "jsdom": "^30.0.1",
     "lint-staged": "^17.0.4",
     "nuxt": "^4.5.2",
     "prettier": "^3.8.3",
-    "primevue": "^4.5.5",
-    "reka-ui": "^2.9.10",
+    "primevue": "4.5.5",
+    "reka-ui": "^2.10.4",
+    "rollup": "^4.63.1",
     "rollup-plugin-dts": "^6.4.1",
     "size-limit": "^12.1.0",
     "typescript": "6.0.3",
     "typescript-eslint": "^8.59.0",
     "unbuild": "^3.6.1",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.5",
+    "vite": "^8.3.0",
+    "vitest": "^4.1.11",
     "vue": "^3.5.33",
     "vue-eslint-parser": "^10.4.0",
     "vue-tsc": "^3.2.7",
@@ -208,11 +210,11 @@
     "dev:prepare": "unbuild --stub && nuxi prepare apps/site",
     "dev:site": "pnpm --filter attaform-site dev",
     "build:site": "pnpm --filter attaform-site build",
-    "lint": "eslint --cache --concurrency=auto . && pnpm format:check",
-    "lint:fix": "eslint --cache --concurrency=auto --fix . && pnpm format",
+    "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}'",
-    "check": "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",
+    "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",
     "prepack:watch": "chokidar 'src/**/*' -c 'pnpm prepack' --initial",
@@ -222,6 +224,7 @@
     "test:types": "pnpm dev:prepare && vue-tsc --noEmit && cd apps/site && vue-tsc --noEmit",
     "test:watch": "node scripts/run-with-webstorage-flag.mjs vitest watch",
     "bench": "node scripts/run-with-webstorage-flag.mjs vitest bench --run",
+    "check:security-floors": "node scripts/check-security-floors.mjs",
     "check:size": "pnpm prepack && size-limit",
     "check:tarball": "node scripts/check-tarball-size.mjs",
     "check:eager": "node scripts/check-eager-size.mjs",
@@ -231,6 +234,6 @@
     "check:doc-snippets": "node scripts/check-doc-snippets.mjs",
     "check:site": "pnpm dev:prepare && pnpm --filter attaform-site typecheck",
     "fallow": "DO_NOT_TRACK=1 FALLOW_TELEMETRY=0 npx --yes fallow@2.88.3 --score",
-    "version": "node scripts/promote-changelog.mjs && (node scripts/generate-release-notes.mjs || echo '[version] release-notes step failed; continuing') && node scripts/sync-doc-versions.mjs && git add CHANGELOG.md RELEASES.md docs/scorecard/cii-best-practices-answers.md"
+    "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/skills/attaform/SKILL.md

@@ -24,13 +24,14 @@ import {
   fieldMeta,
   withMeta,
   lazy,
+  gate,
 } from 'attaform'
 ```
 
 - **Do not import `useForm` from `attaform/abstract`.** That entry is the bring-your-own-adapter escape hatch: it exports `useAbstractForm`, which needs a schema adapter wired by hand. A Zod project wants `useForm` from `attaform`. This mismatch is the single most common first-try mistake.
 - Types come from the same barrel: `import type { AnyForm, WizardCtx, Json, ValidationError } from 'attaform'`.
 - `attaform/zod` is the same surface named explicitly; `attaform/zod-v3` and `attaform/zod-v4` pin a Zod major. Any of these works; default to `attaform`.
-- In **Nuxt** with the module installed (`attaform/nuxt`), this surface auto-imports and the `v-register` directive is bound into each compiled template, so a component needs no import lines at all. In **plain Vite**, add the Attaform plugin from `attaform/vite` (it binds `v-register` the same way) plus the auto-import preset it exports. Without either build plugin, register the directive once per app: `import { installVRegister } from 'attaform/directive'` then `installVRegister(app)`.
+- In **Nuxt** with the module installed (`attaform/nuxt`), the whole block above auto-imports and the `v-register` directive is bound into each compiled template, so a component needs no import lines at all. Writing them anyway is always safe and always portable: an explicit import beats an auto-import of the same name, which is why every snippet below keeps its import line. In **plain Vite**, add the Attaform plugin from `attaform/vite` (it binds `v-register` the same way) plus the auto-import preset it exports. Without either build plugin, register the directive once per app: `import { installVRegister } from 'attaform/directive'` then `installVRegister(app)`.
 - Undo/redo ships from its own entry: `import { historyPlugin } from 'attaform/history'`, then `useForm({ schema, history: historyPlugin({ max: 200 }) })` unlocks a live `form.history` namespace (`undo` / `redo` / `clear` / `canUndo` / `canRedo` / `size`). Without the plugin the namespace is inert stubs.
 
 ## Build a form
@@ -86,7 +87,8 @@ Prefer an explicit `key` (`useForm({ schema, key: 'sign-in' })`): it makes the f
 - **Reach with `?.` on injected forms.** `injectForm()` and `injectWizard()` return `T | null`; chain optional access (`form?.register('email')`) at every consumption site.
 - **Put labels on the schema, not the template.** `z.string().register(fieldMeta, { label: 'Email' })`; read it back through `form.fields.email.label` (resolved, with a humanized-path fallback).
 - **Native inputs first.** Bind `<input>`, `<select>`, `<textarea>` with `v-register`. Reach for `useRegister` only inside a custom input component. See `references/custom-components.md`.
-- **`v-register` alone does binding, SSR value injection, and ARIA.** Do not stack `@change` handlers, reset-signal props, or watchers on top of it. If a control seems to need that scaffolding, the idiomatic shape is being missed.
+- **`v-register` alone does binding, SSR value injection, and ARIA.** Do not stack a second _writer_ on it: no `v-model`, no handler that writes the field back, no reset-signal prop. If a control seems to need that scaffolding, the idiomatic shape is being missed.
+- **Observing the field is fine, and is how a per-interaction save is built.** A `@change` that only reads, or a `watch(form.toRef('path'), ...)`, sits beside `v-register` without fighting it: the directive writes the field before your handler runs, so the value you read is the committed one. Reach for this whenever a surface persists each decision as it is made rather than on submit. See `references/saving.md`.
 
 ## Wizards
 
@@ -120,6 +122,7 @@ Load one when the task reaches its area:
 - **`references/custom-components.md`**: wrapping an input or binding a third-party component. `useRegister`, the three orthogonal primitives, attribute fallthrough, and the optional `form-key` prop.
 - **`references/ssr.md`**: debugging SSR and hydration. Why the value injection is a build-time transform, how to confirm it faithfully, and the test traps to avoid.
 - **`references/validation.md`**: designing the schema. Client-is-UX / server-is-truth, keeping closed sets in sync, and why a clearable edit field is a required string.
+- **`references/saving.md`**: persisting each decision as it is made. Choosing between an observing listener and a `watch`, the ordering that makes a listener safe, and the four things a production autosave adds.
 
 ## Going deeper
 

package/skills/attaform/references/custom-components.md

@@ -49,11 +49,16 @@ For a **compound** component that binds _multiple_ paths (a date range exposing
 
 - Read the display signals straight in the template: `field.showErrors` gates the error row, `field.showPending` gates an async "checking" indicator (it is anti-flash timed), `field.firstError?.message` is the text.
 - `v-register`'s `autoAria` (on by default) keeps `aria-invalid`, `aria-busy`, and `aria-required` in sync. It wires the _error_ id, and only while the field is in its error state, so author `aria-describedby` yourself if a _static_ hint should stay associated too.
-- **`v-register` alone does binding, SSR value injection, and ARIA.** Do not stack `@change` handlers, `:reset-signal` props, redundant directive imports, or watchers on top of it. If a control seems to need that scaffolding, find the idiomatic shape rather than hand-rolling around it.
+- **`v-register` alone does binding, SSR value injection, and ARIA.** Do not stack a second _writer_ on it: no `v-model`, no handler that writes the field back, no `:reset-signal` prop, no redundant directive import. If a control seems to need that scaffolding, find the idiomatic shape rather than hand-rolling around it.
+- **An _observer_ is not a second writer.** A `@change` that only reads, or a `watch(form.toRef('path'), ...)`, is supported beside `v-register`. The directive attaches its own listener in the `created` hook, before Vue applies yours, so it writes the field first and your handler reads committed state. That is the shape for a surface that saves each decision as it is made instead of on submit; see `references/saving.md`.
 
 ## Third-party components
 
-`v-register` binds a third-party component host, not just a native element, as long as the component renders a real form control and forwards attributes to it. The directive marks the host and injects the same binding, SSR, and ARIA it gives a native input.
+`v-register` binds a third-party component host, not just a native element. The directive marks the host and injects the same binding, SSR, and ARIA it gives a native input.
+
+When the component renders exactly one real form control and forwards attributes to it, that control becomes the field's anchor: focus and blur tracking, ARIA, and the invalid-submit focus target all land on it. A **composite** widget (a PIN input of several boxes) or a **control-less** one (a slider built from `<div>`s) binds too; the directive declines the single-element latch and tracks focus at the widget root instead. Do not reach for an escape hatch on account of either.
+
+The one shape that loses the directive half is a component whose root is a **fragment**, because Vue hands a runtime directive only to a single-element root. The value channel still works there; wrap it in an element you control to get the rest back.
 
 ## Do not re-declare native attributes as props
 

package/skills/attaform/references/errors.md

@@ -17,7 +17,8 @@ const onSubmit = form.handleSubmit(async (values) => {
 })
 ```
 
-- `setErrors(errors | updater | (path, errors))` is a **whole-layer replace**, so `clearErrors()` at the top of a fresh attempt drops errors a previous submit set. `clearErrors(path?)` scopes the clear.
+- `setErrors(errors | updater | (path, errors))` is a **whole-layer replace** of the user layer, so `clearErrors()` at the top of a fresh attempt drops errors a previous submit set. `clearErrors(path?)` scopes the clear.
+- `clearErrors` clears the **schema layer too**, at whatever path it targets, not just the user one. Inside a submit callback that costs nothing, since validation has already passed to get there, and with always-on validation the schema half re-populates on the next mutation if the value is still wrong. Pass `setErrors([])` instead when you mean to empty the user layer alone.
 - `handleSubmit` focuses the first offending field for user-set errors exactly as it does for client-invalid fields, so a `setErrors` call inside the callback needs no separate focus step.
 
 ## The `ValidationError` envelope
@@ -27,7 +28,11 @@ If your backend emits Attaform's `ValidationError` shape, it pipes straight into
 ```ts
 import type { ValidationError, Json } from 'attaform'
 
-// { message: string; path: (string | number)[]; code?: string; data?: Json | null }
+// ValidationError, what you READ BACK:
+// { message: string; path: (string | number)[]; code: string; data?: Json | null }
+// What setErrors ACCEPTS is looser: every field optional, plus a bare
+// Error. A missing message becomes 'Unknown error', a missing path is
+// [] (form level), a missing code is 'atta:user-error'.
 ```
 
 - One entry per message at `path: [field]`; a form-level error is `path: []`; a dotted key splits into segments.
@@ -55,7 +60,7 @@ A form-level banner wants the root's **own** bucket, not the aggregate:
 const banner = computed(() => form.meta.firstOwnError)
 ```
 
-Do not use `form.errors([])` for a banner: `errors(path)` uniformly means "path plus descendants", so `errors([])` is the whole-form aggregate and would surface individual field errors in the summary. `form.meta.firstOwnError` is the correct root-only read. The same own axis surfaces a container-level `.refine()` error, for example `form.fields.address.firstOwnError`.
+Do not use `form.errors([])` for a banner: `errors(path)` uniformly means "path plus descendants", so `errors([])` is the whole-form aggregate and would surface individual field errors in the summary. `form.meta.firstOwnError` is the correct root-only read. The same own axis surfaces a container-level `.refine()` error, through the CALL form: `form.fields('address').firstOwnError`. Dot access on a container (`form.fields.address`) is navigation toward leaves and carries no error state of its own, so the dotted spelling reads `undefined` no matter what the container holds.
 
 ## One normalizer, always non-empty
 

package/skills/attaform/references/saving.md

@@ -0,0 +1,77 @@
+# Saving as the user goes
+
+A surface that persists each decision as it is made, instead of on a submit, is a supported shape. It needs no scaffolding around `v-register` and no redesign toward a batch Save button. Two shapes fit it, and the one to reach for follows what the reaction belongs to.
+
+- The reaction belongs to the **interaction** (one pick is one whole decision: a `<select>`, a checkbox, a radio, a star rating) → a plain listener beside `v-register`.
+- The reaction belongs to the **value** (typing, or anything that must also catch a programmatic write) → `watch(form.toRef(path), ...)`.
+
+The deciding fact when a form both saves per change and hydrates itself from a saved record: a DOM listener never sees `form.setValue` or `form.reset()`, because neither fires a DOM event. Only the watch does.
+
+## The listener shape
+
+```vue
+<script setup lang="ts">
+  import { z } from 'zod'
+  import { useForm } from 'attaform'
+
+  const schema = z.object({ choice: z.string() })
+  const form = useForm({ schema })
+
+  async function save() {
+    // Already the newly picked value: the directive wrote it first.
+    await fetch('/api/choice', {
+      method: 'PATCH',
+      body: JSON.stringify({ value: form.values.choice }),
+    })
+  }
+</script>
+
+<template>
+  <select v-register="form.register('choice')" @change="save">
+    <option value="yes">Yes</option>
+    <option value="no">No</option>
+  </select>
+</template>
+```
+
+`v-register` attaches its own listener in Vue's `created` hook, which runs before Vue applies the handlers you wrote. The directive's listener is therefore registered first, fires first, and has written the field by the time yours is called, so the handler reads committed state rather than the previous value. That ordering is a pinned contract, not an accident of timing, and it holds for `@change`, `@input`, a `v-register.lazy` control, a checkbox, and a radio.
+
+An observing handler is **not** a second writer. Nothing is stacked, and neither the compile-time nor the runtime redundant-binding guard flags it. What stays forbidden is a second _writer_: a `v-model`, a handler that writes the field back, a reset-signal prop.
+
+## The watch shape
+
+```ts
+import { watch } from 'vue'
+import { z } from 'zod'
+import { useForm } from 'attaform'
+
+const schema = z.object({ bio: z.string() })
+const form = useForm({ schema })
+
+async function save(value: string): Promise<void> {
+  await fetch('/api/bio', { method: 'PATCH', body: JSON.stringify({ value }) })
+}
+
+// `form.toRef(path)` is a read-only ref over that path's value, so this
+// fires on every committed change, including `setValue` and `reset`.
+watch(form.toRef('bio'), (value) => {
+  void save(value)
+})
+```
+
+Registered inside `setup`, so the watchers stop on unmount with no manual teardown. Writing the same value back is a no-op in Attaform, so a watcher never fires for a write that changed nothing. For a whole container path, add `{ deep: true }`: an in-place leaf edit keeps the container's reference stable.
+
+## What a real one adds
+
+The full recipe at https://attaform.dev/docs/cross-cutting-state/autosave is copy-paste and carries the parts a production autosave needs. Reproduce these rather than shipping the bare watch above:
+
+- **Debounce per path**, because typing is continuous and a keystroke is not a decision. For a per-interaction surface the wait is pointless: keep the recipe and pass `{ debounceMs: 0 }`.
+- **A validity gate.** Run `form.parse(path, { commit: true })` and skip the write when it fails, so an invalid value never reaches the server and async refinements run as part of the same check. Turn it off per path for a true draft save.
+- **Abort on supersede.** One `AbortController` per path, handed to `fetch` as its `signal`, so a slow request cancels when a newer edit lands and the latest write wins.
+- **A pause for your own writes.** This is the one that bites. A watch reacts to every change including yours, so hydrating ten fields from a saved record echoes ten saves straight back at the server you just loaded from. Wrap a hydrating `setValue` or `reset` so the watchers skip it. The pause belongs to your composable, never to the form.
+
+## Do not trade away the rendering to get the saving
+
+Both shapes leave `v-register` in place, so the control keeps its binding, its ARIA, and its SSR value injection. That last one is worth naming, because a row of server-rendered `<select>` elements is where it shows: a selection is a DOM property rather than markup, so the server can only express it as `selected` on the right `<option>`, and hand-binding that per call site is a step every new row can forget. `v-register` emits it for every option it owns.
+
+Saving per decision never costs you that. Guidance that implies otherwise, and sends an author to a batch submit to keep their server-rendered state correct, is wrong.

package/skills/attaform/references/wizards.md

@@ -12,6 +12,8 @@ A step slot is one of:
 - a **function** returning any of those, for runtime branching,
 - a `lazy((ctx) => ...)`-wrapped function, which memoizes its resolution and re-fires only when its own tracked reads change.
 
+`gate(slot)` wraps any of them rather than being a kind of its own: it marks that position a hard prerequisite and leaves how the slot resolves alone. A function slot may return one, so whether a position is a gate can itself be a runtime decision.
+
 ```ts
 import { useForm, useWizard } from 'attaform'
 
@@ -24,7 +26,7 @@ const wizard = useWizard({ key: 'onboarding', steps: [account, 'review', profile
 ## Navigation vs submission
 
 - **`wizard.tryNext(): Promise<boolean>`** is the gated Next. It validates the active step and advances only on a clean pass, revealing that step's errors in place otherwise. It resolves to whether it advanced, and it is inline-bindable: `@click="wizard.tryNext()"`.
-- **`wizard.next()` / `wizard.back()` / `wizard.goTo(key)`** are positional moves with no validation gate. Use them for a Back button or a jump; use `tryNext` for a forward move that should validate.
+- **`wizard.next()` / `wizard.back()` / `wizard.goTo(key)`** are positional moves with no validation gate. Use them for a Back button or a jump; use `tryNext` for a forward move that should validate. Two exceptions: they refuse while a submit is in flight, and `next()` on an **uncleared `gate()` step behaves as `tryNext()`**, so wiring Next straight to it can never skip the gate's confirmation. Once that gate clears, `next()` is plain navigation again and does not re-submit.
 - **`wizard.handleSubmit(onSubmit, onError?)`** validates **every** step from any position and calls `onSubmit` once with all forms' values. It **never advances**. Wire it to the final Submit.
 
 For a forward move that runs a custom callback before advancing, compose the step form's own submit with `next`:
@@ -58,9 +60,9 @@ const onComplete = wizard.handleSubmit(async (ctx) => {
 
 The wizard handle exposes the flow's rolled-up state, all reactive:
 
-- `wizard.forms[key]`: the live form handle for a step (a facade typed as a form).
+- `wizard.forms[key]`: the step's own form handle, identity-equal to the `useForm` ref that was slotted in.
 - `wizard.allValues` / `wizard.allErrors`: every form's values / aggregate errors, keyed.
-- `wizard.activeForm`: the currently active step's form facade.
+- `wizard.activeForm`: a live facade over whichever step is active, so a handler captured once retargets as the pin moves. Not the handle itself: use `wizard.forms[key]` for that.
 - `wizard.statuses`: per-form status. Plus `wizard.progress`, `wizard.canAdvance`, `wizard.canGoBack`, `wizard.isFinalStep`, `wizard.visited`.
 
 ## A declarative step registry
@@ -94,11 +96,11 @@ const wizard = useWizard({
 
 Everything derives from the registry: the step slots, the titles, any persisted key list. Add, remove, reorder, or gate a step by editing the registry alone. Do not add speculative registry fields with no consumer; add a hook when the second consumer arrives.
 
-## Keyed injection resolves by tree and timing
+## Keyed injection resolves by name and timing
 
-A string key passed to `injectForm('account')` or `injectWizard('onboarding')` _reads_ like a global address but resolves by the **caller's component-tree position and mount timing**, not as a global lookup:
+A string key passed to `injectForm('account')` or `injectWizard('onboarding')` is a name in Attaform's app-level registry, not a location in the component tree:
 
-- `provide` / `inject` is descendant-only, so a form created in a **leaf** is unreachable from an **ancestor**.
-- A keyed form is not resolvable until the creating component's `setup` has run, so mount order matters.
+- **Position-independent.** The lookup reaches any component in the app: a sibling branch, a floating toolbar, a teleported modal. Extracting a wrapper or changing how deep a component sits never changes what a key resolves to. The no-key ambient form is the opposite, and is the one that runs on `provide` / `inject`: it reaches descendants of the owning `useForm` only.
+- **Time-dependent.** The registry entry appears when the owner's own `useForm({ key })` / `useWizard({ key })` setup runs, and not before.
 
-The consequence: a purely structural refactor can silently break a lookup. The stable shape is to **lift a shared form's creation to the coordinating ancestor** (the component that owns the wizard) and have leaves `injectForm(key)` it downward by a prop key. Always chain `?.` on the result, which is `T | null`.
+Together they give one rule: **resolve downward.** Vue runs a parent's setup before its children's, so a descendant reaching an ancestor's keyed form always resolves, while an ancestor reaching a descendant's gets `null`. The stable shape is to **lift a shared form's creation to the coordinating ancestor** (the component that owns the wizard) and reach for it at or below that point. Always chain `?.` on the result, which is `T | null`.