attaform 0.28.0 → 0.30.0

package/dist/dev/shared/{attaform-dev.WmuhD_CZ.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, i as isShadowedKey, c as safeOwnHas, a as safeOwnRead, b as safeAssign, d as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, e as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, f as applyChangedKeys, R as RESERVED_KEY_PREFIX, g as DEFAULT_MAX_RECURSION_DEPTH, h as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform-dev.By4PRjt0.mjs';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.BXE2cr0L.mjs';
-import { R as REGISTER_OWNER_MARKER, d as armDomBinding, V as V_REGISTER_MARKER } from './attaform-dev.P7cseiEG.mjs';
-import { i as isPathPrefix, e as canonicalizePath, h as cellEntriesFor, s as segmentsForPathKey, k as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, R as ROOT_PATH, l as normalizeErrorInputs, m as coerceToPathKey, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform-dev.Dr2YzS5B.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. */
@@ -98,42 +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 = /* @__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;
@@ -186,6 +176,17 @@ function humanize(segment) {
 }
 
 const NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+function mapKeyForSegment(map, segment, declared) {
+  if (map.has(segment)) return segment;
+  if (typeof segment !== "number") return segment;
+  const asString = String(segment);
+  if (map.has(asString)) return asString;
+  return declared === "string" ? asString : segment;
+}
+function isRebuildableContainer(root, segment) {
+  if (root === null || root === void 0 || typeof root !== "object") return true;
+  return typeof segment === "number" ? Array.isArray(root) : isPlainRecord(root);
+}
 function descendStep(value, segment) {
   if (value === null || value === void 0) return NOT_FOUND;
   if (typeof value !== "object") return NOT_FOUND;
@@ -194,6 +195,11 @@ function descendStep(value, segment) {
     if (!(segment in value)) return NOT_FOUND;
     return value[segment];
   }
+  if (value instanceof Map) {
+    const key2 = mapKeyForSegment(value, segment);
+    if (!value.has(key2)) return NOT_FOUND;
+    return value.get(key2);
+  }
   const record = value;
   const key = typeof segment === "number" ? String(segment) : segment;
   if (isShadowedKey(key)) {
@@ -205,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];
@@ -226,11 +243,14 @@ function hasAtPath(root, path) {
   if (current === null || current === void 0) return false;
   if (typeof current !== "object") return false;
   if (Array.isArray(current)) {
-    return typeof last === "number" && last in current;
+    return typeof last === "number" && consumerHas(current, last);
+  }
+  if (current instanceof Map) {
+    return current.has(mapKeyForSegment(current, last));
   }
   const key = typeof last === "number" ? String(last) : last;
   if (isShadowedKey(key)) return safeOwnHas(current, key);
-  return key in current;
+  return consumerHas(current, key);
 }
 function isPlainRecord(value) {
   if (value === null || typeof value !== "object") return false;
@@ -238,29 +258,30 @@ 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 (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) {
   if (path.length === 0) return NO_IN_PLACE;
+  try {
+    return descendAndWrite(root, path, value);
+  } catch {
+    return NO_IN_PLACE;
+  }
+}
+function descendAndWrite(root, path, value) {
   let node = root;
   for (let i = 0; i < path.length; i++) {
     const seg = path[i];
+    if (node instanceof Map) return NO_IN_PLACE;
     if (Array.isArray(node)) {
       if (typeof seg !== "number" || seg < 0 || seg >= node.length) return NO_IN_PLACE;
     } else if (isPlainRecord(node)) {
@@ -295,17 +316,40 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
   if (Array.isArray(consumer)) {
     return mergeStructuralArray(schema, scratch, consumer);
   }
+  if (consumer instanceof Map) {
+    return mergeStructuralMap(schema, scratch, consumer);
+  }
   if (isPlainRecord(consumer)) {
     if (!isPlainRecord(defaultValue)) {
       return consumer;
     }
-    const out = { ...consumer };
+    const out = spreadConsumerRecord(consumer);
     const filledAny = fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out);
     const recursedAny = recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out);
     return filledAny || recursedAny ? out : consumer;
   }
   return consumer;
 }
+function mergeStructuralMap(schema, scratch, consumer) {
+  if (consumer.size === 0) return consumer;
+  let entryDefault;
+  let entryDefaultRead = false;
+  let out = null;
+  for (const [key, entry] of consumer) {
+    if (typeof key !== "string" && typeof key !== "number") continue;
+    scratch.push(key);
+    if (!entryDefaultRead) {
+      entryDefault = schema.getDefaultAtPath(scratch);
+      entryDefaultRead = true;
+    }
+    const merged = mergeStructuralImpl(schema, scratch, entry, entryDefault);
+    scratch.pop();
+    if (merged === entry) continue;
+    out ?? (out = new Map(consumer));
+    out.set(key, merged);
+  }
+  return out ?? consumer;
+}
 function mergeStructuralArray(schema, scratch, consumer) {
   const shape = schema.arrayShapeAtPath(scratch);
   const isTuple = typeof shape === "number";
@@ -313,7 +357,7 @@ function mergeStructuralArray(schema, scratch, consumer) {
   let cachedElementDefault;
   let cachedElementDefaultRead = false;
   let mutated = targetLen > consumer.length;
-  const out = consumer.slice();
+  const out = copyConsumerArray(consumer);
   while (out.length < targetLen) out.push(void 0);
   for (let i = 0; i < targetLen; i++) {
     scratch.push(i);
@@ -327,7 +371,7 @@ function mergeStructuralArray(schema, scratch, consumer) {
       }
       elemDefault = cachedElementDefault;
     }
-    const consumerElem = i < consumer.length ? consumer[i] : void 0;
+    const consumerElem = i < consumer.length ? readConsumerIndex(consumer, i) : void 0;
     const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
     scratch.pop();
     if (merged !== consumerElem) {
@@ -355,7 +399,7 @@ function fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out
 }
 function recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out) {
   let mutated = false;
-  for (const key of Object.keys(consumer)) {
+  for (const key of consumerKeys(consumer)) {
     const cVal = safeOwnRead(consumer, key);
     if (cVal === void 0) continue;
     scratch.push(key);
@@ -376,6 +420,21 @@ function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
   if (startIdx >= fullPath.length) return value;
   const head = fullPath[startIdx];
   const isLeafStep = startIdx === fullPath.length - 1;
+  if (root instanceof Map) {
+    const next = new Map(root);
+    const key = mapKeyForSegment(root, head, schema.entryKeyKindAtPath(fullPath.slice(0, startIdx)));
+    if (isLeafStep) {
+      next.set(key, value);
+      return next;
+    }
+    let childRoot2 = next.get(key);
+    if (childRoot2 === void 0 || childRoot2 !== null && typeof childRoot2 !== "object") {
+      childRoot2 = schema.getDefaultAtPath(fullPath.slice(0, startIdx + 1));
+    }
+    next.set(key, setAtPathWithSchemaFillImpl(childRoot2, schema, fullPath, value, startIdx + 1));
+    return next;
+  }
+  if (!isRebuildableContainer(root, head)) return root;
   if (typeof head === "number") {
     const arr = Array.isArray(root) ? [...root] : [];
     const prefix = fullPath.slice(0, startIdx);
@@ -413,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)];
@@ -425,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);
@@ -443,17 +505,18 @@ function isUnderStubAncestor(state, segments) {
   }
   return false;
 }
-function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, 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);
     return c;
   };
 }
@@ -467,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;
@@ -479,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);
@@ -522,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;
@@ -535,15 +598,14 @@ 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) {
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      const child = value[i];
+      const child = readConsumerIndex(value, i);
       if (Array.isArray(child) || isPlainRecord(child)) {
         visitActiveLeafPaths(child, [...base, i], visit);
       } else {
@@ -553,8 +615,8 @@ function visitActiveLeafPaths(value, base, visit) {
     return;
   }
   if (isPlainRecord(value)) {
-    for (const k of Object.keys(value)) {
-      const child = value[k];
+    for (const k of consumerKeys(value)) {
+      const child = readConsumerProp(value, k);
       if (Array.isArray(child) || isPlainRecord(child)) {
         visitActiveLeafPaths(child, [...base, k], visit);
       } else {
@@ -635,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;
@@ -643,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);
@@ -714,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,
@@ -724,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,
@@ -742,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,
@@ -771,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([]);
@@ -803,6 +856,10 @@ function liveKeysAtPath(state, segments) {
     for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
     return keys;
   }
+  if (value instanceof Map) {
+    return mapSegmentKeys(value)?.map(String) ?? [];
+  }
+  if (value instanceof Set) return [];
   if (typeof value === "object") return Object.keys(value);
   return [];
 }
@@ -813,6 +870,12 @@ function liveContainerHasKey(state, segments, key) {
     const index = Number(key);
     return Number.isInteger(index) && index >= 0 && index < value.length && String(index) === key;
   }
+  if (value instanceof Map) {
+    if (value.has(key)) return true;
+    const index = Number(key);
+    return Number.isInteger(index) && index >= 0 && String(index) === key && value.has(index);
+  }
+  if (value instanceof Set) return false;
   return Object.hasOwn(value, key);
 }
 function isArrayPath(state, segments) {
@@ -839,6 +902,7 @@ function makeReadonlyCoercion(snapshot) {
 }
 
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+const RELEASED = /* @__PURE__ */ Symbol();
 const EMPTY_DESCENT = Object.freeze({});
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
@@ -868,12 +932,18 @@ function callableInvokeShim(method, surface, getDescent) {
 function buildTree(spec) {
   const containerCache = /* @__PURE__ */ new Map();
   const existsCache = /* @__PURE__ */ new Map();
+  spec.sweep.onEvict((key) => {
+    containerCache.delete(`${key}+A`);
+    containerCache.delete(`${key}+O`);
+    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;
     existsCache.set(cacheKey, result);
+    spec.sweep.track(segs, cacheKey);
     return result;
   }
   function descend(segs) {
@@ -883,7 +953,8 @@ function buildTree(spec) {
   }
   function containerAt(segments) {
     const isArrayLike = spec.isArrayAt(segments);
-    const cacheKey = `${JSON.stringify(segments)}+${isArrayLike ? "A" : "O"}`;
+    const pathKey = keyForSegments(segments).key;
+    const cacheKey = `${pathKey}+${isArrayLike ? "A" : "O"}`;
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const isFixedObject = spec.schema.isFixedObjectAtPath(segments);
@@ -973,46 +1044,42 @@ function buildTree(spec) {
       }
     });
     containerCache.set(cacheKey, proxy);
+    spec.sweep.track(segments, pathKey);
     return proxy;
   }
   return containerAt([]);
 }
-function buildErrorsSurface(state) {
+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];
       tree = computed(() => materializeErrors(state, frozen));
       treeCache.set(cacheKey, tree);
+      sweep.track(segments, cacheKey);
     }
     return tree.value;
   };
   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({
@@ -1030,64 +1097,80 @@ function buildErrorsSurface(state) {
     // `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),
-    surface: "form.errors"
+    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) {
@@ -1150,7 +1233,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "placeholder",
   "meta"
 ]);
-function buildFieldsSurface(state, getFieldStateAt) {
+function buildFieldsSurface(state, getFieldStateAt, sweep) {
   const snapshotAt = (segments) => {
     const view = getFieldStateAt(segments).value;
     const snapshot = {};
@@ -1158,8 +1241,9 @@ function buildFieldsSurface(state, getFieldStateAt) {
     return snapshot;
   };
   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(
@@ -1212,6 +1296,7 @@ function buildFieldsSurface(state, getFieldStateAt) {
       }
     });
     viewCache.set(cacheKey, proxy);
+    sweep.track(segments, cacheKey);
     return proxy;
   }
   return buildTree({
@@ -1226,7 +1311,8 @@ function buildFieldsSurface(state, getFieldStateAt) {
     // container's rollup); a path the schema doesn't have is a typo and
     // reads `undefined`. The root (`fields()`) is always declared.
     call: (path) => state.schema.getSlimPrimitiveTypesAtPath(path).size > 0 ? viewAt(path) : void 0,
-    surface: "form.fields"
+    surface: "form.fields",
+    sweep
   });
 }
 function materializeFields(state, containerSegments, snapshotAt) {
@@ -1260,18 +1346,34 @@ function materializeFormValue(node) {
   }
   return out;
 }
-function buildValuesSurface(form) {
+function buildValuesSurface(form, onFormChange) {
   const inner = computed(() => readonly(form.value));
-  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(
-    () => materializeFormValue(inner.value)
-  );
+  let held = null;
+  const snapshot = computed(() => {
+    const box = { value: materializeFormValue(inner.value) };
+    held = box;
+    return box;
+  });
+  onFormChange(() => {
+    if (held === null) return;
+    held.value = RELEASED;
+    held = null;
+  });
+  const readSnapshot = () => {
+    const box = snapshot.value;
+    return box.value === RELEASED ? materializeFormValue(inner.value) : box.value;
+  };
+  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(() => readSnapshot());
   const target = (() => {
   });
   return new Proxy(target, {
     apply(_, __, args) {
       const arg = args[0];
-      if (arg === void 0) return inner.value;
-      return getAtPath(inner.value, canonicalizePath(arg).segments);
+      if (arg === void 0) return readSnapshot();
+      const segments = canonicalizePath(arg).segments;
+      const node = getAtPath(inner.value, segments);
+      if (node === null || typeof node !== "object") return node;
+      return getAtPath(readSnapshot(), segments);
     },
     get(_, key) {
       if (typeof key === "symbol") {
@@ -1556,9 +1658,12 @@ function cloneVariantSnapshot(value) {
     for (let i = 0; i < raw.length; i++) out2[i] = cloneVariantSnapshot(raw[i]);
     return out2;
   }
+  if (!isPlainRecord(raw)) return raw;
   const src = raw;
   const out = {};
-  for (const k of Object.keys(src)) safeAssign(out, k, cloneVariantSnapshot(src[k]));
+  for (const k of consumerKeys(src)) {
+    safeAssign(out, k, cloneVariantSnapshot(readConsumerProp(src, k)));
+  }
   return out;
 }
 function createArrayBookkeeping(deps) {
@@ -1733,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,
@@ -1832,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);
@@ -1853,6 +1958,11 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         event.preventDefault();
       }
       if (state.activeSubmissions.value > 0) {
+        if (event === void 0) {
+          console.warn(
+            `[attaform] handleSubmit: a submit is already in flight on form "${String(state.formKey)}", so this call was ignored; its callback never ran. Await the first submit before starting another, or move the work into that submit's callback.`
+          );
+        }
         return;
       }
       const genAtEntry = state.submissionGeneration.value;
@@ -1878,7 +1988,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
             }
           }
           if (generationStillValid) {
-            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            applyInvalidSubmit?.();
           }
           if (onError !== void 0) {
             try {
@@ -1895,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;
         }
@@ -1913,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."
@@ -1933,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;
 }
@@ -1966,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) {
@@ -2039,15 +2138,16 @@ function walk(schema, store, path, value) {
     reportRejection(store, path, kind, accepted);
     return false;
   }
+  if (schema.isOpaqueLeafAtPath(path)) return true;
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      if (!walk(schema, store, [...path, i], value[i])) return false;
+      if (!walk(schema, store, [...path, i], readConsumerIndex(value, i))) return false;
     }
     return true;
   }
   if (isPlainRecord(value)) {
-    for (const key of Object.keys(value)) {
-      if (!walk(schema, store, [...path, key], value[key])) {
+    for (const key of consumerKeys(value)) {
+      if (!walk(schema, store, [...path, key], readConsumerProp(value, key))) {
         return false;
       }
     }
@@ -2058,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.
@@ -2091,170 +2191,95 @@ 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);
+function resolveCoerceEnabled(config) {
+  return config !== false;
+}
+function memberSlimTypes(schema, segments, accepted) {
+  if (accepted.has("array")) return schema.getSlimPrimitiveTypesAtPath([...segments, 0]);
+  if (accepted.has("set")) {
+    return schema.getSlimPrimitiveTypesAtPath([...segments, SET_MEMBER_SEGMENT]);
   }
-  return idx;
+  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 = accepted.has("array") || accepted.has("set") ? schema.getSlimPrimitiveTypesAtPath([...segments, 0]) : void 0;
-  return (value) => coerceValue(value, accepted, elementAccepted, index);
+  const elementAccepted = memberSlimTypes(schema, segments, accepted);
+  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);
-  if (!accepted.has("array") && !accepted.has("set")) return void 0;
-  const elementAccepted = schema.getSlimPrimitiveTypesAtPath([...segments, 0]);
-  return (value) => coerceScalar(value, elementAccepted, index);
+  const elementAccepted = memberSlimTypes(schema, segments, accepted);
+  if (elementAccepted === void 0) return void 0;
+  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 coerceScalar(value, accepted, index) {
+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) {
-    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;
@@ -2294,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 = {
@@ -2423,7 +2447,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       // --- Aria (internal; consumed by the directive) ---
       aria,
       isRequired,
-      ariaEnabled,
       ...ariaDisplayState !== void 0 ? { ariaDisplayState } : {}
     };
     return shallowReadonly(internalRv);
@@ -2445,8 +2468,8 @@ function walkUnsetSentinels(values, schema) {
   const cleaned = walkCore(values, [], schema, paths, true);
   return { cleanedValues: cleaned, paths };
 }
-function isOpaqueLeaf(value) {
-  return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function";
+function isRecursable(value) {
+  return Array.isArray(value) || isPlainRecord(value);
 }
 function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
   if (isUnset(input)) {
@@ -2460,20 +2483,21 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     return input;
   }
   if (input === null) return null;
-  if (isOpaqueLeaf(input)) return input;
+  if (!isRecursable(input)) return input;
   if (Array.isArray(input)) {
     const out = new Array(input.length);
     let mutated = false;
     for (let i = 0; i < input.length; i++) {
-      const walked = walkCore(input[i], [...segments, i], schema, paths, synthesizeSchemaKeys);
+      const original = readConsumerIndex(input, i);
+      const walked = walkCore(original, [...segments, i], schema, paths, synthesizeSchemaKeys);
       out[i] = walked;
-      if (walked !== input[i]) mutated = true;
+      if (walked !== original) mutated = true;
     }
     return mutated ? out : input;
   }
   if (typeof input === "object") {
     const obj = input;
-    const inputKeys = Object.keys(obj);
+    const inputKeys = consumerKeys(obj);
     let keys = inputKeys;
     let mutated = false;
     let inputKeysSet = null;
@@ -2481,7 +2505,7 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
       inputKeysSet = new Set(inputKeys);
       const allKeys = new Set(inputKeys);
       const slim = schema.getDefaultAtPath(segments);
-      if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !isOpaqueLeaf(slim)) {
+      if (isPlainRecord(slim)) {
         for (const k of Object.keys(slim)) allKeys.add(k);
       }
       keys = allKeys;
@@ -2489,7 +2513,7 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     }
     const out = {};
     for (const key of keys) {
-      const orig = obj[key];
+      const orig = readConsumerProp(obj, key);
       if (synthesizeSchemaKeys && orig === void 0 && inputKeysSet?.has(key) === true) {
         safeAssign(out, key, void 0);
         mutated = true;
@@ -2510,22 +2534,12 @@ function walkUnspecified(slim, segments, paths) {
     }
     return slim;
   }
-  if (isOpaqueLeaf(slim)) {
-    return slim;
-  }
-  if (Array.isArray(slim)) return slim;
-  if (slim !== null && typeof slim === "object") {
-    const out = {};
-    for (const key of Object.keys(slim)) {
-      safeAssign(
-        out,
-        key,
-        walkUnspecified(slim[key], [...segments, key], paths)
-      );
-    }
-    return out;
+  if (!isPlainRecord(slim)) return slim;
+  const out = {};
+  for (const key of Object.keys(slim)) {
+    safeAssign(out, key, walkUnspecified(slim[key], [...segments, key], paths));
   }
-  return slim;
+  return out;
 }
 function substituteUnsetSentinels(value, prefix, schema) {
   const paths = [];
@@ -2561,11 +2575,11 @@ function expandUnsetAt(segments, schema, paths) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
-  if (isOpaqueLeaf(slim)) {
+  if (Array.isArray(slim)) return slim;
+  if (!isPlainRecord(slim)) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
-  if (Array.isArray(slim)) return slim;
   const result = {};
   for (const key of Object.keys(slim)) {
     result[key] = expandUnsetAt([...segments, key], schema, paths);
@@ -2575,14 +2589,14 @@ function expandUnsetAt(segments, schema, paths) {
 function walkAuthoredFromConstraints(value, prefix, out) {
   if (prefix.length > 0) out.add(canonicalizePath(prefix).key);
   if (isPlainRecord(value)) {
-    for (const k of Object.keys(value)) {
-      walkAuthoredFromConstraints(value[k], [...prefix, k], out);
+    for (const k of consumerKeys(value)) {
+      walkAuthoredFromConstraints(readConsumerProp(value, k), [...prefix, k], out);
     }
     return;
   }
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      walkAuthoredFromConstraints(value[i], [...prefix, i], out);
+      walkAuthoredFromConstraints(readConsumerIndex(value, i), [...prefix, i], out);
     }
   }
 }
@@ -2596,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({
@@ -2627,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;
@@ -2661,26 +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 = state.pathSweep;
   const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
     getFormMetaBase,
-    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);
@@ -2692,6 +2754,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     const segments = canonicalizePath(pathInput).segments;
     return computed(() => getAtPath(state.form.value, segments));
   }
+  function pathStoresFunctions(segments) {
+    if (state.schema.isOpaqueLeafAtPath(segments)) return false;
+    return state.schema.getSlimPrimitiveTypesAtPath(segments).has("function");
+  }
   function setValueImpl(pathOrValue, maybeValue) {
     const argc = arguments.length;
     const isPathForm = argc >= 2 && (typeof pathOrValue === "string" || Array.isArray(pathOrValue));
@@ -2744,7 +2810,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     };
     if (isUnset(maybeValue)) return writeUnsetAt();
     let resolvedValue;
-    if (typeof maybeValue === "function") {
+    if (typeof maybeValue === "function" && !pathStoresFunctions(segments)) {
       const current = state.getValueAtPath(segments);
       const prev = current === void 0 ? state.schema.getDefaultAtPath(segments) : current;
       resolvedValue = maybeValue(prev);
@@ -2762,7 +2828,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     reMarkBlanksAfterSubstitution(walked.paths);
     return true;
   }
-  const errorsProxy = buildErrorsSurface(state);
+  const errorsProxy = buildErrorsSurface(state, pathSweep);
   function flattenUserErrors() {
     const all = [];
     for (const cell of state.errorCells.values()) all.push(...cell.user);
@@ -2804,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
@@ -2848,21 +2913,19 @@ 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) {
       state.reset();
     } else {
-      const walked = walkUnsetSentinels(
+      const walked = substituteUnsetSentinels(
         nextDefaultValues,
+        [],
         state.schema
       );
       state.reset(walked.cleanedValues);
@@ -2894,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();
@@ -2936,8 +2984,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     };
     return Object.freeze(view);
   });
-  const valuesProxy = buildValuesSurface(state.form);
-  const fieldStateProxy = buildFieldsSurface(state, getRootFieldStateAt);
+  const valuesProxy = buildValuesSurface(state.form, state.onFormChange);
+  const fieldStateProxy = buildFieldsSurface(state, getRootFieldStateAt, pathSweep);
   const needsLazyGate = state.defaultValuesFactory.value !== void 0 || state.hasSsrPrefetch;
   function gated(fn) {
     if (!needsLazyGate) return fn;
@@ -3083,8 +3131,53 @@ 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;
+function withLiveness(machine, now) {
+  if (machine.display !== "pending") return machine;
+  if (machine.reviewAt !== void 0 && Number.isFinite(machine.reviewAt)) return machine;
+  return { ...machine, reviewAt: now + PENDING_LIVENESS_MS };
+}
 function createDisplayEngine(ssr) {
   const machines = /* @__PURE__ */ new Map();
   const tick = ref(0);
@@ -3113,7 +3206,7 @@ function createDisplayEngine(ssr) {
       return;
     }
     if (timer !== null && timerTarget === target) return;
-    if (target === lastFiredTarget) {
+    if (target === lastFiredTarget && target <= now) {
       clearTimer();
       return;
     }
@@ -3132,8 +3225,9 @@ function createDisplayEngine(ssr) {
   function resolve(key, ctx, reducer) {
     void tick.value;
     const prev = machines.get(key) ?? IDLE;
-    const machine = reducer(prev, ctx);
-    if (ssr) return machine;
+    const reduced = reducer(prev, ctx);
+    if (ssr) return reduced;
+    const machine = withLiveness(reduced, ctx.now);
     const active = machine.display !== "idle" || machine.reviewAt !== void 0 && Number.isFinite(machine.reviewAt);
     if (active) machines.set(key, machine);
     else machines.delete(key);
@@ -3169,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);
 }
@@ -3230,6 +3376,7 @@ async function runFactoryAndApply(st, factory) {
       st.schema
     );
     st.applyFormReplacement(full, { hydration: true });
+    st.adoptResolvedDefaults(value);
     st.scheduleFieldValidation(
       [],
       true
@@ -3314,12 +3461,10 @@ function applyDuStubs(schema, data, options = {}) {
 }
 function walkDuStubs(schema, value, path, warned) {
   if (value === null || value === void 0 || typeof value !== "object") return value;
-  if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function") {
-    return value;
-  }
   if (Array.isArray(value)) {
     return value.map((item, i) => walkDuStubs(schema, item, [...path, i], warned));
   }
+  if (!isPlainRecord(value)) return value;
   const rec = value;
   const du = schema.getUnionDiscriminatorAtPath(path);
   if (du !== void 0) {
@@ -3342,8 +3487,8 @@ function walkDuStubs(schema, value, path, warned) {
     }
   }
   const out = {};
-  for (const k of Object.keys(rec)) {
-    safeAssign(out, k, walkDuStubs(schema, rec[k], [...path, k], warned));
+  for (const k of consumerKeys(rec)) {
+    safeAssign(out, k, walkDuStubs(schema, readConsumerProp(rec, k), [...path, k], warned));
   }
   return out;
 }
@@ -3353,23 +3498,25 @@ function stripSymbolsDeep(value) {
     let mutated2 = false;
     const out2 = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
-      const cleaned = stripSymbolsDeep(value[i]);
+      const original = readConsumerIndex(value, i);
+      const cleaned = stripSymbolsDeep(original);
       out2[i] = cleaned;
-      if (cleaned !== value[i]) mutated2 = true;
+      if (cleaned !== original) mutated2 = true;
     }
     return mutated2 ? out2 : value;
   }
   const proto = Object.getPrototypeOf(value);
   if (proto !== Object.prototype && proto !== null) return value;
-  const symKeys = Object.getOwnPropertySymbols(value);
-  const stringKeys = Object.keys(value);
+  const symKeys = consumerSymbolKeys(value);
+  const stringKeys = consumerKeys(value);
   let mutated = symKeys.length > 0;
   const out = {};
   const src = value;
   for (const k of stringKeys) {
-    const cleaned = stripSymbolsDeep(src[k]);
+    const original = readConsumerProp(src, k);
+    const cleaned = stripSymbolsDeep(original);
     out[k] = cleaned;
-    if (cleaned !== src[k]) mutated = true;
+    if (cleaned !== original) mutated = true;
   }
   return mutated ? out : value;
 }
@@ -3394,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();
@@ -3415,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,
       [],
@@ -3457,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;
@@ -3603,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 {
@@ -3817,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;
@@ -3836,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;
 }
@@ -3905,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;
     }
@@ -3918,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) {
@@ -4202,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);
     }
   }
 }
@@ -4218,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 });
@@ -4237,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;
@@ -4290,9 +4422,24 @@ function activate(st) {
   if (factory === void 0) return Promise.resolve();
   return fireFactory(st, factory);
 }
+function adoptResolvedDefaults(st, value) {
+  st.defaultValues = structuralSnapshot(
+    mergeSparseHydration(
+      st.defaultValues,
+      value,
+      st.schema
+    )
+  );
+  seedOriginalsFromBaseline(st, computeBaselineResponse(st.schema, st.defaultValues).data, false);
+}
 function reset(st, nextDefaultValues) {
-  const resetSource = nextDefaultValues ?? st.defaultValues;
-  const resetResponse = computeBaselineResponse(st.schema, st.strict, resetSource);
+  const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
+    st.defaultValues,
+    nextDefaultValues,
+    st.schema
+  );
+  st.defaultValues = structuralSnapshot(resetSource);
+  const resetResponse = computeBaselineResponse(st.schema, resetSource);
   const next = resetResponse.data;
   rebuildAuthoredPaths(st, resetSource, next);
   applyFormReplacement(st, next);
@@ -4300,25 +4447,23 @@ function reset(st, nextDefaultValues) {
   st.removedSubtrees.clear();
   seedOriginalsFromBaseline(st, next, false);
   if (nextDefaultValues !== void 0) {
-    st.blankPaths.clear();
-    st.originalBlankPaths.clear();
-  } else {
-    st.blankPaths.clear();
-    for (const key of st.originalBlankPaths) {
-      st.blankPaths.add(key);
-    }
+    const mentioned = /* @__PURE__ */ new Set();
+    walkAuthoredFromConstraints(nextDefaultValues, [], mentioned);
+    for (const key of mentioned) st.originalBlankPaths.delete(key);
+  }
+  st.blankPaths.clear();
+  for (const key of st.originalBlankPaths) {
+    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) {
@@ -4408,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);
@@ -4445,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;
@@ -4458,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);
@@ -4486,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);
   }
@@ -4512,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);
@@ -4544,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;
@@ -4562,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,
@@ -4579,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,
@@ -4586,10 +4747,11 @@ function createFormStore(options) {
     fields,
     errorCells,
     derivedBlankErrors,
+    errorWindowAt,
     originals,
+    pathSweep,
     schema,
     ssr,
-    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4617,12 +4779,20 @@ function createFormStore(options) {
     displayEngine,
     domBinding,
     modules,
-    coerceIndex,
+    coerceEnabled,
     blankPaths,
     originalBlankPaths,
     // --- kernel-internal state ---
-    strict,
-    defaultValues,
+    // 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.
+    defaultValues: structuralSnapshot(defaultValues),
     ssrPrefetch,
     rememberVariants,
     fieldValidationMode,
@@ -4649,16 +4819,20 @@ function createFormStore(options) {
     transformTokenSeq: 0,
     warnedDisabledWrite: false,
     // --- methods: thin per-instance skins over the module kernel ---
-    rehydrate: () => rehydrate(st),
-    activate: () => activate(st),
-    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,
@@ -4667,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,
@@ -4676,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);
@@ -4748,7 +4919,7 @@ function createFormStore(options) {
         blurredAfterInteraction: false
       });
     });
-    if (strict && !schemaResponse.success) {
+    if (!schemaResponse.success) {
       replaceErrorChannel(st, "schema", schemaResponse.errors);
     }
   }
@@ -4779,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;
   }
@@ -4804,6 +4974,7 @@ function useAbstractForm(configuration, options) {
     const factory = resolvedDefaults.factory;
     state.defaultValuesFactory.value = factory;
     if (hadPendingHydration) {
+      state.adoptResolvedDefaults(toRaw(state.form.value));
       state.hydrating.value = false;
       state.defaultsResolved.value = true;
     } else if (registry.ssr) {
@@ -4820,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());
   }
@@ -4834,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);
@@ -4883,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`
@@ -5032,12 +5181,13 @@ function makeRegisterValueProxy(capturedRegisterValue) {
     get(_target, prop) {
       if (prop === "__v_isRef") return true;
       if (prop === "value") return capturedRegisterValue.value;
+      if (prop === "isBound") return capturedRegisterValue.value !== void 0;
       const v = capturedRegisterValue.value;
       if (v === void 0) return void 0;
       return Reflect.get(v, prop);
     },
     has(_target, prop) {
-      if (prop === "__v_isRef" || prop === "value") return true;
+      if (prop === "__v_isRef" || prop === "value" || prop === "isBound") return true;
       const v = capturedRegisterValue.value;
       if (v === void 0) return false;
       return Reflect.has(v, prop);
@@ -5058,7 +5208,7 @@ function makeRegisterValueProxy(capturedRegisterValue) {
     }
   });
 }
-function useRegister() {
+function useRegister(options) {
   const instance = getCurrentInstance();
   if (instance === null) {
     warnOutsideSetup();
@@ -5098,7 +5248,7 @@ function useRegister() {
     if (el !== null && el !== void 0 && typeof el === "object") {
       el[REGISTER_OWNER_MARKER] = true;
     }
-    if (capturedRegisterValue.value === void 0) {
+    if (capturedRegisterValue.value === void 0 && options?.optional !== true) {
       warnNoParentRV(instance);
     }
   });
@@ -5118,7 +5268,7 @@ function warnNoParentRV(instance) {
   warnedNoParentRV.add(instance);
   const frame = captureUserCallSite();
   console.warn(
-    `[attaform] useRegister: no parent registerValue prop; RegisterValue fields will read as undefined. Pass v-register on the parent: \`<YourComponent v-register="form.register('field')" />\`.` + (frame !== void 0 ? ` ${frame}` : "")
+    `[attaform] useRegister: no parent registerValue prop; RegisterValue fields will read as undefined. Pass v-register on the parent: \`<YourComponent v-register="form.register('field')" />\`. If this component is meant to work without a form too, say so with \`useRegister({ optional: true })\` and branch on \`rv?.isBound\`.` + (frame !== void 0 ? ` ${frame}` : "")
   );
 }
 
