attaform 0.28.0 → 0.29.0

package/dist/dev/shared/{attaform-dev.WmuhD_CZ.mjs → attaform-dev.DHuydLAC.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 { A as ANONYMOUS_FORM_KEY_PREFIX, d as consumerHas, i as isShadowedKey, e as safeOwnHas, a as safeOwnRead, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform-dev.ButTkwHd.mjs';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.DD5m2W51.mjs';
+import { R as REGISTER_OWNER_MARKER, d as armDomBinding, V as V_REGISTER_MARKER } from './attaform-dev.D8aoKb89.mjs';
+import { i as isPathPrefix, e as canonicalizePath, j as cellEntriesFor, s as segmentsForPathKey, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, l as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, o as normalizeErrorInputs, q as coerceToPathKey, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform-dev.A-TpJW0B.mjs';
 
 const AttaformErrorCode = {
   /** A required field is in the blank set — user hasn't supplied a value. */
@@ -77,6 +77,11 @@ function makeBlankRequiredError(segments) {
 }
 const NO_ERRORS = Object.freeze([]);
 
+function crossCopyState(key, create) {
+  const carrier = globalThis;
+  return carrier[key] ?? (carrier[key] = create());
+}
+
 function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
 }
@@ -99,7 +104,10 @@ function earliestNonNull(a, b) {
 }
 const DEFAULT_TIMINGS = { showDelay: 120, minVisible: 120 };
 const FOCUS_OUT_GRACE = 16;
-const defaultFamily = /* @__PURE__ */ new WeakSet();
+const defaultFamily = crossCopyState(
+  /* @__PURE__ */ Symbol.for("attaform:default-display-state-family"),
+  () => /* @__PURE__ */ new WeakSet()
+);
 function isDefaultDisplayState(fn) {
   return defaultFamily.has(fn);
 }
@@ -186,6 +194,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 +213,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)) {
@@ -226,11 +250,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;
@@ -245,6 +272,13 @@ function setAtPathOffset(root, path, value, offset) {
   if (offset >= path.length) return value;
   const head = path[offset];
   const nextOffset = offset + 1;
+  if (root instanceof Map) {
+    const next = new Map(root);
+    const key = mapKeyForSegment(root, head);
+    next.set(key, setAtPathOffset(root.get(key), path, value, nextOffset));
+    return next;
+  }
+  if (!isRebuildableContainer(root, head)) return root;
   if (typeof head === "number") {
     const arr = Array.isArray(root) ? [...root] : [];
     while (arr.length <= head) arr.push(void 0);
@@ -258,9 +292,17 @@ function setAtPathOffset(root, path, value, offset) {
 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 +337,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 +378,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 +392,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 +420,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 +441,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);
@@ -443,9 +523,10 @@ function isUnderStubAncestor(state, segments) {
   }
   return false;
 }
-function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options) {
+function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, sweep, options) {
   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);
@@ -454,6 +535,7 @@ function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options
       () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate)
     );
     cache.set(key, c);
+    sweep.track(segments, key);
     return c;
   };
 }
@@ -543,7 +625,7 @@ function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBa
 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 +635,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 {
@@ -803,6 +885,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 +899,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 +931,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 +961,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 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 +982,8 @@ function buildTree(spec) {
   }
   function containerAt(segments) {
     const isArrayLike = spec.isArrayAt(segments);
-    const cacheKey = `${JSON.stringify(segments)}+${isArrayLike ? "A" : "O"}`;
+    const pathKey = JSON.stringify(segments);
+    const cacheKey = `${pathKey}+${isArrayLike ? "A" : "O"}`;
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const isFixedObject = spec.schema.isFixedObjectAtPath(segments);
@@ -973,12 +1073,14 @@ 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);
     let tree = treeCache.get(cacheKey);
@@ -986,6 +1088,7 @@ function buildErrorsSurface(state) {
       const frozen = [...segments];
       tree = computed(() => materializeErrors(state, frozen));
       treeCache.set(cacheKey, tree);
+      sweep.track(segments, cacheKey);
     }
     return tree.value;
   };
