attaform 0.29.0 → 0.30.0

package/dist/dev/shared/{attaform-dev.DHuydLAC.mjs → attaform-dev.CQ2rJiAX.mjs}

@@ -1,8 +1,8 @@
-import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, reactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope } from 'vue';
-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-dev.ButTkwHd.mjs';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.DD5m2W51.mjs';
-import { R as REGISTER_OWNER_MARKER, d as armDomBinding, V as V_REGISTER_MARKER } from './attaform-dev.D8aoKb89.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-dev.A-TpJW0B.mjs';
+import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope } from 'vue';
+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, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform-dev.BcYT6tFh.mjs';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.DUZckyV8.mjs';
+import { R as REGISTER_OWNER_MARKER, d as armDomBinding, V as V_REGISTER_MARKER } from './attaform-dev.D6CLvaQT.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-dev.BQc5QV3Y.mjs';
 
 const AttaformErrorCode = {
   /** A required field is in the blank set — user hasn't supplied a value. */
@@ -77,11 +77,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;
 }
@@ -103,45 +98,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;
@@ -229,16 +211,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];
@@ -265,29 +258,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) {
@@ -493,10 +472,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)];
@@ -505,11 +484,14 @@ 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;
 }
 
-const warnedDisplayStatePredicates = /* @__PURE__ */ new WeakSet();
 function isUnderStubAncestor(state, segments) {
   for (let i = 0; i < segments.length; i++) {
     const ancestorPath = segments.slice(0, i);
@@ -523,16 +505,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 +530,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 +542,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);
@@ -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);
@@ -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,23 +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) {
-    if (!warnedDisplayStatePredicates.has(predicate)) {
-      warnedDisplayStatePredicates.add(predicate);
-      console.warn(
-        "[attaform] custom getDisplayState threw \u2014 falling back to defaultDisplayState. Subsequent throws from the same predicate will not warn again.",
-        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,
@@ -853,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([]);
@@ -967,7 +938,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;
@@ -982,7 +953,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;
@@ -1082,7 +1053,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];
@@ -1094,28 +1065,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({
@@ -1133,65 +1097,80 @@ function buildErrorsSurface(state, sweep) {
     // `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),
+    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) {
@@ -1264,7 +1243,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(
@@ -1832,45 +1811,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);
-    }
-  };
-}
-
 const warnedNoScopeStores = /* @__PURE__ */ new WeakSet() ;
 function isErrorInputLike(value) {
   if (value instanceof Error) return true;
@@ -1898,8 +1838,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,
@@ -1997,7 +1937,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);
@@ -2048,7 +1988,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
             }
           }
           if (generationStillValid) {
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
           if (onError !== void 0) {
             try {
@@ -2065,7 +2005,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         await onSubmit(merged.data);
         if (hasUserErrorEntries(state)) {
           if (state.submissionGeneration.value === genAtEntry) {
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
           return;
         }
@@ -2083,7 +2023,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
               if (segments === null) continue;
               state.setUserErrorsForPath([...segments], bucket);
             }
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
             if (messageless) {
               console.warn(
                 "[attaform] handleSubmit callback threw a non-Error value; throw an Error or a ValidationError ({ message, path? }) so the failure surfaces with a usable message."
@@ -2103,6 +2043,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;
 }
@@ -2136,24 +2080,9 @@ 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 });
-}
 
 const warnedRejections = /* @__PURE__ */ new WeakMap() ;
-function shouldWarnOnce$1(store, key) {
+function shouldWarnOnce(store, key) {
   if (warnedRejections === null) return false;
   let set = warnedRejections.get(store);
   if (set === void 0) {
@@ -2229,7 +2158,7 @@ function walk(schema, store, path, value) {
 function reportRejection(store, path, kind, accepted) {
   const dotted = path.map((s) => String(s)).join(".") || "(root)";
   const key = `${dotted}::${kind}`;
-  if (!shouldWarnOnce$1(store, key)) return;
+  if (!shouldWarnOnce(store, key)) return;
   if (accepted.size === 0) {
     console.warn(
       `[attaform] Cannot write to '${dotted}' \u2014 this path is not in your schema.
@@ -2262,56 +2191,9 @@ function formatExpectedKinds(accepted) {
   return `one of: ${list.join(", ")}`;
 }
 
-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") {
-      {
-        console.warn("[attaform] coercion entry missing or invalid `transform` \u2014 skipped.");
-      }
-      continue;
-    }
-    const key = `${entry.input}->${entry.output}`;
-    if (idx.has(key) && true) {
-      console.warn(`[attaform] duplicate coercion rule for '${key}' \u2014 last entry wins.`);
-    }
-    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]);
@@ -2320,119 +2202,84 @@ 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;
 }
-const warnedCoerce = /* @__PURE__ */ new WeakMap() ;
-const sharedWarnStore = {};
-function shouldWarnOnce(key) {
-  if (warnedCoerce === null) return false;
-  let set = warnedCoerce.get(sharedWarnStore);
-  if (set === void 0) {
-    set = /* @__PURE__ */ new Set();
-    warnedCoerce.set(sharedWarnStore, set);
-  }
-  if (set.has(key)) return false;
-  set.add(key);
-  return true;
+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, index) {
+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) {
-    if (shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
-      console.warn(
-        `[attaform] coercion '${entry.input}->${entry.output}' threw \u2014 write passes through.`,
-        err
-      );
-    }
-    return value;
-  }
-  if (!result.coerced) return value;
-  const returnedKind = slimKindOf(result.value);
-  if (returnedKind !== entry.output) {
-    if (shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
-      console.warn(
-        `[attaform] coercion '${entry.input}->${entry.output}' produced a ${returnedKind} \u2014 write passes through.`
-      );
-    }
-    return value;
-  }
-  if (entry.output === "number" && !Number.isFinite(result.value)) {
-    if (shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
-      console.warn(
-        `[attaform] coercion '${entry.input}->${entry.output}' produced a non-finite number \u2014 write passes through.`
-      );
-    }
-    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 warnedMultiRootHosts = /* @__PURE__ */ new Set();
 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;
@@ -2472,16 +2319,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 = {
@@ -2601,7 +2447,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       // --- Aria (internal; consumed by the directive) ---
       aria,
       isRequired,
-      ariaEnabled,
       ...ariaDisplayState !== void 0 ? { ariaDisplayState } : {}
     };
     return shallowReadonly(internalRv);
@@ -2765,11 +2610,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({
@@ -2796,32 +2680,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;
@@ -2830,28 +2708,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);
@@ -2979,22 +2870,21 @@ 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 = {
+  const metaOwn = {
     // 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
@@ -3023,14 +2913,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) {
@@ -3070,21 +2957,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();
@@ -3259,6 +3131,45 @@ function shortenSourceFrame(frame) {
   return `(${path}:${line})`;
 }
 
+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;
@@ -3352,6 +3263,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);
 }
@@ -3578,16 +3541,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();
@@ -3599,7 +3561,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,
       [],
@@ -3641,10 +3603,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;
@@ -3787,10 +3745,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 {
@@ -4001,10 +3964,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;
@@ -4020,15 +3980,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;
 }
@@ -4089,12 +4046,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;
     }
@@ -4102,17 +4058,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) {
@@ -4386,10 +4339,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);
     }
   }
 }
@@ -4402,11 +4352,10 @@ function markInteracted(st, path) {
 function touchAtPath(st, segments) {
   const formValue = st.form.value;
   let touchedAny = 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;
     touchedAny = true;
-    const leafKey = canonicalizePath(entry.segments).key;
     const current = st.fields.get(leafKey);
     if (current?.touched === true) continue;
     touchFieldRecord(st, leafKey, entry.segments, { touched: true });
@@ -4421,11 +4370,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;
@@ -4482,11 +4430,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(
@@ -4495,7 +4439,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);
@@ -4512,16 +4456,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) {
@@ -4611,10 +4553,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);
@@ -4648,12 +4586,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;
@@ -4661,22 +4595,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);
@@ -4689,16 +4617,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);
   }
@@ -4715,6 +4642,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);
@@ -4747,7 +4677,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;
@@ -4765,6 +4695,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,
@@ -4782,6 +4739,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,
@@ -4789,10 +4747,11 @@ function createFormStore(options) {
     fields,
     errorCells,
     derivedBlankErrors,
+    errorWindowAt,
     originals,
+    pathSweep,
     schema,
     ssr,
-    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4820,11 +4779,10 @@ 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.
@@ -4861,17 +4819,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. It was
+    // tried: a `setErrorsForPathIn(channel)` factory measured 10 B LARGER,
+    // because gzip had already collected the rent on two adjacent copies
+    // and the helper added a name the original did not need.
     setSchemaErrorsForPath: (path, entries) => setErrorChannelForKey(
       st,
       canonicalizePath(path).key,
@@ -4880,7 +4841,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,
@@ -4889,37 +4850,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);
@@ -4961,7 +4919,7 @@ function createFormStore(options) {
         blurredAfterInteraction: false
       });
     });
-    if (strict && !schemaResponse.success) {
+    if (!schemaResponse.success) {
       replaceErrorChannel(st, "schema", schemaResponse.errors);
     }
   }
@@ -4992,24 +4950,23 @@ 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 = getComputedSchema(key, configuration.schema, {
+    maxRecursionDepth: DEFAULT_MAX_RECURSION_DEPTH
+  }) ;
   if (existing !== void 0) {
     void import('../chunks/dev-key-collision-warnings.mjs').then((m) => {
       void m.warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
     });
   }
   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;
   }
@@ -5034,8 +4991,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());
   }
@@ -5048,36 +5005,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);
@@ -5097,13 +5034,11 @@ 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`
@@ -5417,25 +5352,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,
@@ -5446,13 +5374,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) {
@@ -5571,7 +5500,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);
@@ -5582,7 +5511,7 @@ function useWizard(options) {
     const noop = lazyNoopScope.run(
       () => useAbstractForm(
         {
-          schema: buildNoopWizardSchema(key),
+          schema: buildNoopWizardSchema(),
           key
         },
         { registry }
@@ -6806,4 +6735,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 };