attaform 0.30.0 → 0.30.1

package/dist/shared/{attaform.BXneBxEj.mjs → attaform.CO918TdU.mjs}

@@ -1,7 +1,7 @@
-import { j as humanize, c as useAbstractForm } from './attaform.DNJOWjQw.mjs';
+import { j as humanize, c as useAbstractForm } from './attaform.BIWicztt.mjs';
 import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.CUfrMK7t.mjs';
-import { c as callConsumerSchemaFn } from './attaform.BRDDQeHV.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.DRsANMok.mjs';
+import { c as callConsumerFn } from './attaform.8mfKZCwH.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -131,7 +131,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0);
+  return callConsumerFn(() => getter(), void 0);
 }
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
@@ -145,7 +145,7 @@ function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
+  return callConsumerFn(
     () => cv({ error: new Error("atta:default-values"), input: void 0 }),
     void 0);
 }
@@ -155,7 +155,7 @@ function hasCatchValue(schema) {
 }
 function getDefaultValue(schema) {
   const def = readDef(schema);
-  return callConsumerSchemaFn(() => def?.defaultValue, void 0);
+  return callConsumerFn(() => def?.defaultValue, void 0);
 }
 function getNativeEnumValues(_schema) {
   return void 0;
@@ -335,10 +335,10 @@ function zodIssuesToValidationErrors(issues) {
     }
     return {
       message: issue.message,
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
+      // Adapter-side paths stay schema-RELATIVE: the validation pipeline
+      // in `core/create-form-store.ts` prepends the parent path to
+      // absolutise, then routes form-level entries, those whose absolute
+      // path is empty, to the empty-string bucket at storage time.
       path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
       code
     };
@@ -533,9 +533,9 @@ const sharedV4Schemas = createSharedSchemaStore();
 function buildV4Services() {
   return {
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
-    // v4 doesn't pre-strip for the slim-mode walk — its path walker
-    // already peels every transparent wrapper inline, so the slim and
-    // unstripped walks coincide.
+    // No pre-strip for the slim-mode walk: the path walker peels every
+    // transparent wrapper inline, so the slim and unstripped walks
+    // coincide.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
     deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),

package/dist/shared/{attaform.CUfrMK7t.mjs → attaform.DRsANMok.mjs}

@@ -1,6 +1,6 @@
-import { A as AttaformErrorCode, k as isPlainRecord, s as slimKindOf } from './attaform.DNJOWjQw.mjs';
+import { A as AttaformErrorCode, k as isPlainRecord, s as slimKindOf } from './attaform.BIWicztt.mjs';
 import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform.CdZIEf7_.mjs';
-import { a as safeOwnRead, b as safeAssign } from './attaform.BRDDQeHV.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform.8mfKZCwH.mjs';
 
 const PATH_SEPARATOR = ".";
 function isOpaqueKind(kind) {
@@ -425,8 +425,8 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const rightResults = right === void 0 ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth);
       return [...leftResults, ...rightResults];
     }
-    // Leaves — can't descend further. Opaque leaves (`any` /
-    // `unknown` / `custom`) land here too and `[]` is the truthful
+    // Leaves, with nothing further to descend. An opaque leaf (`any` /
+    // `unknown` / `custom`) lands here too and `[]` is the truthful
     // answer: the schema declares no sub-paths under them, so none are
     // fabricated. `symbol` / `function` / `promise` hold a value
     // without declaring anything inside it and land here for the same
@@ -1017,7 +1017,7 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     case "unknown":
     case "custom":
       return PERMISSIVE_SLIM_KINDS;
-    // A kind this walker has no case for — in practice a kind a newer
+    // A kind this walker has no case for, in practice one a newer
     // Zod introduced. Be permissive rather than reject: the adapter
     // carries the value opaquely and the schema's own parse is what
     // decides whether it was legal.

package/dist/shared/{attaform.B3resMQ1.mjs → attaform.D_f1WgYf.mjs}

@@ -931,20 +931,15 @@ const vRegisterCheckbox = {
       el._lastAppliedModel = value.innerRef.value;
     });
   },