@@ -1031,7 +1134,8 @@ function buildErrorsSurface(state) {
     // aggregate — the same helper `meta.errors` reads, so the surfaces
     // never drift.
     call: (path) => aggregateErrorsAt(state, path),
-    surface: "form.errors"
+    surface: "form.errors",
+    sweep
   });
 }
 function errorAwareContainerKeys(state, segments) {
@@ -1150,7 +1254,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,6 +1262,7 @@ 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 existing = viewCache.get(cacheKey);
@@ -1212,6 +1317,7 @@ function buildFieldsSurface(state, getFieldStateAt) {
       }
     });
     viewCache.set(cacheKey, proxy);
+    sweep.track(segments, cacheKey);
     return proxy;
   }
   return buildTree({
@@ -1226,7 +1332,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 +1367,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 +1679,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) {
@@ -1706,6 +1832,45 @@ function buildFieldArrayApi(state) {
   };
 }
 
+const SWEEP_SLICE = 8;
+function createDynamicPathSweep(state) {
+  const dynamicKeys = /* @__PURE__ */ new Set();
+  const evictors = [];
+  const isDynamicPath = (segments) => {
+    for (let i = 0; i < segments.length; i++) {
+      if (typeof segments[i] === "number") return true;
+      if (!state.schema.isFixedObjectAtPath(segments.slice(0, i))) return true;
+    }
+    return false;
+  };
+  let sweepCursor = null;
+  state.onFormChange((next) => {
+    if (dynamicKeys.size === 0) return;
+    const raw = toRaw(next);
+    for (let i = 0; i < SWEEP_SLICE; i++) {
+      sweepCursor ?? (sweepCursor = dynamicKeys.values());
+      const step = sweepCursor.next();
+      if (step.done === true) {
+        sweepCursor = null;
+        break;
+      }
+      const segments = segmentsForPathKey(step.value);
+      if (segments !== null && hasAtPath(raw, segments)) continue;
+      dynamicKeys.delete(step.value);
+      for (const evict of evictors) evict(step.value);
+    }
+  });
+  return {
+    track(segments, key) {
+      if (dynamicKeys.has(key)) return;
+      if (isDynamicPath(segments)) dynamicKeys.add(key);
+    },
+    onEvict(evict) {
+      evictors.push(evict);
+    }
+  };
+}
+
 const warnedNoScopeStores = /* @__PURE__ */ new WeakSet() ;
 function isErrorInputLike(value) {
   if (value instanceof Error) return true;
@@ -1853,6 +2018,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;
@@ -2039,15 +2209,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;
       }
     }
@@ -2142,19 +2313,26 @@ function indexRules(rules) {
   }
   return idx;
 }
+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 void 0;
+}
 function buildCoerceFn(schema, segments, index) {
   if (index === EMPTY_INDEX) return IDENTITY;
   if (index.size === 0) return IDENTITY;
   const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
-  const elementAccepted = accepted.has("array") || accepted.has("set") ? schema.getSlimPrimitiveTypesAtPath([...segments, 0]) : void 0;
+  const elementAccepted = memberSlimTypes(schema, segments, accepted);
   return (value) => coerceValue(value, accepted, elementAccepted, index);
 }
 function buildElementCoerceFn(schema, segments, index) {
   if (index === EMPTY_INDEX) return void 0;
   if (index.size === 0) return void 0;
   const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
-  if (!accepted.has("array") && !accepted.has("set")) return void 0;
-  const elementAccepted = schema.getSlimPrimitiveTypesAtPath([...segments, 0]);
+  const elementAccepted = memberSlimTypes(schema, segments, accepted);
+  if (elementAccepted === void 0) return void 0;
   return (value) => coerceScalar(value, elementAccepted, index);
 }
 function pickScalarTarget(accepted) {
@@ -2445,8 +2623,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 +2638,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 +2660,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 +2668,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 +2689,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 +2730,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 +2744,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);
     }
   }
 }
@@ -2662,10 +2831,12 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return metaBase;
   };
   const fieldStateAccessorOptions = options.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0;
