attaform 0.29.0 → 0.30.1

package/dist/shared/{attaform.CZMAYwSK.mjs → attaform.BIWicztt.mjs}

@@ -1,12 +1,12 @@
-import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, reactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.D0x-qSXm.mjs';
-import { c as armDomBinding } from './attaform.DffRL5pP.mjs';
+import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.WiGdIqgx.mjs';
+import { c as armDomBinding } from './attaform.D_f1WgYf.mjs';
 import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
-import { A as ANONYMOUS_FORM_KEY_PREFIX, d as consumerHas, i as isShadowedKey, e as safeOwnHas, a as safeOwnRead, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.Cvao8bW5.mjs';
-import { i as isPathPrefix, e as canonicalizePath, j as cellEntriesFor, s as segmentsForPathKey, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, l as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, o as normalizeErrorInputs, q as coerceToPathKey, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform.CZYt_5N_.mjs';
+import { A as ANONYMOUS_FORM_KEY_PREFIX, i as isShadowedKey, d as safeOwnHas, a as safeOwnRead, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, c as callConsumerFn, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.8mfKZCwH.mjs';
+import { i as isPathPrefix, e as canonicalizePath, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, s as segmentsForPathKey, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform.CdZIEf7_.mjs';
 
 const AttaformErrorCode = {
-  /** A required field is in the blank set — user hasn't supplied a value. */
+  /** A required field is in the blank set: no value was supplied. */
   NoValueSupplied: "atta:no-value-supplied",
   /** The schema adapter's `validateAtPath` threw synchronously. */
   AdapterThrew: "atta:adapter-threw",
@@ -78,11 +78,6 @@ function makeBlankRequiredError(segments) {
 }
 const NO_ERRORS = Object.freeze([]);
 
-function crossCopyState(key, create) {
-  const carrier = globalThis;
-  return carrier[key] ?? (carrier[key] = create());
-}
-
 function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
 }
@@ -104,45 +99,32 @@ function earliestNonNull(a, b) {
   return a < b ? a : b;
 }
 const DEFAULT_TIMINGS = { showDelay: 120, minVisible: 120 };
+const { showDelay, minVisible } = DEFAULT_TIMINGS;
 const FOCUS_OUT_GRACE = 16;
-const defaultFamily = crossCopyState(
-  /* @__PURE__ */ Symbol.for("attaform:default-display-state-family"),
-  () => /* @__PURE__ */ new WeakSet()
-);
-function isDefaultDisplayState(fn) {
-  return defaultFamily.has(fn);
-}
-function makeDefaultDisplayState({
-  showDelay,
-  minVisible
-}) {
-  const reducer = (prev, { field, formMeta, validatingSince, transformingSince, now }) => {
-    const verdict = computeVerdict(field, formMeta);
-    if (!isGateOpen(field, formMeta)) return { display: verdict };
-    const inFlightSince = earliestNonNull(validatingSince, transformingSince);
-    if (inFlightSince === null) {
-      if (prev.display === "pending") {
-        const shownAt = prev.pendingShownAt ?? now;
-        if (now < shownAt + minVisible)
-          return { display: "pending", pendingShownAt: shownAt, reviewAt: shownAt + minVisible };
-      }
-      return { display: verdict };
-    }
-    if (prev.display === "pending")
-      return { display: "pending", pendingShownAt: prev.pendingShownAt ?? now };
-    const window = field.focused === false ? Math.min(showDelay, FOCUS_OUT_GRACE) : showDelay;
-    if (now - inFlightSince < window) {
-      return { display: prev.display, reviewAt: inFlightSince + window };
+const defaultDisplayState = (prev, { field, formMeta, validatingSince, transformingSince, now }) => {
+  const verdict = computeVerdict(field, formMeta);
+  if (!isGateOpen(field, formMeta)) return { display: verdict };
+  const inFlightSince = earliestNonNull(validatingSince, transformingSince);
+  if (inFlightSince === null) {
+    if (prev.display === "pending") {
+      const shownAt = prev.pendingShownAt ?? now;
+      if (now < shownAt + minVisible)
+        return {
+          display: "pending",
+          pendingShownAt: shownAt,
+          reviewAt: shownAt + minVisible
+        };
     }
-    return { display: "pending", pendingShownAt: now, reviewAt: now + minVisible };
-  };
-  defaultFamily.add(reducer);
-  return reducer;
-}
-const defaultDisplayState = makeDefaultDisplayState(DEFAULT_TIMINGS);
-function resolveGetDisplayState(config) {
-  return config ?? defaultDisplayState;
-}
+    return { display: verdict };
+  }
+  if (prev.display === "pending")
+    return { display: "pending", pendingShownAt: prev.pendingShownAt ?? now };
+  const window = field.focused === false ? Math.min(showDelay, FOCUS_OUT_GRACE) : showDelay;
+  if (now - inFlightSince < window) {
+    return { display: prev.display, reviewAt: inFlightSince + window };
+  }
+  return { display: "pending", pendingShownAt: now, reviewAt: now + minVisible };
+};
 
 function hashStableString(input, seed = 0) {
   let h1 = 3735928559 ^ seed;
@@ -230,16 +212,27 @@ function descendStep(value, segment) {
 }
 function getAtPath(root, path) {
   if (path.length === 0) return root;
-  let current = root;
-  for (const segment of path) {
-    const next = descendStep(current, segment);
-    if (next === NOT_FOUND) return void 0;
-    current = next;
+  try {
+    let current = root;
+    for (const segment of path) {
+      const next = descendStep(current, segment);
+      if (next === NOT_FOUND) return void 0;
+      current = next;
+    }
+    return current;
+  } catch {
+    return void 0;
   }
-  return current;
 }
 function hasAtPath(root, path) {
   if (path.length === 0) return true;
+  try {
+    return hasAtPathUnguarded(root, path);
+  } catch {
+    return false;
+  }
+}
+function hasAtPathUnguarded(root, path) {
   let current = root;
   for (let i = 0; i < path.length - 1; i++) {
     const segment = path[i];
@@ -266,29 +259,15 @@ function isPlainRecord(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
+const NO_SCHEMA_DEFAULTS = /* @__PURE__ */ new Set();
+const NO_SCHEMA_FILL = {
+  getDefaultAtPath: () => void 0,
+  arrayShapeAtPath: () => null,
+  getSlimPrimitiveTypesAtPath: () => NO_SCHEMA_DEFAULTS,
+  entryKeyKindAtPath: () => void 0
+};
 function setAtPath(root, path, value) {
-  return setAtPathOffset(root, path, value, 0);
-}
-function setAtPathOffset(root, path, value, offset) {
-  if (offset >= path.length) return value;
-  const head = path[offset];
-  const nextOffset = offset + 1;
-  if (root instanceof Map) {
-    const next = new Map(root);
-    const key = mapKeyForSegment(root, head);
-    next.set(key, setAtPathOffset(root.get(key), path, value, nextOffset));
-    return next;
-  }
-  if (!isRebuildableContainer(root, head)) return root;
-  if (typeof head === "number") {
-    const arr = Array.isArray(root) ? [...root] : [];
-    while (arr.length <= head) arr.push(void 0);
-    arr[head] = setAtPathOffset(arr[head], path, value, nextOffset);
-    return arr;
-  }
-  const rec = isPlainRecord(root) ? { ...root } : {};
-  safeAssign(rec, head, setAtPathOffset(safeOwnRead(rec, head), path, value, nextOffset));
-  return rec;
+  return setAtPathWithSchemaFill(root, NO_SCHEMA_FILL, path, value);
 }
 const NO_IN_PLACE = { applied: false };
 function tryInPlaceLeafWrite(root, path, value) {
@@ -494,10 +473,10 @@ function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
   }
   const rec = isPlainRecord(root) ? { ...root } : {};
   if (isLeafStep) {
-    rec[head] = value;
+    safeAssign(rec, head, value);
     return rec;
   }
-  const existing = rec[head];
+  const existing = safeOwnRead(rec, head);
   let childRoot;
   if (existing === void 0 || existing !== null && typeof existing !== "object") {
     const intermPath = [...fullPath.slice(0, startIdx + 1)];
@@ -506,7 +485,11 @@ function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
   } else {
     childRoot = existing;
   }
-  rec[head] = setAtPathWithSchemaFillImpl(childRoot, schema, fullPath, value, startIdx + 1);
+  safeAssign(
+    rec,
+    head,
+    setAtPathWithSchemaFillImpl(childRoot, schema, fullPath, value, startIdx + 1)
+  );
   return rec;
 }
 
@@ -523,16 +506,15 @@ function isUnderStubAncestor(state, segments) {
   }
   return false;
 }
-function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, sweep, options) {
+function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, sweep) {
   const cache = /* @__PURE__ */ new Map();
-  const predicate = options?.getDisplayState;
   sweep.onEvict((key) => cache.delete(key));
   return function getFieldState(pathInput) {
     const { segments, key } = canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = computed(
-      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate)
+      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase) : buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase)
     );
     cache.set(key, c);
     sweep.track(segments, key);
@@ -549,7 +531,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const record = state.fields.get(key);
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
-  const pristine = state.isPristineAtPath(segments);
+  const pristine = state.isPristineAtPathByKey(key, segments);
   const cell = state.errorCells.get(key);
   const schemaForKey = cell !== void 0 && cell.schema.length > 0 ? cell.schema : void 0;
   const blankForKey = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments)] : void 0;
@@ -561,7 +543,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const validating = (state.fieldValidationCounts.get(key) ?? 0) > 0;
   const transforming = (state.fieldTransformCounts.get(key) ?? 0) > 0;
   const transformError = state.transformErrors.get(key) ?? null;
-  const gated = state.pathHasAsyncValidation(segments) && !state.firstValidationDone.value;
+  const gated = state.pathHasAsyncValidationByKey(key, segments) && !state.firstValidationDone.value;
   const isOrphan = segments.length > 0 && !hasAtPath(state.form.value, segments) && isUnderStubAncestor(state, segments);
   const valid = !gated && errors.length === 0 && !validating && !isOrphan;
   const elementRecord = state.domBinding.value?.elements.get(key);
@@ -584,9 +566,8 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     updatedAt: record?.updatedAt ?? null,
     errors,
     // A leaf has no descendants, so its own-bucket errors ARE its subtree
-    // errors. Reuse the same array reference: referential `ownErrors ===
-    // errors`, and no second read of the whole-form `derivedBlankErrors`
-    // map (preserves the P3 blank-reactivity optimization above).
+    // errors. Reuse the array reference, which makes `ownErrors === errors`
+    // and avoids a second read of the whole-form `derivedBlankErrors` map.
     ownErrors: errors,
     validating,
     valid,
@@ -604,7 +585,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     meta: resolved.meta
   };
 }
-function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase) {
   const base = buildLeafFieldStateBase(state, segments, key, formInstanceId);
   const validatingSince = state.fieldValidatingSince.get(key) ?? null;
   const transformingSince = state.fieldTransformingSince.get(key) ?? null;
@@ -617,9 +598,8 @@ function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBa
     transformingSince,
     false,
     // revealedDescendantError: leaves have no descendants
-    false,
+    false
     // isRoot: a leaf is never the form root
-    getDisplayState
   );
 }
 function visitActiveLeafPaths(value, base, visit) {
@@ -717,7 +697,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     pristine = false;
     dirty = true;
   }
-  const errors = aggregateErrorsAt(state, segments);
+  const errors = aggregateErrorsAt(state, segments, key);
   const revealedDescendantError = errors.length > 0 && errors.some((e) => {
     const ePath = e.path;
     if (ePath.length === segments.length && ePath.every((s, i) => s === segments[i])) return false;
@@ -725,7 +705,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (ePath.length === 1 && ePath[0] === "") return blurredAfterInteraction;
     return blurredLeafSegments.some((s) => isPathPrefix(ePath, s));
   });
