attaform 0.29.0 → 0.30.1

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

@@ -1,18 +1,42 @@
-import { A as AttaformErrorCode, n as isPlainRecord, s as slimKindOf, o as crossCopyState } from './attaform.CZMAYwSK.mjs';
-import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform.CZYt_5N_.mjs';
-import { a as safeOwnRead, b as safeAssign } from './attaform.Cvao8bW5.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.8mfKZCwH.mjs';
 
 const PATH_SEPARATOR = ".";
 function isOpaqueKind(kind) {
   return kind === "any" || kind === "unknown" || kind === "custom";
 }
-function createAbstractSchema(rootSchema, intro, services, formKey, options) {
+const MEMO_CAP = 4096;
+const ROOT_KINDS = /* @__PURE__ */ new Set(["object"]);
+const NO_KINDS = /* @__PURE__ */ new Set();
+function memoPut(memo, key, value) {
+  if (memo.size >= MEMO_CAP) memo.clear();
+  memo.set(key, value);
+  return value;
+}
+function createSharedSchemaStore() {
+  const bySchema = /* @__PURE__ */ new WeakMap();
+  return (rootSchema, maxRecursionDepth, build) => {
+    let byDepth = bySchema.get(rootSchema);
+    if (byDepth === void 0) {
+      byDepth = /* @__PURE__ */ new Map();
+      bySchema.set(rootSchema, byDepth);
+    }
+    const hit = byDepth.get(maxRecursionDepth);
+    if (hit !== void 0) return hit;
+    const built = build();
+    byDepth.set(maxRecursionDepth, built);
+    return built;
+  };
+}
+function createAbstractSchema(rootSchema, intro, services, options) {
   const maxRecursionDepth = options.maxRecursionDepth;
   const leafCache = /* @__PURE__ */ new Map();
   const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
   const opaqueLeafCache = /* @__PURE__ */ new Map();
   const discriminatorCache = /* @__PURE__ */ new Map();
   const entryKeyKindCache = /* @__PURE__ */ new Map();
+  const slimKindsCache = /* @__PURE__ */ new Map();
   let asyncValidationFlag = null;
   let containerRefineFlag = null;
   let discriminatedUnionFlag = null;
@@ -56,7 +80,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (intro.kindOf(litSchema) !== "literal") continue;
           const literalValues = intro.getLiteralValues(litSchema);
           if (literalValues.includes(value)) {
-            return services.deriveDefault(opt, true, maxRecursionDepth, formKey);
+            return services.deriveDefault(opt, true, maxRecursionDepth);
           }
         }
         return void 0;
@@ -67,7 +91,6 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
     };
   }
   const abstractSchema = {
-    fingerprint: () => services.fingerprint(rootSchema),
     needsAsyncValidation() {
       asyncValidationFlag ?? (asyncValidationFlag = intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema));
       return asyncValidationFlag;
@@ -81,24 +104,24 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       return discriminatedUnionFlag;
     },
     getDefaultValues(config) {
-      return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth);
+      return services.runGetDefaults(rootSchema, config, maxRecursionDepth);
     },
     getDefaultAtPath(path) {
       if (path.length === 0) {
-        return services.deriveDefault(rootSchema, true, maxRecursionDepth, formKey);
+        return services.deriveDefault(rootSchema, true, maxRecursionDepth);
       }
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
       if (first === void 0) return void 0;
       const peeled = services.unwrapStructuralWrappers(first);
-      return services.deriveDefault(peeled, true, maxRecursionDepth, formKey);
+      return services.deriveDefault(peeled, true, maxRecursionDepth);
     },
     getEmptyValueAtPath(path) {
       if (path.length === 0) {
-        return services.deriveDefault(rootSchema, false, maxRecursionDepth, formKey);
+        return services.deriveDefault(rootSchema, false, maxRecursionDepth);
       }
       const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth);
       if (first === void 0) return void 0;
-      return services.deriveDefault(first, false, maxRecursionDepth, formKey);
+      return services.deriveDefault(first, false, maxRecursionDepth);
     },
     arrayShapeAtPath(path) {
       if (path.length === 0) return null;
@@ -139,25 +162,27 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
             answer = void 0;
         }
       }