+  const pathSweep = createDynamicPathSweep(state);
   const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
     getFormMetaBase,
+    pathSweep,
     fieldStateAccessorOptions
   );
   const getDisplayStateAt = (segments) => getRootFieldStateAt(segments).value.displayState;
@@ -2692,6 +2863,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 +2919,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 +2937,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);
@@ -2861,8 +3036,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (nextDefaultValues === void 0) {
       state.reset();
     } else {
-      const walked = walkUnsetSentinels(
+      const walked = substituteUnsetSentinels(
         nextDefaultValues,
+        [],
         state.schema
       );
       state.reset(walked.cleanedValues);
@@ -2936,8 +3112,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;
@@ -3085,6 +3261,12 @@ function shortenSourceFrame(frame) {
 
 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 +3295,7 @@ function createDisplayEngine(ssr) {
       return;
     }
     if (timer !== null && timerTarget === target) return;
-    if (target === lastFiredTarget) {
+    if (target === lastFiredTarget && target <= now) {
       clearTimer();
       return;
     }
@@ -3132,8 +3314,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);
@@ -3230,6 +3413,7 @@ async function runFactoryAndApply(st, factory) {
       st.schema
     );
     st.applyFormReplacement(full, { hydration: true });
+    st.adoptResolvedDefaults(value);
     st.scheduleFieldValidation(
       [],
       true
@@ -3314,12 +3498,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 +3524,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 +3535,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;
 }
@@ -4290,8 +4474,27 @@ 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.strict, st.defaultValues).data,
+    false
+  );
+}
 function reset(st, nextDefaultValues) {
-  const resetSource = nextDefaultValues ?? st.defaultValues;
+  const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
+    st.defaultValues,
+    nextDefaultValues,
+    st.schema
+  );
+  st.defaultValues = structuralSnapshot(resetSource);
   const resetResponse = computeBaselineResponse(st.schema, st.strict, resetSource);
   const next = resetResponse.data;
   rebuildAuthoredPaths(st, resetSource, next);
@@ -4300,13 +4503,13 @@ 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) {
@@ -4622,7 +4825,16 @@ function createFormStore(options) {
     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,
@@ -4651,6 +4863,7 @@ function createFormStore(options) {
     // --- methods: thin per-instance skins over the module kernel ---
     rehydrate: () => rehydrate(st),
     activate: () => activate(st),
+    adoptResolvedDefaults: (value) => adoptResolvedDefaults(st, value),
     pathHasAsyncValidation: (path) => pathHasAsyncValidation(st, path),
     pathHasAsyncValidationByKey: (key, segments) => pathHasAsyncValidationByKey(st, key, segments),
     applyFormReplacement: (next, meta) => applyFormReplacement(st, next, meta),
@@ -4804,6 +5017,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) {
@@ -5032,12 +5246,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 +5273,7 @@ function makeRegisterValueProxy(capturedRegisterValue) {
     }
   });
 }
-function useRegister() {
+function useRegister(options) {
   const instance = getCurrentInstance();
   if (instance === null) {
     warnOutsideSetup();
@@ -5098,7 +5313,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 +5333,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}` : "")
   );
 }
 
@@ -5224,8 +5439,12 @@ function buildNoopWizardSchema(formKey) {
     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,
     getSlimPrimitiveTypesAtPath: () => new Set(EMPTY_SLIM_KINDS),
@@ -6024,6 +6243,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 +6287,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 +6324,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 +6613,7 @@ function useWizard(options) {
     onScopeDispose(() => {
       historyHandle.dispose();
       lazyNoopScope.stop();
+      cancelDeferredAdvance?.();
     });
   }
   const explicitKey = options.key;
@@ -6558,4 +6806,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, DEFAULT_TIMINGS as D, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, escapeForInlineScript as e, isUnset as f, gate as g, useAbstractForm as h, injectForm as i, useRegister as j, useWizard as k, lazy as l, makeDefaultDisplayState as m, isPlainRecord as n, crossCopyState as o, getAtPath as p, humanize as q, slimKindOf as s, unset as u };