-  if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
+  if (!asyncPending && state.pathHasAsyncValidationByKey(key, segments)) asyncPending = true;
   if ((state.fieldValidationCounts.get(key) ?? 0) > 0) {
     validating = true;
     const since = state.fieldValidatingSince.get(key);
@@ -767,19 +747,19 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       elements: EMPTY_ELEMENTS,
       updatedAt,
       errors,
-      // The container's OWN bucket only (this exact path), excluding every
-      // descendant that `errors` rolls up: a cross-field `.refine()` here,
-      // or `setErrors` pinned at this node. The same raw union the leaf
-      // builds from the three stores; the container already depends on all
-      // three via `aggregateErrorsAt`, so there's no new reactivity cost.
+      // The container's OWN bucket at this exact path, excluding every
+      // descendant `errors` rolls up: a cross-field `.refine()` here, or a
+      // `setErrors` pinned at this node. The same raw union the leaf builds
+      // from the three stores, and the container already depends on all three
+      // through `aggregateErrorsAt`, so it costs no new reactivity.
       ownErrors: state.getErrorsForPath(segments),
       validating,
       valid,
       transforming,
       busy: transforming || validating,
-      // A container surfaces its OWN transform failure (a transform registered
-      // on the container path, e.g. a file normalizer) but never rolls up a
-      // descendant leaf's failure — that stays a per-field channel.
+      // A container surfaces its OWN transform failure, from a transform
+      // registered on the container path such as a file normalizer, and never
+      // rolls up a descendant's: that stays a per-field channel.
       transformError: ownTransformError,
       path: segments,
       ...computeFieldIdentity(formInstanceId, state.formKey, key),
@@ -796,7 +776,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     revealedDescendantError
   };
 }
-function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase) {
   const { base, validatingSince, transformingSince, revealedDescendantError } = buildContainerFieldStateBase(state, segments, key, formInstanceId);
   return decorateWithDerivedProps(
     base,
@@ -806,14 +786,12 @@ function buildContainerFieldState(state, segments, key, formInstanceId, getFormM
     validatingSince,
     transformingSince,
     revealedDescendantError,
-    segments.length === 0,
-    getDisplayState
+    segments.length === 0
   );
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, transformingSince, revealedDescendantError, isRoot, getDisplayState) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, transformingSince, revealedDescendantError, isRoot) {
   const firstError = base.errors[0];
   const firstOwnError = base.ownErrors[0];
-  const predicate = getDisplayState ?? state.getDisplayState;
   const formMeta = getFormMetaBase();
   const ctx = {
     field: base,
@@ -824,16 +802,9 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     // flight) so the reducer returns the plain verdict and hydration matches.
     now: state.ssr ? 0 : Date.now()
   };
-  let machine;
-  let rollupApplies = isDefaultDisplayState(predicate);
-  try {
-    machine = state.displayEngine.resolve(key, ctx, predicate);
-  } catch (err) {
-    machine = state.displayEngine.resolve(key, ctx, defaultDisplayState);
-    rollupApplies = true;
-  }
-  const submitValidating = rollupApplies && isRoot && state.submitting.value && state.activeValidations.value > 0;
-  const resolvedDisplayState = machine.display === "pending" || submitValidating ? "pending" : rollupApplies && revealedDescendantError ? "error" : machine.display;
+  const machine = state.displayEngine.resolve(key, ctx, defaultDisplayState);
+  const submitValidating = isRoot && state.submitting.value && state.activeValidations.value > 0;
+  const resolvedDisplayState = machine.display === "pending" || submitValidating ? "pending" : revealedDescendantError ? "error" : machine.display;
   const displayState = base.disabled === true ? "idle" : resolvedDisplayState;
   return {
     ...base,
@@ -846,26 +817,33 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     firstOwnError
   };
 }
-function aggregateErrorsAt(state, prefix) {
+function aggregateErrorsAt(state, prefix, prefixKey) {
+  const candidates = state.errorWindowAt(prefix, prefixKey);
+  if (candidates.length === 0) return [];
   const formValue = state.form.value;
+  const cells = state.errorCells;
   const buckets = /* @__PURE__ */ new Map();
-  const collect = (errs) => {
-    for (const [pathKey, list] of errs) {
-      if (list.length === 0) continue;
-      const segs = segmentsForPathKey(pathKey);
-      if (segs === null) continue;
-      if (!isPathPrefix(prefix, segs)) continue;
-      if (segs.length > 0 && !hasAtPath(formValue, segs)) continue;
-      const ordinal = state.ensurePathOrdinal(pathKey);
-      const existing = buckets.get(ordinal);
-      if (existing === void 0) buckets.set(ordinal, [...list]);
-      else existing.push(...list);
-    }
-  };
-  collect(cellEntriesFor(state.errorCells, "schema"));
-  collect(state.derivedBlankErrors.value);
-  collect(cellEntriesFor(state.errorCells, "user"));
+  for (const { key, segments } of candidates) {
+    if (!isPathPrefix(prefix, segments)) continue;
+    if (segments.length > 0 && !hasAtPath(formValue, segments)) continue;
+    const cell = cells.get(key);
+    const blankList = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments)] : void 0;
+    const schemaList = cell?.schema;
+    const userList = cell?.user;
+    const total = (schemaList?.length ?? 0) + (blankList?.length ?? 0) + (userList?.length ?? 0);
+    if (total === 0) continue;
+    const ordinal = state.ensurePathOrdinal(key);
+    let bucket = buckets.get(ordinal);
+    if (bucket === void 0) {
+      bucket = [];
+      buckets.set(ordinal, bucket);
+    }
+    if (schemaList !== void 0) bucket.push(...schemaList);
+    if (blankList !== void 0) bucket.push(...blankList);
+    if (userList !== void 0) bucket.push(...userList);
+  }
   if (buckets.size === 0) return [];
+  if (buckets.size === 1) return [...buckets.values()][0];
   return [...buckets.entries()].sort(([a], [b]) => a - b).flatMap(([, errs]) => errs);
 }
 const EMPTY_ELEMENTS = Object.freeze([]);