@@ -5202,38 +5352,36 @@ 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,
+    isOpaqueLeafAtPath: () => false,
     arrayShapeAtPath: () => null,
     isFixedObjectAtPath: (path) => path.length === 0,
+    // The noop schema declares no shape at all, so nothing under it is
+    // 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) {
@@ -5352,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);
@@ -5363,7 +5511,7 @@ function useWizard(options) {
     const noop = lazyNoopScope.run(
       () => useAbstractForm(
         {
-          schema: buildNoopWizardSchema(key),
+          schema: buildNoopWizardSchema(),
           key
         },
         { registry }
@@ -6024,6 +6172,24 @@ function useWizard(options) {
     const target = list[idx + 1];
     moveTo(target.key);
   }
+  let cancelDeferredAdvance = null;
+  function advanceWhenInFlightSubmitLands(store, key) {
+    cancelDeferredAdvance?.();
+    const attemptsAtRequest = store.submissionAttempts.value;
+    const off = store.onSubmitSuccess(() => {
+      off();
+      cancelDeferredAdvance = null;
+      if (store.submissionAttempts.value !== attemptsAtRequest) return;
+      if (activeKey.value !== key) return;
+      advanceOne();
+    });
+    cancelDeferredAdvance = off;
+  }
+  function inFlightActiveStore() {
+    const store = registry.forms.get(activeKey.value);
+    if (store === void 0 || store.activeSubmissions.value === 0) return void 0;
+    return store;
+  }
   async function next() {
     if (submitting.value) {
       {
@@ -6050,7 +6216,12 @@ function useWizard(options) {
       return;
     }
     const active = list[idx];
-    if (active !== void 0 && active.isGate) {
+    if (active !== void 0 && active.isGate && !clearedGates.has(active.key)) {
+      const inFlight = inFlightActiveStore();
+      if (inFlight !== void 0) {
+        advanceWhenInFlightSubmitLands(inFlight, activeKey.value);
+        return;
+      }
       await tryNext();
       return;
     }
@@ -6082,11 +6253,16 @@ function useWizard(options) {
     const form = activeForm.value;
     if (form === void 0) return false;
     const before = activeKey.value;
+    const inFlight = inFlightActiveStore();
+    if (inFlight !== void 0) {
+      advanceWhenInFlightSubmitLands(inFlight, before);
+      return false;
+    }
     let ranClean = false;
     await asHandleSubmitSource(form).handleSubmit(() => {
       ranClean = true;
     })();
-    if (ranClean) advanceOne();
+    if (ranClean && activeKey.value === before) advanceOne();
     return activeKey.value !== before;
   }
   function back() {
@@ -6366,6 +6542,7 @@ function useWizard(options) {
     onScopeDispose(() => {
       historyHandle.dispose();
       lazyNoopScope.stop();
+      cancelDeferredAdvance?.();
     });
   }
   const explicitKey = options.key;
@@ -6558,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, humanize as o, 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 };