-      entryKeyKindCache.set(cacheKey, answer);
-      return answer;
+      return memoPut(entryKeyKindCache, cacheKey, answer);
     },
     getSchemasAtPath(path) {
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
       if (resolved.length === 0) return [];
-      return resolved.map((sub) => services.makeSubSchema(sub, formKey, maxRecursionDepth));
+      return resolved.map((sub) => services.makeSubSchema(sub, maxRecursionDepth));
     },
     getSlimPrimitiveTypesAtPath(path) {
-      if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
+      if (path.length === 0) return ROOT_KINDS;
+      const cacheKey = canonicalizePath(path).key;
+      const hit = slimKindsCache.get(cacheKey);
+      if (hit !== void 0) return hit;
       const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth);
-      if (resolved.length === 0) return /* @__PURE__ */ new Set();
+      if (resolved.length === 0) return memoPut(slimKindsCache, cacheKey, NO_KINDS);
       const out = /* @__PURE__ */ new Set();
       for (const candidate of resolved) {
         for (const k of services.slimPrimitivesOf(candidate, maxRecursionDepth)) {
           out.add(k);
         }
       }
-      return out;
+      return memoPut(slimKindsCache, cacheKey, out);
     },
     isLeafAtPath(path) {
       const cacheKey = canonicalizePath(path).key;
@@ -166,8 +191,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       const opaque = path.length > 0 && this.isOpaqueLeafAtPath(path);
       const prim = opaque ? void 0 : this.getSlimPrimitiveTypesAtPath(path);
       const isLeaf = opaque || prim !== void 0 && prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
-      leafCache.set(cacheKey, isLeaf);
-      return isLeaf;
+      return memoPut(leafCache, cacheKey, isLeaf);
     },
     isPreprocessOrCoerceLeaf(path) {
       const cacheKey = canonicalizePath(path).key;
@@ -184,8 +208,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           }
         }
       }
-      preprocessOrCoerceCache.set(cacheKey, hit);
-      return hit;
+      return memoPut(preprocessOrCoerceCache, cacheKey, hit);
     },
     isOpaqueLeafAtPath(path) {
       const cacheKey = canonicalizePath(path).key;
@@ -195,8 +218,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       const opaque = resolved.length > 0 && resolved.every(
         (candidate) => isOpaqueKind(intro.kindOf(services.peelAllWrappers(candidate)))
       );
-      opaqueLeafCache.set(cacheKey, opaque);
-      return opaque;
+      return memoPut(opaqueLeafCache, cacheKey, opaque);
     },
     isRequiredAtPath(path) {
       if (path.length === 0) return true;
@@ -212,9 +234,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       if (discriminatorCache.has(cacheKey)) {
         return discriminatorCache.get(cacheKey);
       }
-      const result = computeDiscriminator(path);
-      discriminatorCache.set(cacheKey, result);
-      return result;
+      return memoPut(discriminatorCache, cacheKey, computeDiscriminator(path));
     },
     validateAtPath(data, path, validateOptions) {
       const trySync = validateOptions?.sync === true;
@@ -226,11 +246,10 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
       }
       return runAsync();
       function parseResultToResponse(result) {
-        return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
+        return result.success ? { data: result.data, errors: void 0, success: true } : {
           data: void 0,
           errors: services.issuesToValidationErrors(result.issues),
-          success: false,
-          formKey
+          success: false
         };
       }
       function runSync() {
@@ -245,7 +264,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (response.success) return response;
           aggregated.push(...response.errors);
         }
-        return { data: void 0, errors: aggregated, success: false, formKey };
+        return { data: void 0, errors: aggregated, success: false };
       }
       async function runAsync() {
         if (path === void 0) {
@@ -271,7 +290,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
           if (response.success) return response;
           aggregated.push(...response.errors);
         }
-        return { data: void 0, errors: aggregated, success: false, formKey };
+        return { data: void 0, errors: aggregated, success: false };
       }
       function validatorThrewResponse(err, errPath) {
         const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
@@ -284,8 +303,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
               code: AttaformErrorCode.ValidatorThrew
             }
           ],
-          success: false,
-          formKey
+          success: false
         };
       }
       function pathNotFound(p) {
@@ -298,8 +316,7 @@ function createAbstractSchema(rootSchema, intro, services, formKey, options) {
               code: AttaformErrorCode.PathNotFound
             }
           ],
-          success: false,
-          formKey
+          success: false
         };
       }
     }