@@ -957,7 +935,7 @@ function buildTree(spec) {
     existsCache.delete(key);
   });
   function schemaHasPath(segs) {
-    const cacheKey = JSON.stringify(segs);
+    const cacheKey = keyForSegments(segs).key;
     const cached = existsCache.get(cacheKey);
     if (cached !== void 0) return cached;
     const result = spec.schema.getSlimPrimitiveTypesAtPath(segs).size > 0;
@@ -972,7 +950,7 @@ function buildTree(spec) {
   }
   function containerAt(segments) {
     const isArrayLike = spec.isArrayAt(segments);
-    const pathKey = JSON.stringify(segments);
+    const pathKey = keyForSegments(segments).key;
     const cacheKey = `${pathKey}+${isArrayLike ? "A" : "O"}`;
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
@@ -1072,7 +1050,7 @@ function buildErrorsSurface(state, sweep) {
   const treeCache = /* @__PURE__ */ new Map();
   sweep.onEvict((key) => treeCache.delete(key));
   const materialize = (segments) => {
-    const cacheKey = JSON.stringify(segments);
+    const cacheKey = keyForSegments(segments).key;
     let tree = treeCache.get(cacheKey);
     if (tree === void 0) {
       const frozen = [...segments];
@@ -1084,28 +1062,21 @@ function buildErrorsSurface(state, sweep) {
   };
   const resolveLeaf = (path) => {
     const isContainerSelfAccess = path.length > 1 && path[path.length - 1] === "";
-    const collectAtKey = (key2, active2, into) => {
-      const cell = state.errorCells.get(key2);
-      if (active2) {
-        const b = state.derivedBlankErrors.value.get(key2);
-        if (cell !== void 0) into.push(...cell.schema);
-        if (b !== void 0) into.push(...b);
-      }
-      if (cell !== void 0) into.push(...cell.user);
-    };
     const merged = [];
     if (isContainerSelfAccess) {
       const containerPath = path.slice(0, -1);
-      const containerKey = canonicalizePath(containerPath).key;
-      const literalKey = canonicalizePath(path).key;
+      const container = canonicalizePath(containerPath);
+      const literal = canonicalizePath(path);
       const active2 = hasAtPath(state.form.value, containerPath);
-      collectAtKey(containerKey, active2, merged);
-      if (literalKey !== containerKey) collectAtKey(literalKey, active2, merged);
+      collectErrorsAt(state, container.key, container.segments, active2, merged);
+      if (literal.key !== container.key) {
+        collectErrorsAt(state, literal.key, literal.segments, active2, merged);
+      }
       return merged;
     }
-    const { key } = canonicalizePath(path);
+    const { key, segments } = canonicalizePath(path);
     const active = hasAtPath(state.form.value, path);
-    collectAtKey(key, active, merged);
+    collectErrorsAt(state, key, segments, active, merged);
     return merged;
   };
   return buildTree({
@@ -1120,68 +1091,83 @@ function buildErrorsSurface(state, sweep) {
     // non-schema keys reachable while a genuinely-absent key stays out.
     hasOwn: (segments, key) => liveContainerHasKey(state, segments, key) || errorAwareContainerKeys(state, segments).includes(key),
     isArrayAt: (segments) => isArrayPath(state, segments),
-    // `errors()` / `errors([])` / `errors(path)` are all the subtree
-    // aggregate — the same helper `meta.errors` reads, so the surfaces
-    // never drift.
-    call: (path) => aggregateErrorsAt(state, path),
+    // `errors()`, `errors([])` and `errors(path)` are all the subtree
+    // aggregate, through the helper `meta.errors` reads, so they cannot
+    // drift.
+    call: (path) => aggregateErrorsAt(state, path, keyForSegments(path).key),
     surface: "form.errors",
     sweep
   });
 }
+function collectErrorsAt(state, key, segments, active, into) {
+  const cell = state.errorCells.get(key);
+  if (active) {
+    if (cell !== void 0) into.push(...cell.schema);
+    if (state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments)) {
+      into.push(makeBlankRequiredError(segments));
+    }
+  }
+  if (cell !== void 0) into.push(...cell.user);
+}
 function errorAwareContainerKeys(state, segments) {
   const keys = new Set(liveKeysAtPath(state, segments));
   const formValue = state.form.value;
-  const walk = (store, applyActivePathFilter) => {
-    for (const [pathKey, errors] of store) {
-      if (errors.length === 0) continue;
-      const decoded = segmentsForPathKey(pathKey);
-      if (decoded === null) continue;
-      if (decoded.length <= segments.length) continue;
-      if (!isPathPrefix(segments, decoded)) continue;
-      if (applyActivePathFilter && !hasAtPath(formValue, decoded)) continue;
-      const nextSeg = decoded[segments.length];
-      keys.add(typeof nextSeg === "number" ? String(nextSeg) : nextSeg);
-    }
-  };
-  walk(cellEntriesFor(state.errorCells, "schema"), true);
-  walk(state.derivedBlankErrors.value, true);
-  walk(cellEntriesFor(state.errorCells, "user"), false);
+  const errors = [];
+  const found = [];
+  for (const { key, segments: decoded } of state.errorWindowAt(
+    segments,
+    keyForSegments(segments).key
+  )) {
+    if (decoded.length <= segments.length) continue;
+    if (!isPathPrefix(segments, decoded)) continue;
+    errors.length = 0;
+    collectErrorsAt(state, key, decoded, hasAtPath(formValue, decoded), errors);
+    if (errors.length === 0) continue;
+    const nextSeg = decoded[segments.length];
+    found.push({
+      childKey: typeof nextSeg === "number" ? String(nextSeg) : nextSeg,
+      ordinal: state.ensurePathOrdinal(key)
+    });
+  }
+  found.sort((a, b) => a.ordinal - b.ordinal);
+  for (const { childKey } of found) keys.add(childKey);
   return [...keys];
 }
 function materializeErrors(state, containerSegments) {
-  const liveContainer = getAtPath(state.form.value, containerSegments);
+  const formValue = state.form.value;
+  const liveContainer = getAtPath(formValue, containerSegments);
   const tree = Array.isArray(liveContainer) ? [] : {};
-  const collect = (store, applyActivePathFilter) => {
-    entries: for (const [pathKey, errors] of store) {
-      if (errors.length === 0) continue;
-      const fullPath = segmentsForPathKey(pathKey);
-      if (fullPath === null) continue;
-      if (fullPath.length === 0) {
-        if (containerSegments.length === 0) placeAt(tree, [ROOT_PATH_KEY], errors);
-        continue;
-      }
-      if (fullPath.length < containerSegments.length) continue;
-      for (let i = 0; i < containerSegments.length; i++) {
-        if (fullPath[i] !== containerSegments[i]) continue entries;
-      }
-      if (applyActivePathFilter && !hasAtPath(state.form.value, fullPath)) continue;
-      const relativePath = fullPath.slice(containerSegments.length);
-      let placePath;
-      if (relativePath.length === 0) {
-        placePath = [""];
-      } else if (state.schema.isLeafAtPath(fullPath)) {
-        placePath = relativePath;
-      } else if (state.schema.getSlimPrimitiveTypesAtPath(fullPath).size > 0) {
-        placePath = [...relativePath, ""];
-      } else {
-        placePath = relativePath;
-      }
-      placeAt(tree, placePath, errors);
+  const placements = [];
+  for (const { key, segments: fullPath } of state.errorWindowAt(
+    containerSegments,
+    keyForSegments(containerSegments).key
+  )) {
+    const isRoot = fullPath.length === 0;
+    if (isRoot) {
+      if (containerSegments.length !== 0) continue;
+    } else if (!isPathPrefix(containerSegments, fullPath)) {
+      continue;
     }
-  };
-  collect(cellEntriesFor(state.errorCells, "schema"), true);
-  collect(state.derivedBlankErrors.value, true);
-  collect(cellEntriesFor(state.errorCells, "user"), false);
+    const errors = [];
+    collectErrorsAt(state, key, fullPath, isRoot || hasAtPath(formValue, fullPath), errors);
+    if (errors.length === 0) continue;
+    const relativePath = fullPath.slice(containerSegments.length);
+    let placePath;
+    if (isRoot) {
+      placePath = [ROOT_PATH_KEY];
+    } else if (relativePath.length === 0) {
+      placePath = [""];
+    } else if (state.schema.isLeafAtPath(fullPath)) {
+      placePath = relativePath;
+    } else if (state.schema.getSlimPrimitiveTypesAtPath(fullPath).size > 0) {
+      placePath = [...relativePath, ""];
+    } else {
+      placePath = relativePath;
+    }
+    placements.push({ placePath, errors, ordinal: state.ensurePathOrdinal(key) });
+  }
+  placements.sort((a, b) => a.ordinal - b.ordinal);
+  for (const { placePath, errors } of placements) placeAt(tree, placePath, errors);
   return tree;
 }
 function placeAt(tree, path, errors) {
@@ -1254,7 +1240,7 @@ function buildFieldsSurface(state, getFieldStateAt, sweep) {
   const viewCache = /* @__PURE__ */ new Map();
   sweep.onEvict((key) => viewCache.delete(key));
   function viewAt(segments) {
-    const cacheKey = JSON.stringify(segments);
+    const cacheKey = keyForSegments(segments).key;
     const existing = viewCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(
@@ -1816,45 +1802,6 @@ function buildFieldArrayApi(state) {
   };
 }
 
-const SWEEP_SLICE = 8;
-function createDynamicPathSweep(state) {
-  const dynamicKeys = /* @__PURE__ */ new Set();
-  const evictors = [];
-  const isDynamicPath = (segments) => {
-    for (let i = 0; i < segments.length; i++) {
-      if (typeof segments[i] === "number") return true;
-      if (!state.schema.isFixedObjectAtPath(segments.slice(0, i))) return true;
-    }
-    return false;
-  };
-  let sweepCursor = null;
-  state.onFormChange((next) => {
-    if (dynamicKeys.size === 0) return;
-    const raw = toRaw(next);
-    for (let i = 0; i < SWEEP_SLICE; i++) {
-      sweepCursor ?? (sweepCursor = dynamicKeys.values());
-      const step = sweepCursor.next();
-      if (step.done === true) {
-        sweepCursor = null;
-        break;
-      }
-      const segments = segmentsForPathKey(step.value);
-      if (segments !== null && hasAtPath(raw, segments)) continue;
-      dynamicKeys.delete(step.value);
-      for (const evict of evictors) evict(step.value);
-    }
-  });
-  return {
-    track(segments, key) {
-      if (dynamicKeys.has(key)) return;
-      if (isDynamicPath(segments)) dynamicKeys.add(key);
-    },
-    onEvict(evict) {
-      evictors.push(evict);
-    }
-  };
-}
-
 function isErrorInputLike(value) {
   if (value instanceof Error) return true;
   if (typeof value !== "object" || value === null) return false;
@@ -1881,8 +1828,8 @@ function deriveSubmitErrors(err) {
     messageless: true
   };
 }
-function buildProcessForm(state, formInstanceId, options = {}) {
-  const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
+function buildProcessForm(state, options = {}) {
+  const applyInvalidSubmit = options.applyInvalidSubmit;
   function validate(pathInput) {
     const result = ref({
       pending: true,
@@ -1975,7 +1922,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     };
   }
   async function runRefinementValidation(data, path) {
-    return await state.schema.validateAtPath(data, path);
+    return stampFormKey(await state.schema.validateAtPath(data, path), state.formKey);
   }
   function composeWithDerivedBlank(refinement, scope) {
     const blankErrors = collectScopedBlankErrors(state, scope);
@@ -2021,7 +1968,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
             }
           }
           if (generationStillValid) {
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
           if (onError !== void 0) {
             try {
@@ -2038,7 +1985,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         await onSubmit(merged.data);
         if (hasUserErrorEntries(state)) {
           if (state.submissionGeneration.value === genAtEntry) {
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
           return;
         }
@@ -2056,7 +2003,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
               if (segments === null) continue;
               state.setUserErrorsForPath([...segments], bucket);
             }
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
         }
       } finally {
@@ -2071,6 +2018,10 @@ function buildProcessForm(state, formInstanceId, options = {}) {
   };
   return { validate, parse, handleSubmit };
 }
+function stampFormKey(verdict, formKey) {
+  if (verdict.success) return { ...verdict, formKey };
+  return verdict.data === void 0 ? { data: void 0, errors: verdict.errors, success: false, formKey } : { data: verdict.data, errors: verdict.errors, success: false, formKey };
+}
 function toSegments(pathInput) {
   return canonicalizePath(pathInput).segments;
 }
@@ -2104,21 +2055,6 @@ function collectScopedBlankErrors(state, scope) {
   }
   return errors;
 }
-function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
-  if (policy === "none") return;
-  const target = state.domBinding.value?.getFirstErrorElement(formInstanceId) ?? null;
-  if (target === null) return;
-  if (policy === "scroll-to-first-error") {
-    target.element.scrollIntoView();
-    return;
-  }
-  if (policy === "focus-first-error") {
-    target.element.focus({ focusVisible: true });
-    return;
-  }
-  target.element.scrollIntoView();
-  target.element.focus({ preventScroll: true, focusVisible: true });
-}
 
 function slimKindOf(value) {
   if (value === null) return "null";
@@ -2182,51 +2118,9 @@ function walk(schema, store, path, value) {
   return true;
 }
 
-function defineCoercion(entry) {
-  return entry;
-}
 const IDENTITY = (v) => v;
-const EMPTY_INDEX = /* @__PURE__ */ new Map();
-const defaultCoercionRules = [
-  defineCoercion({
-    input: "string",
-    output: "number",
-    transform: (s) => {
-      const trimmed = s.trim();
-      if (trimmed === "") return { coerced: false };
-      const n = Number(trimmed);
-      if (!Number.isFinite(n)) return { coerced: false };
-      return { coerced: true, value: n };
-    }
-  }),
-  defineCoercion({
-    input: "string",
-    output: "boolean",
-    transform: (s) => {
-      const normalized = s.trim().toLowerCase();
-      if (normalized === "true") return { coerced: true, value: true };
-      if (normalized === "false") return { coerced: true, value: false };
-      return { coerced: false };
-    }
-  })
-];
-function resolveCoercionIndex(config) {
-  if (config === false) return EMPTY_INDEX;
-  const rules = config === void 0 || config === true ? defaultCoercionRules : config;
-  return indexRules(rules);
-}
-function indexRules(rules) {
-  const idx = /* @__PURE__ */ new Map();
-  for (const entry of rules) {
-    const candidate = entry;
-    if (candidate === null || typeof candidate !== "object" || typeof candidate.transform !== "function") {
-      continue;
-    }
-    const key = `${entry.input}->${entry.output}`;
-    if (idx.has(key) && false) ;
-    idx.set(key, entry);
-  }
-  return idx;
+function resolveCoerceEnabled(config) {
+  return config !== false;
 }
 function memberSlimTypes(schema, segments, accepted) {
   if (accepted.has("array")) return schema.getSlimPrimitiveTypesAtPath([...segments, 0]);
@@ -2235,89 +2129,83 @@ function memberSlimTypes(schema, segments, accepted) {
   }
   return void 0;
 }
-function buildCoerceFn(schema, segments, index) {
-  if (index === EMPTY_INDEX) return IDENTITY;
-  if (index.size === 0) return IDENTITY;
+function buildCoerceFn(schema, segments, enabled) {
+  if (!enabled) return IDENTITY;
   const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
   const elementAccepted = memberSlimTypes(schema, segments, accepted);
-  return (value) => coerceValue(value, accepted, elementAccepted, index);
+  return (value) => coerceValue(value, accepted, elementAccepted);
 }
-function buildElementCoerceFn(schema, segments, index) {
-  if (index === EMPTY_INDEX) return void 0;
-  if (index.size === 0) return void 0;
+function buildElementCoerceFn(schema, segments, enabled) {
+  if (!enabled) return void 0;
   const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
   const elementAccepted = memberSlimTypes(schema, segments, accepted);
   if (elementAccepted === void 0) return void 0;
-  return (value) => coerceScalar(value, elementAccepted, index);
+  return (value) => coerceScalar(value, elementAccepted);
 }
 function pickScalarTarget(accepted) {
   if (accepted.has("string")) return null;
   if (accepted.has("number")) return "number";
   if (accepted.has("boolean")) return "boolean";
-  if (accepted.has("bigint")) return "bigint";
   return null;
 }
-function coerceScalar(value, accepted, index) {
+function toNumber(source) {
+  const trimmed = source.trim();
+  if (trimmed === "") return source;
+  const n = Number(trimmed);
+  return Number.isFinite(n) ? n : source;
+}
+function toBoolean(source) {
+  const normalized = source.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  return source;
+}
+function coerceScalar(value, accepted) {
   if (accepted.size === 0) return value;
   const sourceKind = slimKindOf(value);
   if (accepted.has(sourceKind)) return value;
+  if (sourceKind !== "string") return value;
   const target = pickScalarTarget(accepted);
-  if (target === null) return value;
-  const entry = index.get(`${sourceKind}->${target}`);
-  if (entry === void 0) return value;
-  let result;
-  try {
-    result = entry.transform(value);
-  } catch (err) {
-    return value;
-  }
-  if (!result.coerced) return value;
-  const returnedKind = slimKindOf(result.value);
-  if (returnedKind !== entry.output) {
-    return value;
-  }
-  if (entry.output === "number" && !Number.isFinite(result.value)) {
-    return value;
-  }
-  return result.value;
+  if (target === "number") return toNumber(value);
+  if (target === "boolean") return toBoolean(value);
+  return value;
 }
-function coerceArrayMembers(arr, elementAccepted, index) {
+function coerceArrayMembers(arr, elementAccepted) {
   let changed = false;
   const out = [];
   for (const el of arr) {
-    const next = coerceScalar(el, elementAccepted, index);
+    const next = coerceScalar(el, elementAccepted);
     if (next !== el) changed = true;
     out.push(next);
   }
   return changed ? out : arr;
 }
-function coerceSetMembers(set, elementAccepted, index) {
+function coerceSetMembers(set, elementAccepted) {
   let changed = false;
   const out = [];
   for (const el of set) {
-    const next = coerceScalar(el, elementAccepted, index);
+    const next = coerceScalar(el, elementAccepted);
     if (next !== el) changed = true;
     out.push(next);
   }
   return changed ? new Set(out) : set;
 }
-function coerceValue(value, accepted, elementAccepted, index) {
+function coerceValue(value, accepted, elementAccepted) {
   if (Array.isArray(value)) {
     if (!accepted.has("array") || elementAccepted === void 0) return value;
-    return coerceArrayMembers(value, elementAccepted, index);
+    return coerceArrayMembers(value, elementAccepted);
   }
   if (value instanceof Set) {
     if (!accepted.has("set") || elementAccepted === void 0) return value;
-    return coerceSetMembers(value, elementAccepted, index);
+    return coerceSetMembers(value, elementAccepted);
   }
-  return coerceScalar(value, accepted, index);
+  return coerceScalar(value, accepted);
 }
 
 const EMPTY_TRANSFORMS = Object.freeze([]);
 function buildRegister(state, formInstanceId, instanceConfig) {
-  const coerceIndex = instanceConfig?.coerce !== void 0 ? resolveCoercionIndex(instanceConfig.coerce) : state.coerceIndex;
+  const coerceEnabled = instanceConfig?.coerce !== void 0 ? resolveCoerceEnabled(instanceConfig.coerce) : state.coerceEnabled;
   const instanceMeta = instanceConfig?.instanceMeta;
-  const formAutoAria = instanceConfig?.autoAria ?? true;
   const getDisplayStateAt = instanceConfig?.getDisplayStateAt;
   const withInstanceMeta = (meta) => {
     if (instanceMeta === void 0) return meta;
@@ -2357,16 +2245,15 @@ function buildRegister(state, formInstanceId, instanceConfig) {
     const coerce = buildCoerceFn(
       state.schema,
       segments,
-      coerceIndex
+      coerceEnabled
     );
     const coerceElement = buildElementCoerceFn(
       state.schema,
       segments,
-      coerceIndex
+      coerceEnabled
     );
     const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
     const isRequired = state.schema.isRequiredAtPath(segments);
-    const ariaEnabled = options?.autoAria ?? formAutoAria;
     const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
     const markBlank = () => state.setValueAtPath(segments, slimDefault, withInstanceMeta({ blank: true }));
     const internalRv = {
@@ -2406,7 +2293,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         const accepted = isBlankSignal ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
         return accepted;
       },
-      // Called by the `vRegisterHint` compile-time transform's wrapping
+      // Called by the `vRegisterHintTransform` compile-time transform's wrapping
       // IIFE on every server-side render of `<element v-register="…">`.
       // Without it, every SSR'd FieldState serialises `connected: false`
       // (because Vue skips directive lifecycle during SSR) and the client
@@ -2435,12 +2322,12 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         }
         return false;
       },
-      // --- Async transform lifecycle (internal; the directive's
-      // deferred orchestrator is the only legitimate consumer). Thin
-      // path-bound delegates to the store's per-path token / counter
-      // machinery — same pattern as `markBlank` / `setValueWithInternalPath`,
-      // so the directive (which holds only this RegisterValue, never the
-      // store) can drive the busy/discard/error bookkeeping. ---
+      // --- Async transform lifecycle (internal; the directive's deferred
+      // orchestrator is the only legitimate consumer). Thin path-bound
+      // delegates to the store's per-path token and counter machinery,
+      // the same pattern as `markBlank` and `setValueWithInternalPath`, so
+      // the directive (which holds this RegisterValue and never the store)
+      // can drive the busy / discard / error bookkeeping. ---
       beginTransform: (holder) => state.beginTransform(pathKey, holder),
       isCurrentTransform: (token) => state.isCurrentTransform(pathKey, token),
       endTransform: (token) => state.endTransform(pathKey, token),
@@ -2453,10 +2340,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         return (state.fieldTransformCounts.get(pathKey) ?? 0) > 0;
       },
       path: pathKey,
-      // Frozen so a wrapper component can pass `rv.segments` directly
-      // to `form.fields(...)` without defensive copying — and so test
-      // fixtures or downstream code can't mutate the canonical
-      // segment list out from under the directive.
+      // Frozen so a wrapper component can pass `rv.segments` straight to
+      // `form.fields(...)` with no defensive copy, and so neither a test
+      // fixture nor downstream code can mutate the canonical segment list
+      // out from under the directive.
       segments: Object.freeze(segments.slice()),
       formKey: state.formKey,
       formInstanceId,
@@ -2468,7 +2355,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       // --- Aria (internal; consumed by the directive) ---
       aria,
       isRequired,
-      ariaEnabled,
       ...ariaDisplayState !== void 0 ? { ariaDisplayState } : {}
     };
     return shallowReadonly(internalRv);
@@ -2632,11 +2518,50 @@ const DERIVED_DISPLAY_KEYS = /* @__PURE__ */ new Set([
   "firstError",
   "firstOwnError"
 ]);
-const META_SPECIAL_KEYS = /* @__PURE__ */ new Set(["errors", "validating", "valid", "transforming", "busy"]);
-const BASE_MIRROR_KEYS = [...FIELD_STATE_KEYS].filter((k) => !DERIVED_DISPLAY_KEYS.has(k));
-const META_MIRROR_KEYS = [...FIELD_STATE_KEYS].filter((k) => !META_SPECIAL_KEYS.has(k));
-function defineGetter(target, key, get) {
-  Object.defineProperty(target, key, { get, enumerable: true, configurable: true });
+const META_KEYS = [
+  ...FIELD_STATE_KEYS,
+  "submitting",
+  "submissionAttempts",
+  "departAttempts",
+  "submitError",
+  "submitted",
+  "instanceId",
+  "errorCount"
+];
+const BASE_META_KEYS = META_KEYS.filter((k) => !DERIVED_DISPLAY_KEYS.has(k));
+let INERT_HISTORY;
+function inertHistory() {
+  INERT_HISTORY ?? (INERT_HISTORY = readonly({
+    undo: () => false,
+    redo: () => false,
+    clear: () => {
+    },
+    canUndo: false,
+    canRedo: false,
+    size: 0
+  }));
+  return INERT_HISTORY;
+}
+const denyWrite = () => false;
+function buildMetaProxy(keys, read) {
+  const target = {};
+  const owns = new Set(keys);
+  return new Proxy(target, {
+    get: (_, key) => owns.has(key) ? read(key) : Reflect.get(target, key),
+    has: (_, key) => owns.has(key) || Reflect.has(target, key),
+    // Safe to hand back the same array every time: the spec copies a trap's
+    // key list before using it.
+    ownKeys: () => keys,
+    getOwnPropertyDescriptor(_, key) {
+      if (!owns.has(key)) return Reflect.getOwnPropertyDescriptor(target, key);
+      return { configurable: true, enumerable: true, value: read(key), writable: false };
+    },
+    // A getter with no setter throws on assignment under strict mode, which
+    // every module here is; `false` keeps that.
+    set: denyWrite,
+    deleteProperty: denyWrite,
+    defineProperty: denyWrite
+  });
 }
 function buildFormApi(state, formInstanceId, options = {}) {
   const instanceBag = pickDefined({
@@ -2663,32 +2588,26 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const rootBaseComputed = computed(
     () => buildContainerFieldStateBase(state, ROOT_PATH, ROOT_PATH_KEY, formInstanceId).base
   );
-  const metaBase = {
-    instanceId: formInstanceId,
-    get submitting() {
-      return state.submitting.value;
-    },
-    get submissionAttempts() {
-      return state.submissionAttempts.value;
-    },
-    get departAttempts() {
-      return state.departAttempts.value;
-    },
-    get submitError() {
-      return state.submitError.value;
-    },
-    get submitted() {
-      return state.submitted.value;
+  const metaBase = buildMetaProxy(BASE_META_KEYS, (key) => {
+    switch (key) {
+      case "instanceId":
+        return formInstanceId;
+      case "errorCount":
+        return rootBaseComputed.value.errors.length;
+      case "submitting":
+        return state.submitting.value;
+      case "submissionAttempts":
+        return state.submissionAttempts.value;
+      case "departAttempts":
+        return state.departAttempts.value;
+      case "submitError":
+        return state.submitError.value;
+      case "submitted":
+        return state.submitted.value;
+      default:
+        return rootBaseComputed.value[key];
     }
-  };
-  for (const k of BASE_MIRROR_KEYS) {
-    defineGetter(
-      metaBase,
-      k,
-      () => rootBaseComputed.value[k]
-    );
-  }
-  defineGetter(metaBase, "errorCount", () => rootBaseComputed.value.errors.length);
+  });
   const getFormMetaBase = () => {
     void state.submitting.value;
     void state.submissionAttempts.value;
@@ -2697,28 +2616,41 @@ function buildFormApi(state, formInstanceId, options = {}) {
     void state.submitted.value;
     return metaBase;
   };
-  const fieldStateAccessorOptions = options.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0;
-  const pathSweep = createDynamicPathSweep(state);
+  const pathSweep = state.pathSweep;
   const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
     getFormMetaBase,
-    pathSweep,
-    fieldStateAccessorOptions
+    pathSweep
   );
   const getDisplayStateAt = (segments) => getRootFieldStateAt(segments).value.displayState;
   const registerConfig = {
-    ...pickDefined({ instanceMeta, coerce: options.coerce, autoAria: options.autoAria }),
+    ...pickDefined({ instanceMeta, coerce: options.coerce }),
     getDisplayStateAt
   };
   const register = buildRegister(state, formInstanceId, registerConfig);
-  const processOptions = pickDefined({ onInvalidSubmit: options.onInvalidSubmit });
-  const defaultInvalidSubmitPolicy = options.onInvalidSubmit ?? "focus-first-error";
+  const focusFirstError = (options2) => {
+    const target = state.domBinding.value?.getFirstErrorElement(formInstanceId) ?? null;
+    if (target === null) return false;
+    target.element.focus({ focusVisible: true, ...options2 });
+    return true;
+  };
+  const scrollToFirstError = (options2) => {
+    const target = state.domBinding.value?.getFirstErrorElement(formInstanceId) ?? null;
+    if (target === null) return false;
+    target.element.scrollIntoView(options2);
+    return true;
+  };
+  const applyInvalidSubmitPolicyPublic = () => {
+    if (options.focusOnInvalidSubmit !== false) focusFirstError();
+  };
   const {
     validate: validateBuilt,
     parse: parseBuilt,
     handleSubmit
-  } = buildProcessForm(state, formInstanceId, processOptions);
+  } = buildProcessForm(state, {
+    applyInvalidSubmit: applyInvalidSubmitPolicyPublic
+  });
   const validate = (pathInput) => validateBuilt(pathInput);
   const parse = (arg1, arg2) => {
     const isPathArg = typeof arg1 === "string" || Array.isArray(arg1);
@@ -2846,28 +2778,26 @@ function buildFormApi(state, formInstanceId, options = {}) {
     () => state.firstValidationDone.value && state.errorCells.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
   );
   const history = options.history;
-  const formHistory = readonly(
+  const formHistory = history === void 0 ? inertHistory() : readonly(
     reactive({
-      undo: history?.undo ?? (() => false),
-      redo: history?.redo ?? (() => false),
-      clear: history?.clear ?? (() => {
-      }),
-      canUndo: history?.canUndo ?? computed(() => false),
-      canRedo: history?.canRedo ?? computed(() => false),
-      size: history?.historySize ?? computed(() => 0)
+      undo: history.undo,
+      redo: history.redo,
+      clear: history.clear,
+      canUndo: history.canUndo,
+      canRedo: history.canRedo,
+      size: history.historySize
     })
   );
   const metaErrors = computed(
-    () => aggregateErrorsAt(state, [])
+    () => aggregateErrorsAt(state, [], ROOT_PATH_KEY)
   );
   const rootFieldState = getRootFieldStateAt([]);
-  const metaTarget = {
-    // Whole-form work signals compose the LIFECYCLE counters with the
-    // per-leaf rollup: a submit-time validate shows up as
-    // activeValidations, per-field debounced validators as
-    // fieldValidationCounts — either flips the flag. `valid` keeps the
-    // form-level `firstValidationDone` mount gate; `errors` is the
-    // unfiltered whole-form aggregate.
+  const metaOwn = {
+    // Whole-form work signals compose the LIFECYCLE counters with the per-leaf
+    // rollup: a submit-time validate shows up in `activeValidations` and a
+    // per-field debounced validator in `fieldValidationCounts`, and either
+    // flips the flag. `valid` keeps the form-level mount gate, and `errors` is
+    // the unfiltered whole-form aggregate.
     validating: computed(
       () => state.activeValidations.value > 0 || rootFieldState.value.validating
     ),
@@ -2879,7 +2809,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     busy: computed(
       () => state.activeValidations.value > 0 || state.activeTransforms.value > 0 || rootFieldState.value.validating || rootFieldState.value.transforming
     ),
-    // Lifecycle (form-level only — not on FieldState).
+    // Lifecycle, form-level only and never on FieldState.
     submitting,
     submissionAttempts,
     departAttempts,
@@ -2890,14 +2820,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
     // identifier).
     instanceId: formInstanceId
   };
-  for (const k of META_MIRROR_KEYS) {
-    defineGetter(
-      metaTarget,
-      k,
-      () => rootFieldState.value[k]
-    );
-  }
-  defineGetter(metaTarget, "errorCount", () => metaErrors.value.length);
+  const metaTarget = buildMetaProxy(META_KEYS, (key) => {
+    if (key === "errorCount") return metaErrors.value.length;
+    if (Object.hasOwn(metaOwn, key)) return metaOwn[key];
+    return rootFieldState.value[key];
+  });
   const formMeta = readonly(reactive(metaTarget));
   const reset = (nextDefaultValues) => {
     if (nextDefaultValues === void 0) {
@@ -2937,21 +2864,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     } catch {
     }
   }
-  const focusFirstError = (options2) => {
-    const target = state.domBinding.value?.getFirstErrorElement(formInstanceId) ?? null;
-    if (target === null) return false;
-    target.element.focus({ focusVisible: true, ...options2 });
-    return true;
-  };
-  const scrollToFirstError = (options2) => {
-    const target = state.domBinding.value?.getFirstErrorElement(formInstanceId) ?? null;
-    if (target === null) return false;
-    target.element.scrollIntoView(options2);
-    return true;
-  };
-  const applyInvalidSubmitPolicyPublic = (policy) => {
-    applyInvalidSubmitPolicy(state, formInstanceId, policy ?? defaultInvalidSubmitPolicy);
-  };
   const fieldArrays = buildFieldArrayApi(state);
   const blankPathsView = computed(() => {
     const keys = /* @__PURE__ */ new Set();
@@ -3014,10 +2926,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const api = {
     handleSubmit: gated(handleSubmit),
-    // Callable readonly Proxies (`values`, `fields`, `errors`) and the
-    // reactive containers (`meta`, `history`, `blankPaths`) are exposed
-    // through getters so reading them activates the form on first
-    // touch. Each underlying object is identity-stable across reads.
+    // The callable readonly Proxies (`values`, `fields`, `errors`) and the
+    // reactive containers (`meta`, `history`, `blankPaths`) are exposed through
+    // getters, so reading one activates the form on first touch. Each
+    // underlying object is identity-stable across reads.
     get values() {
       void state.activate();
       return valuesProxy;
@@ -3034,7 +2946,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     key: state.formKey,
     // Auto-unwrapping views over the per-store async-defaults lifecycle
     // refs (see FormStore.hydrating / hydrateError). Reading either
-    // activates the form — observing factory state implies use.
+    // activates the form: observing factory state implies use.
     get hydrating() {
       void state.activate();
       return state.hydrating.value;
@@ -3043,20 +2955,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
       void state.activate();
       return state.hydrateError.value;
     },
-    // Orthogonal to `hydrating` and `hydrateError`: `ready` flips true
-    // once defaults are applied (sync at construction or async factory
-    // resolved successfully). One-way latch — stays true through later
-    // refetches even when those refetches fail, so stale-while-
-    // revalidate UIs keep rendering the prior values while
-    // `hydrateError` surfaces the refresh failure.
+    // Orthogonal to `hydrating` and `hydrateError`. `ready` flips true once
+    // defaults are applied, whether sync at construction or from a factory
+    // that resolved, and it is a one-way latch: it stays true through later
+    // refetches even when those fail, so a stale-while-revalidate UI keeps
+    // rendering the prior values while `hydrateError` surfaces the failure.
     get ready() {
       void state.activate();
       return state.defaultsResolved.value;
     },
-    // `rehydrate` and `activate` are themselves activation entry points
-    // — they fire the factory by design. Wrapping them with `gated`
-    // would double-fire (`state.activate()` plus the underlying call),
-    // so they call `state` directly.
+    // `rehydrate` and `activate` are activation entry points themselves and
+    // fire the factory by design, so wrapping them in `gated` would
+    // double-fire. They call `state` directly.
     rehydrate: () => state.rehydrate(),
     activate: () => state.activate(),
     get errors() {
@@ -3099,6 +3009,45 @@ function buildFormApi(state, formInstanceId, options = {}) {
   return api;
 }
 
+const SWEEP_SLICE = 8;
+function createDynamicPathSweep(deps) {
+  const dynamicKeys = /* @__PURE__ */ new Set();
+  const evictors = [];
+  const isDynamicPath = (segments) => {
+    for (let i = 0; i < segments.length; i++) {
+      if (typeof segments[i] === "number") return true;
+      if (!deps.isFixedObjectAtPath(segments.slice(0, i))) return true;
+    }
+    return false;
+  };
+  let sweepCursor = null;
+  deps.onFormChange((next) => {
+    if (dynamicKeys.size === 0) return;
+    const raw = toRaw(next);
+    for (let i = 0; i < SWEEP_SLICE; i++) {
+      sweepCursor ?? (sweepCursor = dynamicKeys.values());
+      const step = sweepCursor.next();
+      if (step.done === true) {
+        sweepCursor = null;
+        break;
+      }
+      const segments = segmentsForPathKey(step.value);
+      if (segments !== null && hasAtPath(raw, segments)) continue;
+      dynamicKeys.delete(step.value);
+      for (const evict of evictors) evict(step.value);
+    }
+  });
+  return {
+    track(segments, key) {
+      if (dynamicKeys.has(key)) return;
+      if (isDynamicPath(segments)) dynamicKeys.add(key);
+    },
+    onEvict(evict) {
+      evictors.push(evict);
+    }
+  };
+}
+
 const IDLE = Object.freeze({ display: "idle" });
 const MAX_DELAY = 2147483647;
 const PENDING_LIVENESS_MS = 250;
@@ -3187,6 +3136,58 @@ function createDisplayEngine(ssr) {
   return engine;
 }
 
+function buildErrorPathIndex(cells, blank) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key, cell] of cells) {
+    if (cell.schema.length > 0 || cell.user.length > 0) keys.add(key);
+  }
+  for (const [key, list] of blank) {
+    if (list.length > 0) keys.add(key);
+  }
+  if (keys.size === 0) return EMPTY_INDEX;
+  const entries = [];
+  for (const key of keys) {
+    const segments = segmentsForPathKey(key);
+    if (segments !== null) entries.push({ key, segments });
+  }
+  entries.sort(compareByKey);
+  return entries;
+}
+const EMPTY_INDEX = Object.freeze([]);
+function compareByKey(a, b) {
+  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+function windowUnder(index, prefix) {
+  if (prefix.length === 0 || index.length === 0) return index;
+  const prefixKey = keyForSegments(prefix).key;
+  const marker = `${prefixKey.slice(0, -1)},`;
+  const start = lowerBound(index, marker);
+  if (start >= index.length) return EMPTY_INDEX;
+  let end = start;
+  for (; end < index.length; end += 1) {
+    const entry = index[end];
+    if (entry === void 0 || entry.key > prefixKey) break;
+  }
+  return start === 0 && end === index.length ? index : index.slice(start, end);
+}
+function isSameWindow(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i]?.key !== b[i]?.key) return false;
+  }
+  return true;
+}
+function lowerBound(index, target) {
+  let lo = 0;
+  let hi = index.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if ((index[mid]?.key ?? target) < target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+
 function mergeSparseHydration(schemaDefaults, sparse, schema) {
   return mergeDeep(schemaDefaults, sparse, [], schema);
 }
@@ -3397,16 +3398,15 @@ function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out)
     out.add(canonicalizePath(prefix).key);
   }
 }
-function computeBaselineResponse(schema, strict, source) {
+function computeBaselineResponse(schema, source) {
   const completed = source === void 0 ? void 0 : mergeStructural(schema, [], source);
   return schema.getDefaultValues({
     useDefaultSchemaValues: true,
-    constraints: completed,
-    strict
+    constraints: completed
   });
 }
-function initialFirstValidationGate(schema, strict) {
-  return !strict || schema.needsAsyncValidation?.() !== true;
+function initialFirstValidationGate(schema) {
+  return schema.needsAsyncValidation?.() !== true;
 }
 function seedOriginalsFromBaseline(st, baseline, ensureOrdinals) {
   st.originals.clear();
@@ -3418,7 +3418,7 @@ function seedOriginalsFromBaseline(st, baseline, ensureOrdinals) {
   });
 }
 function queueInitialAsyncValidation(st) {
-  if (!st.ssr && st.strict && st.schema.needsAsyncValidation?.() === true) {
+  if (!st.ssr && st.schema.needsAsyncValidation?.() === true) {
     queueMicrotask(() => scheduleFieldValidation(
       st,
       [],
@@ -3460,10 +3460,6 @@ function ensurePathOrdinal(st, key) {
   }
   return ordinal;
 }
-function pathHasAsyncValidation(st, path) {
-  const { key } = canonicalizePath(path);
-  return pathHasAsyncValidationByKey(st, key, path);
-}
 function pathHasAsyncValidationByKey(st, key, segments) {
   const cached = st.pathAsyncCache.get(key);
   if (cached !== void 0) return cached;
@@ -3585,19 +3581,16 @@ function touchFieldRecord(st, pathKey, path, patch) {
     path,
     updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
     connected: patch.connected ?? current?.connected ?? false,
-    // focused/blurred use an explicit-undefined guard because
-    // patches legitimately carry `null` to mark a disconnect — the
-    // `??` operator would short-circuit on null and fall through to
-    // `current`, losing the intent. `!== undefined` honours an
-    // explicit null and preserves current only on absence.
+    // `focused` / `blurred` need an explicit-undefined guard: a patch
+    // legitimately carries `null` to mark a disconnect, and `??` would
+    // short-circuit on it and fall through to `current`, losing the intent.
     focused: patch.focused !== void 0 ? patch.focused : current?.focused ?? null,
     blurred: patch.blurred !== void 0 ? patch.blurred : current?.blurred ?? null,
-    // touched is plain `boolean`; `??` is equivalent to the explicit
-    // guard here because `false` is not nullish.
+    // `touched` is a plain boolean, so `??` is equivalent to the guard above.
     touched: patch.touched ?? current?.touched ?? false,
-    // interacted is sticky-true; a merge patch only ever sets it, so
-    // `??` preserves the current bit. It flips back to false solely
-    // through the reset paths, which reconstruct the record outright.
+    // `interacted` is sticky-true and a merge patch only ever sets it, so `??`
+    // preserves the current bit. Only the reset paths clear it, and they
+    // reconstruct the record outright.
     interacted: patch.interacted ?? current?.interacted ?? false,
     blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
   });
@@ -3606,10 +3599,15 @@ function commitWritePatches(st, patches, meta) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const patch of patches) {
     const { key } = canonicalizePath(patch.path);
-    if (patch.kind === "added" && !st.originals.has(key)) {
+    if (!st.originals.has(key)) {
       st.originals.set(key, { segments: patch.path, value: void 0 });
     }
     touchFieldRecord(st, key, patch.path, { updatedAt: now });
+    st.pathSweep.track(patch.path, key);
+    for (let i = 1; i < patch.path.length; i++) {
+      const ancestor = patch.path.slice(0, i);
+      st.pathSweep.track(ancestor, canonicalizePath(ancestor).key);
+    }
   }
   for (const listener of st.formChangeListeners) {
     try {
@@ -3814,10 +3812,7 @@ function setValueAtPath(st, path, value, meta) {
     if (newlyAuthored && st.schema.isPreprocessOrCoerceLeaf(path)) {
       const modeForAuthoringTransition = meta?.instance?.validateOn ?? st.fieldValidationMode;
       if (modeForAuthoringTransition === "change") {
-        scheduleFieldValidation(st, path, false, {
-          ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
-          ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
-        });
+        scheduleFieldValidation(st, path, false, meta?.instance);
       }
     }
     return true;
@@ -3833,15 +3828,12 @@ function setValueAtPath(st, path, value, meta) {
     st.arrayIdentity.realign(path);
   } else if (isContainer(currentValue) && !isContainer(value)) {
     if (subtreeHadRealBaseline(st, path, currentValue)) {
-      st.removedSubtrees.add(canonicalizePath(path).key);
+      st.removedSubtrees.add(pathKey);
     }
   }
   const effectiveModeAfterWrite = meta?.instance?.validateOn ?? st.fieldValidationMode;
   if (effectiveModeAfterWrite === "change") {
-    scheduleFieldValidation(st, path, false, {
-      ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
-      ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
-    });
+    scheduleFieldValidation(st, path, false, meta?.instance);
   }
   return true;
 }
@@ -3902,12 +3894,11 @@ function reshapeUnionVariant(st, parentPath, oldDiscValue, newDiscValue, variant
         path: [...parentPath, ...err.path]
       }));
       applySchemaErrorsForSubtree(st, parentPath, reStamped);
-      const { key: parentKey2 } = canonicalizePath(parentPath);
-      const prevValidation = st.fieldValidationState.get(parentKey2);
+      const prevValidation = st.fieldValidationState.get(parentKey);
       if (prevValidation !== void 0) {
         if (prevValidation.timer !== null) clearTimeout(prevValidation.timer);
         prevValidation.aborted = true;
-        st.fieldValidationState.delete(parentKey2);
+        st.fieldValidationState.delete(parentKey);
       }
       appliedSync = true;
     }
@@ -3915,17 +3906,14 @@ function reshapeUnionVariant(st, parentPath, oldDiscValue, newDiscValue, variant
   applyFormReplacement(st, nextForm, meta);
   for (const k of newBlankPaths) st.blankPaths.add(k);
   if (reshapeMode === "change" && !appliedSync) {
-    scheduleFieldValidation(st, parentPath, false, {
-      ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
-      ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
-    });
+    scheduleFieldValidation(st, parentPath, false, meta?.instance);
   }
   return true;
 }
-function scheduleFieldValidation(st, path, immediate, override) {
-  const effectiveMode = override?.mode ?? st.fieldValidationMode;
+function scheduleFieldValidation(st, path, immediate, instance) {
+  const effectiveMode = instance?.validateOn ?? st.fieldValidationMode;
   if (effectiveMode === "submit") return;
-  const effectiveDebounce = override?.debounceMs ?? st.fieldValidationDebounceMs;
+  const effectiveDebounce = instance?.debounceMs ?? st.fieldValidationDebounceMs;
   const { key } = canonicalizePath(path);
   const prev = st.fieldValidationState.get(key);
   if (prev !== void 0) {
@@ -4165,13 +4153,13 @@ function markFocused(st, path, focused, meta) {
   touchFieldRecord(st, key, path, {
     focused,
     blurred: !focused,
-    // `touched` flips to true on blur and stays true thereafter; while
-    // a field is currently focused we keep whatever value it held.
+    // `touched` flips true on blur and stays; a focused field keeps whatever
+    // it held.
     touched: focused ? current?.touched ?? false : true,
-    // `blurredAfterInteraction` flips true on the first blur that lands
-    // after a value edit and stays true. A tab-through blur before any
-    // edit leaves it false (`interacted` is still false at that blur),
-    // which is what keeps a clean tab-through from arming the gate.
+    // `blurredAfterInteraction` flips true on the first blur after a value
+    // edit and stays. A tab-through blur before any edit leaves it false,
+    // since `interacted` is still false, which is what keeps a clean
+    // tab-through from arming the gate.
     blurredAfterInteraction: !focused && current?.interacted === true ? true : current?.blurredAfterInteraction ?? false
   });
   const focusMode = meta?.instance?.validateOn ?? st.fieldValidationMode;
@@ -4199,10 +4187,7 @@ function markFocused(st, path, focused, meta) {
       });
     }
     if (changed) {
-      scheduleFieldValidation(st, path, true, {
-        ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
-        ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
-      });
+      scheduleFieldValidation(st, path, true, meta?.instance);
     }
   }
 }
@@ -4214,10 +4199,9 @@ function markInteracted(st, path) {
 }
 function touchAtPath(st, segments) {
   const formValue = st.form.value;
-  for (const [, entry] of st.originals) {
+  for (const [leafKey, entry] of st.originals) {
     if (!isPathPrefix(segments, entry.segments)) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
-    const leafKey = canonicalizePath(entry.segments).key;
     const current = st.fields.get(leafKey);
     if (current?.touched === true) continue;
     touchFieldRecord(st, leafKey, entry.segments, { touched: true });
@@ -4227,11 +4211,10 @@ function interactAtPath(st, segments) {
   if (st.effectiveDisabled.value) return false;
   const formValue = st.form.value;
   let interactedAny = false;
-  for (const [, entry] of st.originals) {
+  for (const [leafKey, entry] of st.originals) {
     if (!isPathPrefix(segments, entry.segments)) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
     interactedAny = true;
-    const leafKey = canonicalizePath(entry.segments).key;
     const current = st.fields.get(leafKey);
     if (current?.touched === true && current.interacted === true && current.blurredAfterInteraction === true) {
       continue;
@@ -4283,11 +4266,7 @@ function adoptResolvedDefaults(st, value) {
       st.schema
     )
   );
-  seedOriginalsFromBaseline(
-    st,
-    computeBaselineResponse(st.schema, st.strict, st.defaultValues).data,
-    false
-  );
+  seedOriginalsFromBaseline(st, computeBaselineResponse(st.schema, st.defaultValues).data, false);
 }
 function reset(st, nextDefaultValues) {
   const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
@@ -4296,7 +4275,7 @@ function reset(st, nextDefaultValues) {
     st.schema
   );
   st.defaultValues = structuralSnapshot(resetSource);
-  const resetResponse = computeBaselineResponse(st.schema, st.strict, resetSource);
+  const resetResponse = computeBaselineResponse(st.schema, resetSource);
   const next = resetResponse.data;
   rebuildAuthoredPaths(st, resetSource, next);
   applyFormReplacement(st, next);
@@ -4313,16 +4292,14 @@ function reset(st, nextDefaultValues) {
     st.blankPaths.add(key);
   }
   st.errorCells.clear();
-  if (st.strict && !resetResponse.success) {
+  if (!resetResponse.success) {
     replaceErrorChannel(st, "schema", resetResponse.errors);
   }
-  if (st.strict) {
-    const syncResult = st.schema.validateAtPath(st.form.value, void 0, { sync: true });
-    if (!(syncResult instanceof Promise) && !syncResult.success) {
-      applySchemaErrorsForSubtree(st, [], syncResult.errors);
-    }
+  const syncResult = st.schema.validateAtPath(st.form.value, void 0, { sync: true });
+  if (!(syncResult instanceof Promise) && !syncResult.success) {
+    applySchemaErrorsForSubtree(st, [], syncResult.errors);
   }
-  st.firstValidationDone.value = initialFirstValidationGate(st.schema, st.strict);
+  st.firstValidationDone.value = initialFirstValidationGate(st.schema);
   queueInitialAsyncValidation(st);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const [pathKey, record] of st.fields) {
@@ -4412,10 +4389,6 @@ function clearFieldRecordFlags(st, pathKey) {
   if (record === void 0) return;
   st.fields.set(pathKey, withClearedHistoryFlags(record, (/* @__PURE__ */ new Date()).toISOString()));
 }
-function isPristineAtPath(st, path) {
-  const { key, segments } = canonicalizePath(path);
-  return isPristineAtPathByKey(st, key, segments);
-}
 function isPristineAtPathByKey(st, key, segments) {
   if (st.blankPaths.has(key) !== st.originalBlankPaths.has(key)) return false;
   const entry = st.originals.get(key);
@@ -4449,12 +4422,8 @@ function getFieldRecord(st, path) {
   const { key } = canonicalizePath(path);
   return st.fields.get(key);
 }
-function getOriginalAtPath(st, path) {
-  const { key } = canonicalizePath(path);
-  return st.originals.get(key)?.value;
-}
 function createFormStore(options) {
-  const { formKey, schema, defaultValues, strict = true, hydration } = options;
+  const { formKey, schema, defaultValues, hydration } = options;
   const ssr = options.ssr === true;
   const ssrPrefetch = options.ssrPrefetch;
   const rememberVariants = options.rememberVariants !== false;
@@ -4462,22 +4431,16 @@ function createFormStore(options) {
   const fieldValidationDebounceMs = normalizeNumericOption({
     value: options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS,
     source: "useForm.debounceMs",
-    allowInfinity: false,
     min: 0,
     defaultValue: DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS
   });
-  const coerceIndex = resolveCoercionIndex(options.coerce);
-  const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
+  const coerceEnabled = resolveCoerceEnabled(options.coerce);
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const fieldValidatingSince = reactive(/* @__PURE__ */ new Map());
   const displayEngine = createDisplayEngine(ssr);
   cleanupHooks.push(() => displayEngine.dispose());
-  const schemaResponse = computeBaselineResponse(
-    schema,
-    strict,
-    defaultValues
-  );
+  const schemaResponse = computeBaselineResponse(schema, defaultValues);
   const schemaInitialData = schemaResponse.data;
   const authoredPaths = /* @__PURE__ */ new Set();
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
@@ -4490,16 +4453,15 @@ function createFormStore(options) {
     const v = getAtPath(toRaw(form.value), arraySegs);
     return Array.isArray(v) ? v.length : 0;
   });
-  const fields = reactive(/* @__PURE__ */ new Map());
+  const fields = shallowReactive(/* @__PURE__ */ new Map());
   const domBinding = shallowRef(null);
-  const errorCells = reactive(/* @__PURE__ */ new Map());
-  const originals = reactive(/* @__PURE__ */ new Map());
+  const errorCells = shallowReactive(/* @__PURE__ */ new Map());
+  const originals = shallowReactive(/* @__PURE__ */ new Map());
   const removedSubtrees = /* @__PURE__ */ new Set();
-  const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
   const blankPaths = reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
-  for (const raw of initialTransientList) {
-    const key = coerceToPathKey(raw);
+  const seededBlankPaths = hydration !== void 0 ? (hydration.blankPaths ?? []).map((dotted) => canonicalizePath(dotted).key) : options.initialBlankPaths ?? [];
+  for (const key of seededBlankPaths) {
     blankPaths.add(key);
     originalBlankPaths.add(key);
   }
@@ -4516,6 +4478,9 @@ function createFormStore(options) {
     }
     return result;
   });
+  const errorPathIndex = computed(
+    () => buildErrorPathIndex(errorCells, derivedBlankErrors.value)
+  );
   const submitting = ref(false);
   const activeSubmissions = ref(0);
   const submissionAttempts = ref(0);
@@ -4540,7 +4505,7 @@ function createFormStore(options) {
   const defaultsResolved = ref(false);
   const activated = ref(false);
   const activationPromise = ref(void 0);
-  const firstValidationDone = ref(initialFirstValidationGate(schema, strict));
+  const firstValidationDone = ref(initialFirstValidationGate(schema));
   watch(activeValidations, (now, prev) => {
     if (prev > 0 && now === 0) {
       firstValidationDone.value = true;
@@ -4558,6 +4523,33 @@ function createFormStore(options) {
   const activeTransforms = ref(0);
   const transformRuns = /* @__PURE__ */ new Map();
   const transformWaiters = [];
+  const errorWindows = /* @__PURE__ */ new Map();
+  const pathSweep = createDynamicPathSweep({
+    onFormChange: (listener) => {
+      formChangeListeners.add(listener);
+    },
+    isFixedObjectAtPath: (path) => schema.isFixedObjectAtPath(path)
+  });
+  pathSweep.onEvict((key) => {
+    fields.delete(key);
+    fieldValidationState.delete(key);
+    authoredPaths.delete(key);
+    if (originals.get(key)?.value === void 0) originals.delete(key);
+    errorWindows.delete(key);
+  });
+  const errorWindowAt = (prefix, prefixKey) => {
+    let cached = errorWindows.get(prefixKey);
+    if (cached === void 0) {
+      const frozen = [...prefix];
+      cached = computed((prev) => {
+        const next = windowUnder(errorPathIndex.value, frozen);
+        return prev !== void 0 && isSameWindow(prev, next) ? prev : next;
+      });
+      errorWindows.set(prefixKey, cached);
+      pathSweep.track(frozen, prefixKey);
+    }
+    return cached.value;
+  };
   const arrayBookkeeping = createArrayBookkeeping({
     form,
     fields,
@@ -4575,6 +4567,7 @@ function createFormStore(options) {
     touchFieldRecord: (pathKey, path, patch) => touchFieldRecord(st, pathKey, path, patch),
     decFieldValidation: (key) => decFieldValidation(st, key)
   });
+  const bind = (fn) => (...args) => fn(st, ...args);
   const st = {
     // --- public data (the FormStore contract's state members) ---
     formKey,
@@ -4582,10 +4575,11 @@ function createFormStore(options) {
     fields,
     errorCells,
     derivedBlankErrors,
+    errorWindowAt,
     originals,
+    pathSweep,
     schema,
     ssr,
-    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4613,20 +4607,16 @@ function createFormStore(options) {
     displayEngine,
     domBinding,
     modules,
-    coerceIndex,
+    coerceEnabled,
     blankPaths,
     originalBlankPaths,
     // --- kernel-internal state ---
-    strict,
-    // Defensive copy, not a fix for an observed alias: today
-    // `getDefaultValues` happens to build a fresh tree, so form storage
-    // does not currently share structure with the consumer's object.
-    // That is an adapter implementation detail rather than a contract,
-    // and this field is now durable state that every `reset()` reads, so
-    // it should not depend on it. The copy also means a consumer who
-    // keeps a reference to the literal they passed cannot mutate the
-    // form's defaults from outside. `reset()` snapshots for a harder
-    // reason (see there) where an alias IS reachable.
+    // A defensive copy. `getDefaultValues` building a fresh tree is an adapter
+    // implementation detail, not a contract, and this field is durable state
+    // that every `reset()` reads, so it must not depend on one. The copy also
+    // stops a consumer holding a reference to the literal they passed from
+    // mutating the form's defaults from outside. `reset()` snapshots for a
+    // harder reason, where an alias IS reachable.
     defaultValues: structuralSnapshot(defaultValues),
     ssrPrefetch,
     rememberVariants,
@@ -4654,17 +4644,20 @@ function createFormStore(options) {
     transformTokenSeq: 0,
     warnedDisabledWrite: false,
     // --- methods: thin per-instance skins over the module kernel ---
-    rehydrate: () => rehydrate(st),
-    activate: () => activate(st),
-    adoptResolvedDefaults: (value) => adoptResolvedDefaults(st, value),
-    pathHasAsyncValidation: (path) => pathHasAsyncValidation(st, path),
-    pathHasAsyncValidationByKey: (key, segments) => pathHasAsyncValidationByKey(st, key, segments),
-    applyFormReplacement: (next, meta) => applyFormReplacement(st, next, meta),
-    setValueAtPath: (path, value, meta) => setValueAtPath(st, path, value, meta),
-    getValueAtPath: (path) => getValueAtPath(st, path),
-    arrayElementKey: (path) => arrayElementKey(st, path),
-    reset: (nextDefaultValues) => reset(st, nextDefaultValues),
-    resetField: (path) => resetField(st, path),
+    rehydrate: bind(rehydrate),
+    activate: bind(activate),
+    adoptResolvedDefaults: bind(adoptResolvedDefaults),
+    pathHasAsyncValidationByKey: bind(pathHasAsyncValidationByKey),
+    applyFormReplacement: bind(applyFormReplacement),
+    setValueAtPath: bind(setValueAtPath),
+    getValueAtPath: bind(getValueAtPath),
+    arrayElementKey: bind(arrayElementKey),
+    reset: bind(reset),
+    resetField: bind(resetField),
+    // The schema/user pair below reads as a fold waiting to happen. Folding
+    // them into a `setErrorsForPathIn(channel)` factory measures 10 B LARGER:
+    // gzip has already collected the rent on two adjacent copies, and the
+    // helper adds a name the original does not need.
     setSchemaErrorsForPath: (path, entries) => setErrorChannelForKey(
       st,
       canonicalizePath(path).key,
@@ -4673,7 +4666,7 @@ function createFormStore(options) {
     ),
     setAllSchemaErrors: (entries) => replaceErrorChannel(st, "schema", entries),
     clearSchemaErrors: (path) => clearErrorChannel(st, "schema", path),
-    applySchemaErrorsForSubtree: (path, entries) => applySchemaErrorsForSubtree(st, path, entries),
+    applySchemaErrorsForSubtree: bind(applySchemaErrorsForSubtree),
     setAllUserErrors: (entries) => replaceErrorChannel(st, "user", entries),
     setUserErrorsForPath: (path, entries) => setErrorChannelForKey(
       st,
@@ -4682,37 +4675,34 @@ function createFormStore(options) {
       entries.length === 0 ? NO_ERRORS : [...entries]
     ),
     clearUserErrors: (path) => clearErrorChannel(st, "user", path),
-    restoreErrorCells: (entries) => restoreErrorCells(st, entries),
-    getErrorsForPath: (path) => getErrorsForPath(st, path),
-    ensurePathOrdinal: (key) => ensurePathOrdinal(st, key),
-    noteDomConnected: (path) => noteDomConnected(st, path),
-    noteDomDisconnected: (path) => noteDomDisconnected(st, path),
-    markFocused: (path, focused, meta) => markFocused(st, path, focused, meta),
-    markInteracted: (path) => markInteracted(st, path),
-    touchAtPath: (segments) => touchAtPath(st, segments),
-    interactAtPath: (segments) => interactAtPath(st, segments),
-    markConnectedOptimistically: (path) => markConnectedOptimistically(st, path),
-    isPristineAtPath: (path) => isPristineAtPath(st, path),
-    isPristineAtPathByKey: (key, segments) => isPristineAtPathByKey(st, key, segments),
-    hasStructuralChangeUnder: (path) => hasStructuralChangeUnder(st, path),
-    hasRemovedSubtreeUnder: (path) => hasRemovedSubtreeUnder(st, path),
-    getFieldRecord: (path) => getFieldRecord(st, path),
-    getOriginalAtPath: (path) => getOriginalAtPath(st, path),
-    cancelFieldValidation: () => cancelFieldValidation(st),
-    beginTransform: (key, holder) => beginTransform(st, key, holder),
-    isCurrentTransform: (key, token) => isCurrentTransform(st, key, token),
-    endTransform: (key, token) => endTransform(st, key, token),
-    setTransformError: (key, err) => setTransformError(st, key, err),
-    cancelTransforms: () => cancelTransforms(st),
-    cancelTransformsUnder: (prefix) => cancelTransformsUnder(st, prefix),
-    settleTransforms: (path) => settleTransforms(st, path),
-    scheduleFieldValidation: (path, immediate, override) => scheduleFieldValidation(st, path, immediate, override),
-    onFormChange: (listener) => onFormChange(st, listener),
-    onSubmitSuccess: (listener) => onSubmitSuccess(st, listener),
-    onReset: (listener) => onReset(st, listener),
-    emitSubmitSuccess: () => emitSubmitSuccess(st),
-    registerCleanup: (fn) => registerCleanup(st, fn),
-    dispose: () => dispose(st)
+    restoreErrorCells: bind(restoreErrorCells),
+    getErrorsForPath: bind(getErrorsForPath),
+    ensurePathOrdinal: bind(ensurePathOrdinal),
+    noteDomConnected: bind(noteDomConnected),
+    noteDomDisconnected: bind(noteDomDisconnected),
+    markFocused: bind(markFocused),
+    markInteracted: bind(markInteracted),
+    touchAtPath: bind(touchAtPath),
+    interactAtPath: bind(interactAtPath),
+    markConnectedOptimistically: bind(markConnectedOptimistically),
+    isPristineAtPathByKey: bind(isPristineAtPathByKey),
+    hasStructuralChangeUnder: bind(hasStructuralChangeUnder),
+    hasRemovedSubtreeUnder: bind(hasRemovedSubtreeUnder),
+    getFieldRecord: bind(getFieldRecord),
+    cancelFieldValidation: bind(cancelFieldValidation),
+    beginTransform: bind(beginTransform),
+    isCurrentTransform: bind(isCurrentTransform),
+    endTransform: bind(endTransform),
+    setTransformError: bind(setTransformError),
+    cancelTransformsUnder: bind(cancelTransformsUnder),
+    settleTransforms: bind(settleTransforms),
+    scheduleFieldValidation: bind(scheduleFieldValidation),
+    onFormChange: bind(onFormChange),
+    onSubmitSuccess: bind(onSubmitSuccess),
+    onReset: bind(onReset),
+    emitSubmitSuccess: bind(emitSubmitSuccess),
+    registerCleanup: bind(registerCleanup),
+    dispose: bind(dispose)
   };
   rebuildAuthoredPaths(st, defaultValues, schemaInitialData);
   seedOriginalsFromBaseline(st, schemaInitialData, true);
@@ -4751,7 +4741,7 @@ function createFormStore(options) {
         blurredAfterInteraction: false
       });
     });
-    if (strict && !schemaResponse.success) {
+    if (!schemaResponse.success) {
       replaceErrorChannel(st, "schema", schemaResponse.errors);
     }
   }
@@ -4782,19 +4772,18 @@ function useAbstractForm(configuration, options) {
   const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
   const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
   const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
-  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
-  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
-  const maxRecursionDepth = normalizeNumericOption({
-    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
-    source: "useForm.maxRecursionDepth",
-    allowInfinity: true,
-    min: 0,
-    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
-  });
-  const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
+  const materialisedConfiguration = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
   const existing = registry.forms.get(key);
+  const resolvedSchema = existing === void 0 || false ? getComputedSchema(key, configuration.schema, {
+    maxRecursionDepth: DEFAULT_MAX_RECURSION_DEPTH
+  }) : existing.schema;
   const hadPendingHydration = registry.pendingHydration.has(key);
-  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  const state = existing ?? buildFreshState(
+    key,
+    resolvedSchema,
+    materialisedConfiguration,
+    registry
+  );
   if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
     state.defaultsResolved.value = true;
   }
@@ -4819,8 +4808,8 @@ function useAbstractForm(configuration, options) {
     const releaseConsumer = registry.trackConsumer(key);
     onScopeDispose(releaseConsumer);
   }
-  if (existing === void 0 && merged.history !== void 0) {
-    const historyModule = merged.history.attach(state);
+  if (existing === void 0 && materialisedConfiguration.history !== void 0) {
+    const historyModule = materialisedConfiguration.history.attach(state);
     state.modules.set(HISTORY_MODULE_KEY, historyModule);
     state.registerCleanup(() => historyModule.dispose());
   }
@@ -4833,36 +4822,16 @@ function useAbstractForm(configuration, options) {
     provide(kFormInstanceId, formInstanceId);
   }
   const apiOptions = pickDefined({
-    onInvalidSubmit: merged.onInvalidSubmit,
+    focusOnInvalidSubmit: materialisedConfiguration.focusOnInvalidSubmit,
     history: state.modules.get(HISTORY_MODULE_KEY),
-    validateOn: merged.validateOn,
-    debounceMs: merged.debounceMs,
-    getDisplayState: merged.getDisplayState,
-    coerce: merged.coerce,
-    rememberVariants: merged.rememberVariants,
-    autoAria: merged.autoAria
+    validateOn: materialisedConfiguration.validateOn,
+    debounceMs: materialisedConfiguration.debounceMs,
+    coerce: materialisedConfiguration.coerce,
+    rememberVariants: materialisedConfiguration.rememberVariants
   });
   const api = buildFormApi(state, formInstanceId, apiOptions);
   return api;
 }
-function mergeWithDefaults(defaults, configuration) {
-  return {
-    ...configuration,
-    ...pickDefined({
-      strict: configuration.strict ?? defaults.strict,
-      onInvalidSubmit: configuration.onInvalidSubmit ?? defaults.onInvalidSubmit,
-      history: configuration.history ?? defaults.history,
-      rememberVariants: configuration.rememberVariants ?? defaults.rememberVariants,
-      disabled: configuration.disabled ?? defaults.disabled,
-      coerce: configuration.coerce ?? defaults.coerce,
-      validateOn: configuration.validateOn ?? defaults.validateOn,
-      debounceMs: configuration.debounceMs ?? defaults.debounceMs,
-      getDisplayState: configuration.getDisplayState ?? defaults.getDisplayState,
-      maxRecursionDepth: configuration.maxRecursionDepth ?? defaults.maxRecursionDepth,
-      autoAria: configuration.autoAria ?? defaults.autoAria
-    })
-  };
-}
 const HISTORY_MODULE_KEY = "history";
 function buildFreshState(key, schema, configuration, registry) {
   const pending = registry.pendingHydration.get(key);
@@ -4882,21 +4851,17 @@ function buildFreshState(key, schema, configuration, registry) {
     hydration: pending,
     ssr: registry.ssr,
     ...pickDefined({
-      strict: configuration.strict,
       validateOn: configuration.validateOn,
       debounceMs: configuration.debounceMs,
       rememberVariants: configuration.rememberVariants,
       disabled: configuration.disabled,
       coerce: configuration.coerce,
-      getDisplayState: configuration.getDisplayState,
       initialBlankPaths
     }),
-    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
-    // records intent on every `state.activate()` so a wizard skip-list
-    // override or a future transform mark has a consistent set to diff
-    // against; `shouldFire` lets the activate path bail when the
-    // wizard explicitly skipped this key — even an explicit
-    // `form.activate()` defers to the wizard's render-efficiency
+    // Server only. `enqueue` records intent on every `state.activate()`
+    // so a wizard skip-list override has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail on a key the
+    // wizard skipped. Even an explicit `form.activate()` defers to that
     // skip-list on the server.
     ...registry.ssr ? {
       ssrPrefetch: {
@@ -5135,25 +5100,18 @@ function createWizardHistory(param) {
   };
 }
 
-const NOOP_FINGERPRINT = "attaform:wizard-noop";
 const EMPTY_SLIM_KINDS = /* @__PURE__ */ new Set();
-function buildNoopWizardSchema(formKey) {
-  const emptyValue = {};
-  const success = {
-    success: true,
-    data: emptyValue,
-    errors: void 0,
-    formKey
-  };
-  const defaultsResponse = {
-    success: true,
-    data: emptyValue,
-    errors: void 0,
-    formKey
-  };
-  return {
-    fingerprint: () => Promise.resolve(NOOP_FINGERPRINT),
-    getDefaultValues: () => defaultsResponse,
+const EMPTY_VALUE = {};
+const NOOP_SUCCESS = {
+  success: true,
+  data: EMPTY_VALUE,
+  errors: void 0
+};
+const NOOP_DEFAULTS = NOOP_SUCCESS;
+let NOOP_SCHEMA;
+function buildNoopWizardSchema() {
+  NOOP_SCHEMA ?? (NOOP_SCHEMA = {
+    getDefaultValues: () => NOOP_DEFAULTS,
     getDefaultAtPath: () => void 0,
     getEmptyValueAtPath: () => void 0,
     isPreprocessOrCoerceLeaf: () => false,
@@ -5164,13 +5122,14 @@ function buildNoopWizardSchema(formKey) {
     // addressable, root included.
     entryKeyKindAtPath: () => void 0,
     getSchemasAtPath: () => [],
-    validateAtPath: () => success,
+    validateAtPath: () => NOOP_SUCCESS,
     getSlimPrimitiveTypesAtPath: () => new Set(EMPTY_SLIM_KINDS),
     isLeafAtPath: () => false,
     isRequiredAtPath: () => false,
     getUnionDiscriminatorAtPath: () => void 0,
     hasDiscriminatedUnions: () => false
-  };
+  });
+  return NOOP_SCHEMA;
 }
 
 function buildCallableReadonlySnapshotProxy(opts) {
@@ -5285,7 +5244,7 @@ function useWizard(options) {
     if (typeof slot !== "string") continue;
     if (noopForms.has(slot)) continue;
     const noop = useAbstractForm({
-      schema: buildNoopWizardSchema(slot),
+      schema: buildNoopWizardSchema(),
       key: slot
     });
     noopForms.set(slot, noop);
@@ -5296,7 +5255,7 @@ function useWizard(options) {
     const noop = lazyNoopScope.run(
       () => useAbstractForm(
         {
-          schema: buildNoopWizardSchema(key),
+          schema: buildNoopWizardSchema(),
           key
         },
         { registry }
@@ -5364,27 +5323,33 @@ function useWizard(options) {
       return activeKey.value === "" ? void 0 : activeKey.value;
     }
   };
-  function lazyComputedFor(marker) {
+  function lazyComputedFor(marker, index) {
     const cached = lazyComputeds.get(marker);
     if (cached !== void 0) return cached;
     const c = computed(() => {
       void lazyEpoch.value;
-      return marker.resolve(slotCtx);
+      return callConsumerFn(
+        () => marker.resolve(slotCtx),
+        void 0);
     });
     lazyComputeds.set(marker, c);
     return c;
   }
   const MAX_SLOT_DEPTH = 32;
-  function normalizeSlot(slot, ctx, gated, depth) {
+  function normalizeSlot(slot, ctx, gated, depth, index) {
     if (depth > MAX_SLOT_DEPTH) {
       return void 0;
     }
     if (slot === void 0 || slot === null) return void 0;
     if (typeof slot === "string") return { form: getOrBuildNoop(slot), gated };
     if (isGateMarker(slot)) return normalizeSlot(slot.inner, ctx, true, depth + 1);
-    if (isLazyMarker(slot)) return normalizeSlot(lazyComputedFor(slot).value, ctx, gated, depth + 1);
+    if (isLazyMarker(slot)) {
+      return normalizeSlot(lazyComputedFor(slot).value, ctx, gated, depth + 1);
+    }
     if (typeof slot === "function") {
-      const result = slot(ctx);
+      const result = callConsumerFn(
+        () => slot(ctx),
+        void 0);
       return normalizeSlot(result, ctx, gated, depth + 1);
     }
     if (isAnyForm(slot)) return { form: slot, gated };
@@ -5702,13 +5667,14 @@ function useWizard(options) {
       seedRef.value = resolved.value;
       applyGateSeed(resolved.value);
     } else {
-      const eager = resolved.factory();
+      const eager = callConsumerFn(() => resolved.factory(), void 0);
       if (eager instanceof Promise) {
         void eager.then((value) => {
           seedRef.value = value;
           applyGateSeed(value);
+        }).catch((err) => {
         });
-      } else {
+      } else if (eager !== void 0) {
         seedRef.value = eager;
         applyGateSeed(eager);
       }
@@ -5781,10 +5747,13 @@ function useWizard(options) {
   const statuses = buildWizardStatusesProxy(statusesRecord);
   const progressOverride = options.progress;
   const progress = computed(() => {
+    const list = compiledSteps.value;
     if (progressOverride !== void 0) {
-      return progressOverride(compiledSteps.value);
+      const override = callConsumerFn(
+        () => progressOverride(list),
+        null);
+      if (override !== null) return override;
     }
-    const list = compiledSteps.value;
     if (list.length === 0) return 0;
     let valid = 0;
     for (const step of list) {
@@ -5812,11 +5781,15 @@ function useWizard(options) {
   historyHandle.subscribe((value) => {
     urlMirror.value = value;
   });
-  const restoreCallback = options.restore === false ? void 0 : options.restore !== void 0 ? options.restore : () => {
+  const consumerRestore = options.restore;
+  const restoreCallback = consumerRestore === false ? void 0 : consumerRestore !== void 0 ? () => callConsumerFn(() => consumerRestore(), void 0) : () => {
     const value = urlMirror.value;
     return value === void 0 ? void 0 : { step: value };
   };
-  const persistCallback = options.persist === false ? void 0 : options.persist !== void 0 ? options.persist : (state) => {
+  const consumerPersist = options.persist;
+  const persistCallback = consumerPersist === false ? void 0 : consumerPersist !== void 0 ? (state) => {
+    callConsumerFn(() => consumerPersist(state), void 0);
+  } : (state) => {
     if (state.step === void 0) return;
     const current = historyHandle.read();
     const effectiveCurrent = current !== void 0 && isCompiledKey(current) ? current : firstKey();
@@ -6380,4 +6353,4 @@ function escapeForInlineScript(json) {
   });
 }
 
-export { AttaformErrorCode as A, DEFAULT_TIMINGS as D, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, escapeForInlineScript as e, isUnset as f, gate as g, useAbstractForm as h, injectForm as i, useRegister as j, useWizard as k, lazy as l, makeDefaultDisplayState as m, isPlainRecord as n, crossCopyState as o, getAtPath as p, humanize as q, slimKindOf as s, unset as u };
+export { AttaformErrorCode as A, injectWizard as a, isUnset as b, useAbstractForm as c, useRegister as d, escapeForInlineScript as e, useWizard as f, gate as g, getAtPath as h, injectForm as i, humanize as j, isPlainRecord as k, lazy as l, slimKindOf as s, unset as u };