-  // Skip the DOM sync when the model is identity-unchanged from the
-  // last application. Pre-fix the scalar branch in `setChecked`
-  // gated on `originalValue === oldValue`, comparing a primitive
-  // scalar against the wrapper RegisterValue object — always !==,
-  // so the guard was a silent no-op. Array / Set branches lacked
-  // any guard. The per-render re-apply mirrors the just-fixed
-  // `vRegisterSelect` shape: a sibling's reactive write triggers
-  // `beforeUpdate` mid-click, `setChecked` re-applies the prior
-  // model state, and the in-flight user toggle is clobbered before
-  // the browser fires `change`. Identity comparison on
-  // `innerRef.value` is sound for the same reason as multi-select —
-  // every form write produces a fresh value at the path (new
-  // primitives; new array/Set references along the spine), so
-  // reference equality tracks "did the model move" exactly.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application. Without the guard, a sibling's reactive write triggers
+  // `beforeUpdate` mid-click, `setChecked` re-applies the prior model state,
+  // and the in-flight toggle is clobbered before the browser fires `change`.
+  // Compare `innerRef.value` by identity: every form write produces a fresh
+  // value at the path, new primitives and new array or Set references along
+  // the spine, so reference equality tracks "did the model move" exactly. The
+  // guard must NOT compare against `oldValue`, which is the previous binding's
+  // wrapper RegisterValue and never equals a model scalar.
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
     if (!isRegisterValue(binding.value)) return;
@@ -994,13 +989,11 @@ const vRegisterRadio = {
       }
     });
   },
-  // Initial checked-state sync runs in `mounted`, NOT `created` —
-  // Vue's directive lifecycle fires `created` BEFORE the element's
-  // attributes are patched (`type`, `value`, `_value` etc. aren't on
-  // the element yet), so `getValue(el)` would return `undefined` and
-  // every radio in a group would mount unchecked regardless of the
-  // model. Checkbox already uses `mounted: setChecked` for the same
-  // reason.
+  // The initial checked sync runs in `mounted`, NOT `created`: Vue fires
+  // `created` before the element's attributes are patched, so `type`, `value`
+  // and `_value` are absent, `getValue(el)` returns undefined, and every radio
+  // in a group mounts unchecked whatever the model says. Checkbox uses
+  // `mounted` for the same reason.
   mounted(el, { value }) {
     if (!isRegisterValue(value)) return;
     el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
@@ -1010,15 +1003,12 @@ const vRegisterRadio = {
       el._lastAppliedModel = value.innerRef.value;
     });
   },