@@ -373,6 +390,8 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
     case "optional":
     case "nullable":
     case "default":
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "catch": {
       const inner = intro.unwrapInner(schema);
@@ -406,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
@@ -446,6 +465,8 @@ function fixNode(schema, value, ctx, lazyDepth) {
       return inner === void 0 ? value : fixNode(inner, value, ctx, lazyDepth);
     }
     case "default":
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "catch": {
       const inner = intro.unwrapInner(schema);
@@ -611,7 +632,7 @@ function hasDeclaredDefaultInChain(schema, intro) {
   }
   return false;
 }
-function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth = 0) {
+function deriveDefaultWalk(schema, useDefault, intro, maxDepth, lazyDepth = 0) {
   if (useDefault) {
     const peeled = peelEmbeddedDefault(schema, intro);
     if (peeled !== NO_EMBEDDED_DEFAULT) return peeled;
@@ -623,11 +644,7 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       const shape = intro.getObjectShape(schema);
       const out = {};
       for (const [key, subSchema] of Object.entries(shape)) {
-        safeAssign(
-          out,
-          key,
-          deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, ctx, lazyDepth)
-        );
+        safeAssign(out, key, deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, lazyDepth));
       }
       return out;
     }
@@ -639,19 +656,17 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       return {};
     case "tuple": {
       const items = intro.getTupleItems(schema);
-      return items.map(
-        (item) => deriveDefaultWalk(item, useDefault, intro, maxDepth, ctx, lazyDepth)
-      );
+      return items.map((item) => deriveDefaultWalk(item, useDefault, intro, maxDepth, lazyDepth));
     }
     case "union": {
       const options = intro.getUnionOptions(schema);
       const first = options[0];
-      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, lazyDepth);
     }
     case "discriminated-union": {
       const options = intro.getDiscriminatedOptions(schema);
       const first = options[0];
-      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return first === void 0 ? void 0 : deriveDefaultWalk(first, useDefault, intro, maxDepth, lazyDepth);
     }
     case "optional":
       return void 0;