-  // Skip the DOM sync when the model is identity-unchanged from the
-  // last application. Pre-fix the guard read `value.innerRef.value
-  // !== oldValue`, comparing a primitive scalar against the previous
-  // binding's wrapper RegisterValue object — always !==, so the
-  // guard was a silent no-op and `el.checked = …` re-applied on
-  // every parent re-render. Same shape as the just-fixed
-  // `vRegisterSelect` and `setChecked` bugs: a sibling's reactive
-  // write triggers `beforeUpdate` mid-click and writes back the
-  // prior model state, clobbering the in-flight selection.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application, tracked on `_lastAppliedModel`. Comparing against `oldValue`
+  // instead compares a primitive scalar to the previous binding's wrapper
+  // RegisterValue, never equal, so `el.checked` re-applies on every parent
+  // re-render and a sibling's reactive write clobbers an in-flight selection
+  // mid-click.
   beforeUpdate(el, { value }, vnode) {
     if (!isRegisterValue(value)) return;
     setAssignFunction(el, vnode, value);
@@ -1077,22 +1067,20 @@ const vRegisterSelect = {
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
   },
-  // Skip the DOM sync when the model is identity-unchanged from the
-  // last application. Parent re-renders fire `updated` whether or not
-  // the bound model actually moved (a typed character in a sibling,
-  // an async-validation tick, any reactive read elsewhere on the
-  // page). Without this guard, every such render unconditionally re-
-  // applies `setSelected` against the prior model, which on a
-  // `<select multiple>` clobbers any in-progress user selection
-  // between mousedown and the browser's change-event decision — the
-  // browser then sees no net change, never fires `change`, and the
-  // model never updates. Identity comparison is sound: every form
-  // write produces a new array/Set reference at the path (the diff-
-  // apply replacement of `form.value` rolls forward fresh structures
-  // along the spine), so reference equality on `innerRef.value`
-  // tracks "did the model move" exactly. The `_assigning` gate stays
-  // — it short-circuits the immediate post-write render where the
-  // DOM is already in sync from the user's click.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application. A parent re-render fires `updated` whether or not the bound
+  // model moved: a typed character in a sibling, an async-validation tick, any
+  // reactive read elsewhere on the page. Re-applying `setSelected` against the
+  // prior model on each of those clobbers an in-progress `<select multiple>`
+  // selection between mousedown and the browser's change decision, after which
+  // the browser sees no net change, never fires `change`, and the model never
+  // updates.
+  //
+  // Identity comparison is sound: every form write produces a new array or Set
+  // reference at the path, the replacement of `form.value` rolling fresh
+  // structures forward along the spine. The `_assigning` gate stays as well,
+  // short-circuiting the immediate post-write render where the DOM is already
+  // in sync from the user's click.
   updated(el, { value }) {
     if (el._assigning === true) return;
     if (!isRegisterValue(value)) return;
@@ -1306,13 +1294,12 @@ const vRegisterDynamic = {
     delete el._syncFromStorage;
     delete el[assignKey];
   },
-  // The lifecycle hooks above don't run on the server (Vue skips
-  // directive lifecycle during SSR), so emit the same aria attributes
-  // here from the SSR-time gated display state. Honors authored attrs
-  // (vnode-level lockout), touches no DOM, and shares
-  // `resolveAriaValue` with the client path. Ids are SSR-stable
-  // (formInstanceId derives from Vue's useId), so a server-rendered
-  // describedby matches the client after hydration.
+  // Vue skips directive lifecycle during SSR, so the hooks above never run on
+  // the server and the same aria attributes are emitted here from the SSR-time
+  // gated display state. Honours authored attrs through the vnode-level
+  // lockout, touches no DOM, and shares `resolveAriaValue` with the client
+  // path. Ids are SSR-stable, `formInstanceId` deriving from Vue's `useId`, so
+  // a server-rendered describedby matches the client after hydration.
   getSSRProps(binding, vnode) {
     const rv = binding.value;
     if (!isRegisterValue(rv)) return void 0;

package/dist/shared/{attaform.CJ8DpRGj.mjs → attaform.D_pt1gOj.mjs}

@@ -1,6 +1,6 @@
-import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, f as fixStructuralDefaults, m as mergeDeep, d as deriveDefaultWalk, e as getFieldMetaListForSchema } from './attaform.CUfrMK7t.mjs';
-import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform.DNJOWjQw.mjs';
-import { c as callConsumerSchemaFn } from './attaform.BRDDQeHV.mjs';
+import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, f as fixStructuralDefaults, m as mergeDeep, d as deriveDefaultWalk, e as getFieldMetaListForSchema } from './attaform.DRsANMok.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform.BIWicztt.mjs';
+import { c as callConsumerFn } from './attaform.8mfKZCwH.mjs';
 import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
 
 function isZodSchemaType(schema, expectedType) {
@@ -306,7 +306,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0);
+  return callConsumerFn(() => getter(), void 0);
 }
 function getLiteralValues(schema) {
   const def = readDef(schema);
@@ -323,15 +323,13 @@ function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  return callConsumerSchemaFn(() => thunk(), void 0);
+  return callConsumerFn(() => thunk(), void 0);
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
-    () => cv({ error: null, input: void 0 }),
-    void 0);
+  return callConsumerFn(() => cv({ error: null, input: void 0 }), void 0);
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -830,13 +828,9 @@ function buildV3Services(maxRecursionDepth) {
   };
   return {
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
-    // v3 pre-strips refinements / defaults / wrappers off the root for
-    // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
-    // `getSchemasAtPath` both consume this variant so the yielded
-    // candidates reflect the slim shape.
-    // The slim-root projection is gone (size-teardown P7): the shared
-    // path walker peels wrappers / effects inline, so the slim and
-    // unstripped walks coincide — same aliasing v4 always had.
+    // The shared path walker peels wrappers and effects inline, so the
+    // slim and unstripped walks coincide and the root needs no slim
+    // projection of its own. Same aliasing v4 has.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
     deriveDefault: (schema, useDefault) => getDefaultValuesFromZodSchema(schema, useDefault),
@@ -855,10 +849,10 @@ function buildV3Services(maxRecursionDepth) {
       const result = await schema.safeParseAsync(data);
       return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
-    // v3 returns the full recursive AbstractSchema for sub-schemas (the
-    // historical shape) — `getSchemasAtPath` consumers may probe any
-    // method on the result. The factory call rebuilds the full surface
-    // against the sub-schema with its own per-form caches.
+    // A `getSchemasAtPath` consumer may probe any method on the result,
+    // so a sub-schema comes back as a full recursive AbstractSchema: the
+    // factory call rebuilds the whole surface against it, with its own
+    // per-form caches.
     makeSubSchema: (sub, maxRecursionDepth2) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
@@ -878,17 +872,16 @@ function zodIssuesToValidationErrors(issues) {
     }
     validationErrors.push({
       message: issue.message,
-      // `ValidationError.path` is `(string | number)[]` per the
-      // public type. v3's `issue.path` is the same in the standard
-      // case, but a custom check via `ctx.addIssue({ path: [...] })`
-      // can smuggle a Symbol through — the public surface promised
-      // strings/numbers, so coerce defensively to keep the contract.
-      // Mirrors v4's behaviour at the same site.
+      // `ValidationError.path` is `(string | number)[]` publicly, and
+      // v3's `issue.path` matches in the standard case, but a custom
+      // check calling `ctx.addIssue({ path: [...] })` can smuggle a
+      // Symbol through. Coerce to keep the promise. v4 does the same
+      // here.
       //
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
+      // Adapter-side paths stay schema-RELATIVE: the validation pipeline
+      // in `core/create-form-store.ts` prepends the parent path to
+      // absolutise, then routes form-level entries, those whose absolute
+      // path is empty, to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
       code
     });
@@ -920,10 +913,10 @@ function unwrapStructuralLeafV3(schema) {
   return current;
 }
 function isStructuralV3Kind(schema) {
-  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type — keep
-  // peeling at the next iteration.
-  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+). Each wraps a single inner
-  // schema with no structural impact — `peelV3Wrappers` resolves them.
+  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type; keep
+  // peeling next iteration.
+  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+), each wrapping one inner
+  // schema with no structural impact. `peelV3Wrappers` resolves them.
   isZodSchemaType(schema, "ZodPipeline") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded");
 }
 function peelV3Wrappers(schema) {

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

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

package/dist/shared/{attaform.BK0cgu2K.mjs → attaform.ZYn2ahzJ.mjs}

@@ -756,9 +756,9 @@ function injectPreamble(element, captured) {
     ),
     exp,
     modifiers: [],
-    // Reuse the host element's source location so any runtime error
-    // in the synthesized expression points at the consumer's template
-    // line, not at the dummyLoc that pre-fix was line 0.
+    // The host element's source location, so a runtime error in the
+    // synthesized expression points at the consumer's template line
+    // rather than at line 0.
     loc: element.loc
   };
   element.props.unshift(directive);

package/dist/transforms.d.mts

@@ -1,50 +1,177 @@
 import { NodeTransform } from '@vue/compiler-core';
 
+/**
+ * Vue compiler node transform that bridges `v-register` into the binding
+ * shapes its consumers expect, on two kinds of host.
+ *
+ *   - `<select v-register>` gets `:value` on a single-select plus a
+ *     per-`<option>` `:selected`, so the runtime directive can pre-mark
+ *     selected options at SSR time.
+ *   - `<MyComponent v-register>`, and a kebab-case custom-element host,
+ *     gets a `:registerValue` bridge prop, so `useRegister` inside the
+ *     child sees the parent's RegisterValue. Any parent-authored slotted
+ *     `<option>` is marked exactly as the native path marks it, so a
+ *     `<select>` wrapped in a styled component keeps its SSR-selected
+ *     option (#394).
+ *
+ * `attaform/vite` and `attaform/nuxt` wire it for you; reach for it
+ * directly only when integrating a custom bundler.
+ */
+
 declare const componentBridgeTransform: NodeTransform;
 
 /**
- * Vue compiler node transform for `<input v-register>` and
- * `<textarea v-register>`. Injects the `:value` / `:checked`
- * bindings required for SSR-correct initial render.
+ * Vue compiler node transform for `<input v-register>` and `<textarea
+ * v-register>`, injecting the `:value` and `:checked` bindings an
+ * SSR-correct initial render needs.
  *
- * Wired automatically by `attaform/vite` and
- * `attaform/nuxt`. Use directly only when integrating with
- * a custom bundler.
+ * `attaform/vite` and `attaform/nuxt` wire it for you; reach for it
+ * directly only when integrating a custom bundler.
  */
 declare const inputTextAreaNodeTransform: NodeTransform;
 
 /**
- * Vue compiler node transform that warns about a redundant state
- * binding co-located with `v-register`, and stamps the
- * compile-active marker so the runtime diagnostic stands down.
+ * The compile-time half of the redundant-binding guard (#464). On every
+ * element carrying `v-register` it does two things.
+ *
+ *   1. Warns at build time when a `v-model` sits beside `v-register` on
+ *      a native `<input>`, `<select>` or `<textarea>`, which installs
+ *      Vue's own model directive next to Attaform's: two writers driving
+ *      one element with no fallback story between them.
+ *      `findRedundantStateBinding` below carries the full reasoning for
+ *      what does and does not count.
+ *
+ *   2. Stamps `V_REGISTER_COMPILED_MODIFIER` on the directive so the
+ *      runtime diagnostic in `core/directive.ts` stands down. This
+ *      transform runs BEFORE `inputTextAreaNodeTransform` and
+ *      `componentBridgeTransform` strip and inject the value channel, so
+ *      it sees the author's props verbatim where the runtime, seeing
+ *      only the post-injection props, cannot. Exactly one layer fires
+ *      per consumer.
+ *
+ * The carve-out: a `:value`, or a static `value=`, is the legitimate
+ * IDENTITY channel for a radio and an `<option>`, and `v-register` READS
+ * it. Those never warn; only the STATE attrs do.
+ *
+ * A dynamic `:type` cannot be classified at compile time, so that input
+ * is skipped for the warn, best-effort as in `inputTextAreaNodeTransform`
+ * and the runtime `resolveDynamicModel`. The marker is still stamped, so
+ * the runtime layer, which sees the resolved type, does not double-report.
+ *
+ * It is deliberately NOT `__DEV__`-gated: firing on every compile,
+ * production and CI included, is what lets a consumer retire a bespoke
+ * SFC-lint gate. Warnings only. A redundant binding never fails the
+ * build, the Vue compiler giving transforms no error channel and a
+ * library having no business nuking a consumer's build over a
+ * lint-level issue.
+ *
+ * `attaform/vite` and `attaform/nuxt` wire it first in `nodeTransforms`;
+ * reach for it directly only when integrating a custom bundler.
+ */
+
+/**
+ * Vue compiler node transform that warns about a redundant state binding
+ * sitting beside `v-register`, and stamps the compile-active marker so
+ * the runtime diagnostic stands down.
  *
- * Must run BEFORE `inputTextAreaNodeTransform` and
- * `componentBridgeTransform` so it reads the author's props before they
- * are stripped / injected. Wired first by `attaform/vite` and
- * `attaform/nuxt`.
+ * It MUST run before `inputTextAreaNodeTransform` and
+ * `componentBridgeTransform`, so it reads the author's props before they
+ * are stripped and injected. `attaform/vite` and `attaform/nuxt` wire it
+ * first.
  */
 declare const redundantBindingWarnTransform: NodeTransform;
 
 /**
- * Vue compiler node transform that wraps every `v-register`
- * expression in a small IIFE so the directive can flag a field as
- * connected during SSR. Eliminates the `false → true` flicker on
- * `getFieldState(path).connected` after hydration.
+ * Rewrites every `<element v-register="<expr>">` so the binding
+ * expression wraps `<expr>` in an IIFE that calls
+ * `markConnectedOptimistically()` on the resulting `RegisterValue` and
+ * hands back the same object:
+ *
+ *   ((__attaRv) => (__attaRv?.markConnectedOptimistically?.(), __attaRv))(<expr>)
+ *
+ * Vue deliberately skips directive lifecycle hooks during SSR (see the
+ * header of `core/directive.ts`), so the `v-register` directive's
+ * `created` hook, the one that flips `connected: true`, never fires on
+ * the server. Every SSR'd FieldState therefore serialises `connected:
+ * false`, then flickers to `true` when the directive runs on hydration,
+ * and anything reading `getFieldState(path).connected` in a
+ * server-rendered template sees the stale value baked into the HTML.
  *
- * Must run after `vRegisterPreambleTransform`. Wired automatically
- * by `attaform/vite` and `attaform/nuxt`.
+ * The IIFE captures the `RegisterValue` `<expr>` produced, fires the
+ * optimistic mark, itself guarded by `state.ssr` so it is a free no-op
+ * on the client, and returns the same object, so the directive receives
+ * exactly what the author wrote.
+ *
+ * It is agnostic to the shape of `<expr>`, inline, hoisted into a
+ * variable, or dynamically built: all three produce a `RegisterValue` at
+ * runtime and the wrapper never needs the path string. A setup-time
+ * `register()` call NEVER bound to `v-register` gets no wrapper, no
+ * mark, and stays `connected: false` after hydration, which is correct:
+ * it represents no rendered DOM element.
+ *
+ * Idempotent. Running twice on one AST, as some bundler configurations
+ * do, detects the marker on the second pass and skips re-wrapping.
+ */
+
+/**
+ * Vue compiler node transform that wraps every `v-register` expression
+ * in a small IIFE, so the directive can flag a field connected during
+ * SSR and `getFieldState(path).connected` does not flicker after
+ * hydration.
+ *
+ * It must run after `vRegisterPreambleTransform`. `attaform/vite` and
+ * `attaform/nuxt` wire both.
  */
 declare const vRegisterHintTransform: NodeTransform;
 
 /**
- * Vue compiler node transform that hoists `v-register`'s SSR
- * connection marks to the root of the template. Together with
- * `vRegisterHintTransform`, ensures expressions earlier in the
- * template that read `getFieldState(path).connected` see the
- * correct value during the server's single-pass render.
+ * Closes the render-order edge `vRegisterHintTransform` alone leaves
+ * open.
+ *
+ * The hint transform wraps each `v-register` expression in an IIFE that
+ * calls `markConnectedOptimistically()` when the element's vnode is
+ * created, which covers any expression evaluated AT or AFTER the input
+ * in render order. Vue's SSR is single-pass top to bottom, though, so in
+ *
+ *   <pre>{{ form.fields.password.connected }}</pre>
+ *   <input v-register="form.register('password')" />
+ *
+ * the `<pre>` evaluates BEFORE the wrapper has fired. The serialized
+ * HTML carries `connected: false`, the post-hydration steady state says
+ * `true`, and the user sees a one-tick flicker.
+ *
+ * So the marks hoist one level up. The walk collects every static
+ * `v-register` binding, skipping `v-for` descendants, whose expressions
+ * reference loop locals unavailable at root scope, and prepends a
+ * synthetic `:data-atta-pre-mark` directive to the first root element.
+ * Vue evaluates an element's prop bindings before recursing into its
+ * children, so that IIFE fires every collected mark before any
+ * descendant expression runs. Its own expression resolves to
+ * `undefined`, which the SSR renderer drops, so no attribute appears and
+ * the marks are the only output.
+ *
+ * Register it BEFORE `vRegisterHintTransform`. The pre-order pass here
+ * captures each expression's original, un-wrapped text into a
+ * per-template state map, the hint transform then wraps the in-place
+ * directive expression, and the exit hook on the first root element
+ * builds the preamble from the captured originals. An element's exit
+ * hooks fire before `transformElement`'s codegen exit, so the injected
+ * prop lands in the rendered output.
+ *
+ * For a `v-for` descendant the hint transform's per-element wrapper
+ * stays load-bearing: those bindings cannot hoist, their path
+ * expressions referencing loop-scoped identifiers.
+ */
+
+/**
+ * Vue compiler node transform that hoists `v-register`'s SSR connection
+ * marks to the root of the template. With `vRegisterHintTransform`, it
+ * is what lets an expression EARLIER in the template read
+ * `getFieldState(path).connected` correctly during the server's
+ * single-pass render.
  *
- * Must run before `vRegisterHintTransform`. Wired automatically
- * by `attaform/vite` and `attaform/nuxt`.
+ * It must run before `vRegisterHintTransform`. `attaform/vite` and
+ * `attaform/nuxt` wire both.
  */
 declare const vRegisterPreambleTransform: 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.BK0cgu2K.mjs';
+export { c as componentBridgeTransform, i as inputTextAreaNodeTransform, r as redundantBindingWarnTransform, v as vRegisterHintTransform, a as vRegisterPreambleTransform } from './shared/attaform.ZYn2ahzJ.mjs';