@@ -660,39 +675,41 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     case "default": {
       if (useDefault) return intro.getDefaultValue(schema);
       const inner = intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
+    case "nonoptional":
+    case "success":
     case "readonly":
     case "branded": {
       const inner = kind === "branded" ? intro.unwrapBranded(schema) : intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "effects": {
       const inner = intro.unwrapEffectsSource(schema);
       if (intro.isPreprocessNode(schema)) {
         if (inner !== void 0 && hasDeclaredDefaultInChain(inner, intro)) {
-          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
         }
         return void 0;
       }
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "pipeline": {
       const inner = intro.unwrapPipeIn(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "pipe": {
       const inn = intro.unwrapPipeIn(schema);
       if (inn !== void 0 && intro.kindOf(inn) === "transform") {
         const out2 = intro.unwrapPipeOut(schema);
         if (out2 !== void 0 && hasDeclaredDefaultInChain(out2, intro)) {
-          return deriveDefaultWalk(out2, useDefault, intro, maxDepth, ctx, lazyDepth);
+          return deriveDefaultWalk(out2, useDefault, intro, maxDepth, lazyDepth);
         }
         return void 0;
       }
       const out = intro.unwrapPipeOut(schema);
       const real = inn !== void 0 && intro.kindOf(inn) !== "transform" ? inn : out !== void 0 && intro.kindOf(out) !== "transform" ? out : inn ?? out;
-      return real === void 0 ? void 0 : deriveDefaultWalk(real, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return real === void 0 ? void 0 : deriveDefaultWalk(real, useDefault, intro, maxDepth, lazyDepth);
     }
     case "string":
       return "";
@@ -736,19 +753,19 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
       } catch {
         return void 0;
       }
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth + 1);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
       const left = intro.getIntersectionLeft(schema);
       const right = intro.getIntersectionRight(schema);
-      const l = left === void 0 ? void 0 : deriveDefaultWalk(left, useDefault, intro, maxDepth, ctx, lazyDepth);
-      const r = right === void 0 ? void 0 : deriveDefaultWalk(right, useDefault, intro, maxDepth, ctx, lazyDepth);
+      const l = left === void 0 ? void 0 : deriveDefaultWalk(left, useDefault, intro, maxDepth, lazyDepth);
+      const r = right === void 0 ? void 0 : deriveDefaultWalk(right, useDefault, intro, maxDepth, lazyDepth);
       return mergeDeep(l, r);
     }
     case "catch": {
       if (useDefault) return intro.getCatchDefault(schema);
       const inner = intro.unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth);
+      return inner === void 0 ? void 0 : deriveDefaultWalk(inner, useDefault, intro, maxDepth, lazyDepth);
     }
     case "file":
       return null;
@@ -767,10 +784,15 @@ function deriveDefaultWalk(schema, useDefault, intro, maxDepth, ctx, lazyDepth =
     case "transform":
       return void 0;
     default:
-      return ctx.unsupportedKindFallback(schema, kind);
+      return void 0;
   }
 }
 
+function crossCopyState(key, create) {
+  const carrier = globalThis;
+  return carrier[key] ?? (carrier[key] = create());
+}
+
 const state = crossCopyState(/* @__PURE__ */ Symbol.for("attaform:field-meta-state"), () => ({
   store: /* @__PURE__ */ new WeakMap(),
   lists: /* @__PURE__ */ new WeakMap(),
@@ -929,10 +951,20 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     }
     case "default":
     case "readonly":
+    case "success":
     case "catch": {
       const inner = intro.unwrapInner(schema);
       return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
     }
+    case "nonoptional": {
+      const inner = intro.unwrapInner(schema);
+      if (inner === void 0) return PERMISSIVE_SLIM_KINDS;
+      const innerSet = slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
+      if (!innerSet.has("undefined")) return innerSet;
+      const out = new Set(innerSet);
+      out.delete("undefined");
+      return out;
+    }
     case "branded": {
       const inner = intro.unwrapBranded(schema);
       return inner === void 0 ? PERMISSIVE_SLIM_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth);
@@ -985,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.
@@ -1167,4 +1199,4 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress,
   }
 }
 
-export { getFieldMetaListForSchema as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };
+export { createSharedSchemaStore as a, buildFieldMetaPathMap as b, createAbstractSchema as c, deriveDefaultWalk as d, getFieldMetaListForSchema as e, fixStructuralDefaults as f, getFieldMetaForSchema as g, installingFieldMetaStore as i, mergeDeep as m, slimPrimitivesWalk as s, walkPathSegments as w };

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

@@ -1,6 +1,6 @@
 import { reactive, markRaw, effectScope, watch, nextTick } from 'vue';
 import { i as isRegisterValue, a as isTransforming, S as SSR_COMPONENT_HOST_MODIFIER, R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
-import { e as canonicalizePath } from './attaform.CZYt_5N_.mjs';
+import { e as canonicalizePath } from './attaform.CdZIEf7_.mjs';
 
 const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 
@@ -271,7 +271,7 @@ function isCheckboxInput(tagName, type) {
   return tagName === "INPUT" && typeof type === "string" && type.toLowerCase() === "checkbox";
 }
 function applyAria(el, rv, vnode) {
-  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return;
+  if (rv.ariaDisplayState === void 0) return;
   if (!INTERACTIVE_TAG_NAMES.has(el.tagName)) return;
   const locks = el[ariaLockKey] ?? EMPTY_ARIA_LOCKS;
   const ds = rv.ariaDisplayState.value;
@@ -286,7 +286,7 @@ function applyAria(el, rv, vnode) {
   }
 }
 function setupAria(el, rv, vnode) {
-  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return;
+  if (rv.ariaDisplayState === void 0) return;
   if (!INTERACTIVE_TAG_NAMES.has(el.tagName)) return;
   mergeAriaLocks(el, vnode);
   applyAria(el, rv, vnode);
@@ -308,7 +308,7 @@ function seedLocksFromDom(el) {
   }
 }
 function setupAriaLive(el, rv) {
-  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return;
+  if (rv.ariaDisplayState === void 0) return;
   if (!INTERACTIVE_TAG_NAMES.has(el.tagName)) return;
   seedLocksFromDom(el);
   applyAria(el, rv, null);
@@ -320,7 +320,7 @@ function setupAriaLive(el, rv) {
   el[ariaScopeKey] = () => scope.stop();
 }
 function getSSRAriaProps(rv, vnode) {
-  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return void 0;
+  if (rv.ariaDisplayState === void 0) return void 0;
   const props = vnode?.props ?? null;
   const ds = rv.ariaDisplayState.value;
   const tagName = typeof vnode?.type === "string" ? vnode.type.toUpperCase() : "";
@@ -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;
@@ -1264,7 +1252,7 @@ const vRegisterDynamic = {
     callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
     const ariaEl = el;
     const value = binding.value;
-    if (!isRegisterValue(value) || value.ariaEnabled !== true || value.ariaDisplayState === void 0) {
+    if (!isRegisterValue(value) || value.ariaDisplayState === void 0) {
       teardownAria(ariaEl);
     } else {
       const old = binding.oldValue;
@@ -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) and the ariaEnabled gate, 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;