attaform 0.21.0 → 0.21.2

package/dist/shared/{attaform.DSqO6Db7.mjs → attaform.CTheKoTc.mjs}

@@ -1,5 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, toRaw, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
-import { _ as __DEV__, j as canonicalizePath, G as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, v as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, J as useRegistry, z as kFormContext, B as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.Y_Mgg0Yp.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
+import { _ as __DEV__, a as canonicalizePath, s as segmentsForPathKey, l as isPathPrefix, F as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, t as toError, A as AnonPersistError, q as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, w as allowSensitivePersist, x as FORM_ERRORS_PATH, y as coerceToPathKey, z as isSensitivePath, B as createPersistOptInRegistry, d as InvalidUseFormConfigError, C as ensureAttaformInstalled, u as useRegistry, E as kFormContext, G as kFormInstanceId, h as ReservedFormKeyError, H as createIsSensitivePath, J as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, k as kAttaformWizardActiveStepResolver, K as kAttaformAncestorWizard } from './attaform.DP-u7_tk.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -13,10 +13,14 @@ function safeAssign(target, key, value) {
   }
   target[key] = value;
 }
+function isShadowedKey(key) {
+  return key in Object.prototype;
+}
 function safeOwnRead(target, key) {
-  if (key === "__proto__") {
-    const desc = Object.getOwnPropertyDescriptor(target, "__proto__");
-    return desc?.value;
+  if (isShadowedKey(key)) {
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc === void 0) return void 0;
+    return "value" in desc ? desc.value : target[key];
   }
   return target[key];
 }
@@ -35,6 +39,10 @@ function descendStep(value, segment) {
   }
   const record = value;
   const key = typeof segment === "number" ? String(segment) : segment;
+  if (isShadowedKey(key)) {
+    if (!safeOwnHas(record, key)) return NOT_FOUND;
+    return safeOwnRead(record, key);
+  }
   if (!(key in record)) return NOT_FOUND;
   return record[key];
 }
@@ -64,6 +72,7 @@ function hasAtPath(root, path) {
     return typeof last === "number" && last >= 0 && last < current.length;
   }
   const key = typeof last === "number" ? String(last) : last;
+  if (isShadowedKey(key)) return safeOwnHas(current, key);
   return key in current;
 }
 function isPlainRecord(value) {
@@ -151,68 +160,80 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
   }
   if (consumer === null) return null;
   if (Array.isArray(consumer)) {
-    const shape = resolveArrayShape(schema, scratch);
-    const isTuple = typeof shape === "number";
-    const targetLen = isTuple ? shape : consumer.length;
-    let cachedElementDefault;
-    let cachedElementDefaultRead = false;
-    let mutated = targetLen > consumer.length;
-    const out = consumer.slice();
-    while (out.length < targetLen) out.push(void 0);
-    for (let i = 0; i < targetLen; i++) {
-      scratch.push(i);
-      let elemDefault;
-      if (isTuple) {
-        elemDefault = schema.getDefaultAtPath(scratch);
-      } else {
-        if (!cachedElementDefaultRead) {
-          cachedElementDefault = schema.getDefaultAtPath(scratch);
-          cachedElementDefaultRead = true;
-        }
-        elemDefault = cachedElementDefault;
-      }
-      const consumerElem = i < consumer.length ? consumer[i] : void 0;
-      const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
-      scratch.pop();
-      if (merged !== consumerElem) {
-        out[i] = merged;
-        mutated = true;
-      }
-    }
-    return mutated ? out : consumer;
+    return mergeStructuralArray(schema, scratch, consumer);
   }
   if (isPlainRecord(consumer)) {
     if (!isPlainRecord(defaultValue)) {
       return consumer;
     }
-    let mutated = false;
     const out = { ...consumer };
-    for (const key of Object.keys(defaultValue)) {
-      if (!safeOwnHas(consumer, key)) {
-        const defAtKey = safeOwnRead(defaultValue, key);
-        scratch.push(key);
-        const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
-        scratch.pop();
-        if (filled !== void 0) {
-          safeAssign(out, key, filled);
-          mutated = true;
-        }
+    const filledAny = fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out);
+    const recursedAny = recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out);
+    return filledAny || recursedAny ? out : consumer;
+  }
+  return consumer;
+}
+function mergeStructuralArray(schema, scratch, consumer) {
+  const shape = resolveArrayShape(schema, scratch);
+  const isTuple = typeof shape === "number";
+  const targetLen = isTuple ? shape : consumer.length;
+  let cachedElementDefault;
+  let cachedElementDefaultRead = false;
+  let mutated = targetLen > consumer.length;
+  const out = consumer.slice();
+  while (out.length < targetLen) out.push(void 0);
+  for (let i = 0; i < targetLen; i++) {
+    scratch.push(i);
+    let elemDefault;
+    if (isTuple) {
+      elemDefault = schema.getDefaultAtPath(scratch);
+    } else {
+      if (!cachedElementDefaultRead) {
+        cachedElementDefault = schema.getDefaultAtPath(scratch);
+        cachedElementDefaultRead = true;
       }
+      elemDefault = cachedElementDefault;
     }
-    for (const key of Object.keys(consumer)) {
-      const cVal = safeOwnRead(consumer, key);
-      if (cVal === void 0) continue;
+    const consumerElem = i < consumer.length ? consumer[i] : void 0;
+    const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
+    scratch.pop();
+    if (merged !== consumerElem) {
+      out[i] = merged;
+      mutated = true;
+    }
+  }
+  return mutated ? out : consumer;
+}
+function fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out) {
+  let mutated = false;
+  for (const key of Object.keys(defaultValue)) {
+    if (!safeOwnHas(consumer, key)) {
+      const defAtKey = safeOwnRead(defaultValue, key);
       scratch.push(key);
-      const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
+      const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
       scratch.pop();
-      if (merged !== cVal) {
-        safeAssign(out, key, merged);
+      if (filled !== void 0) {
+        safeAssign(out, key, filled);
         mutated = true;
       }
     }
-    return mutated ? out : consumer;
   }
-  return consumer;
+  return mutated;
+}
+function recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out) {
+  let mutated = false;
+  for (const key of Object.keys(consumer)) {
+    const cVal = safeOwnRead(consumer, key);
+    if (cVal === void 0) continue;
+    scratch.push(key);
+    const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
+    scratch.pop();
+    if (merged !== cVal) {
+      safeAssign(out, key, merged);
+      mutated = true;
+    }
+  }
+  return mutated;
 }
 function setAtPathWithSchemaFill(root, schema, fullPath, value) {
   if (fullPath.length === 0) return value;
@@ -295,55 +316,27 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   const oldIsDescendable = isDescendable(oldValue);
   const newIsDescendable = isDescendable(newValue);
   if (oldValue === void 0 && newIsDescendable) {
-    if (Array.isArray(newValue)) {
-      for (let i = 0; i < newValue.length; i++) {
-        diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = newValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
-      }
-    }
+    walkNewDescendable(newValue, prefix, visit);
     return;
   }
   if (oldIsDescendable && newValue === void 0) {
-    if (Array.isArray(oldValue)) {
-      for (let i = 0; i < oldValue.length; i++) {
-        diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = oldValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
-      }
-    }
+    walkOldDescendable(oldValue, prefix, visit);
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
     const oldIsArray = Array.isArray(oldValue);
     const newIsArray = Array.isArray(newValue);
     if (oldIsArray && newIsArray) {
-      const oldArr = oldValue;
-      const newArr = newValue;
-      const max = Math.max(oldArr.length, newArr.length);
-      for (let i = 0; i < max; i++) {
-        diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
-      }
+      diffArraysLockstep(oldValue, newValue, prefix, visit);
       return;
     }
     if (!oldIsArray && !newIsArray) {
-      const oldRec = oldValue;
-      const newRec = newValue;
-      const seen = /* @__PURE__ */ new Set();
-      for (const k of Object.keys(oldRec)) {
-        seen.add(k);
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
-      for (const k of Object.keys(newRec)) {
-        if (seen.has(k)) continue;
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
+      diffObjectsLockstep(
+        oldValue,
+        newValue,
+        prefix,
+        visit
+      );
       return;
     }
     visit({ kind: "changed", path: prefix, oldValue, newValue });
@@ -367,6 +360,47 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   }
   visit({ kind: "changed", path: prefix, oldValue, newValue });
 }
+function walkNewDescendable(newValue, prefix, visit) {
+  if (Array.isArray(newValue)) {
+    for (let i = 0; i < newValue.length; i++) {
+      diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+    }
+  } else {
+    const rec = newValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+    }
+  }
+}
+function walkOldDescendable(oldValue, prefix, visit) {
+  if (Array.isArray(oldValue)) {
+    for (let i = 0; i < oldValue.length; i++) {
+      diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+    }
+  } else {
+    const rec = oldValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+    }
+  }
+}
+function diffArraysLockstep(oldArr, newArr, prefix, visit) {
+  const max = Math.max(oldArr.length, newArr.length);
+  for (let i = 0; i < max; i++) {
+    diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+  }
+}
+function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(oldRec)) {
+    seen.add(k);
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+  for (const k of Object.keys(newRec)) {
+    if (seen.has(k)) continue;
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+}
 function applyChangedKeys(target, source) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
   const targetIsArray = Array.isArray(target);
@@ -470,7 +504,12 @@ function computeVerdict(field, formMeta) {
   if (field.valid === true && field.blank !== true && field.dirty === true) return "success";
   return "idle";
 }
-const DEFAULT_TIMINGS = { showDelay: 100, minVisible: 120 };
+function earliestNonNull(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return a < b ? a : b;
+}
+const DEFAULT_TIMINGS = { showDelay: 120, minVisible: 120 };
 const FOCUS_OUT_GRACE = 16;
 const defaultFamily = /* @__PURE__ */ new WeakSet();
 function isDefaultDisplayState(fn) {
@@ -480,10 +519,11 @@ function makeDefaultDisplayState({
   showDelay,
   minVisible
 }) {
-  const reducer = (prev, { field, formMeta, validatingSince, now }) => {
+  const reducer = (prev, { field, formMeta, validatingSince, transformingSince, now }) => {
     const verdict = computeVerdict(field, formMeta);
     if (!isGateOpen(field, formMeta)) return { display: verdict };
-    if (validatingSince === null) {
+    const inFlightSince = earliestNonNull(validatingSince, transformingSince);
+    if (inFlightSince === null) {
       if (prev.display === "pending") {
         const shownAt = prev.pendingShownAt ?? now;
         if (now < shownAt + minVisible)
@@ -494,8 +534,8 @@ function makeDefaultDisplayState({
     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 - validatingSince < window) {
-      return { display: prev.display, reviewAt: validatingSince + window };
+    if (now - inFlightSince < window) {
+      return { display: prev.display, reviewAt: inFlightSince + window };
     }
     return { display: "pending", pendingShownAt: now, reviewAt: now + minVisible };
   };
@@ -608,6 +648,12 @@ function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options
     return c;
   };
 }
+function resolveFieldMetaAndLabel(state, segments) {
+  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
+  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
+  const label = resolved.label || humanize(lastSegment);
+  return { resolved, label };
+}
 function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const record = state.fields.get(key);
   const value = state.getValueAtPath(segments);
@@ -621,15 +667,15 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   if (blankForKey !== void 0) errors.push(...blankForKey);
   if (userForKey !== void 0) errors.push(...userForKey);
   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 isOrphan = segments.length > 0 && !hasAtPath(state.form.value, segments) && isUnderStubAncestor(state, segments);
   const valid = !gated && errors.length === 0 && !validating && !isOrphan;
   const elementRecord = state.elements.get(key);
   const elementsArr = elementRecord ? Object.freeze([...elementRecord.elements]) : EMPTY_ELEMENTS;
   const firstElement = elementsArr[0] ?? null;
-  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
-  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
-  const label = resolved.label || humanize(lastSegment);
+  const { resolved, label } = resolveFieldMetaAndLabel(state, segments);
   return {
     value,
     original,
@@ -647,6 +693,9 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     errors,
     validating,
     valid,
+    transforming,
+    busy: transforming || validating,
+    transformError,
     path: segments,
     ...computeFieldIdentity(formInstanceId, state.formKey, key),
     key: state.arrayElementKey(segments),
@@ -660,12 +709,14 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
 function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
   const base = buildLeafFieldStateBase(state, segments, key, formInstanceId);
   const validatingSince = state.fieldValidatingSince.get(key) ?? null;
+  const transformingSince = state.fieldTransformingSince.get(key) ?? null;
   return decorateWithDerivedProps(
     base,
     state,
     getFormMetaBase,
     key,
     validatingSince,
+    transformingSince,
     false,
     // revealedDescendantError: leaves have no descendants
     false,
@@ -688,6 +739,8 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let connected = false;
   let validating = false;
   let validatingSince = null;
+  let transforming = false;
+  let transformingSince = null;
   let updatedAt = null;
   let asyncPending = false;
   const submissionAttempts = state.submissionAttempts.value;
@@ -718,6 +771,13 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       if (leafGateOpen && since !== void 0 && (validatingSince === null || since < validatingSince))
         validatingSince = since;
     }
+    if ((state.fieldTransformCounts.get(leafKey) ?? 0) > 0) {
+      transforming = true;
+      const leafGateOpen = submissionAttempts > 0 || leafRecord?.blurredAfterInteraction === true;
+      const since = state.fieldTransformingSince.get(leafKey);
+      if (leafGateOpen && since !== void 0 && (transformingSince === null || since < transformingSince))
+        transformingSince = since;
+    }
     if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
@@ -737,11 +797,22 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     return blurredLeafSegments.some((s) => isPathPrefix(ePath, s));
   });
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
+  if ((state.fieldValidationCounts.get(key) ?? 0) > 0) {
+    validating = true;
+    const since = state.fieldValidatingSince.get(key);
+    if (since !== void 0 && (validatingSince === null || since < validatingSince))
+      validatingSince = since;
+  }
+  if ((state.fieldTransformCounts.get(key) ?? 0) > 0) {
+    transforming = true;
+    const since = state.fieldTransformingSince.get(key);
+    if (since !== void 0 && (transformingSince === null || since < transformingSince))
+      transformingSince = since;
+  }
+  const ownTransformError = state.transformErrors.get(key) ?? null;
   const gated = asyncPending && !state.firstValidationDone.value;
   const valid = !gated && errors.length === 0 && !validating;
-  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
-  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
-  const label = resolved.label || humanize(lastSegment);
+  const { resolved, label } = resolveFieldMetaAndLabel(state, segments);
   return {
     base: {
       value,
@@ -760,6 +831,12 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       errors,
       validating,
       valid,
+      transforming,
+      busy: transforming || validating,
+      // A container surfaces its OWN transform failure (a transform registered
+      // on the container path, e.g. a file normalizer) but never rolls up a
+      // descendant leaf's failure — that stays a per-field channel.
+      transformError: ownTransformError,
       path: segments,
       ...computeFieldIdentity(formInstanceId, state.formKey, key),
       key: state.arrayElementKey(segments),
@@ -770,28 +847,25 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       meta: resolved.meta
     },
     validatingSince,
+    transformingSince,
     revealedDescendantError
   };
 }
 function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
-  const { base, validatingSince, revealedDescendantError } = buildContainerFieldStateBase(
-    state,
-    segments,
-    key,
-    formInstanceId
-  );
+  const { base, validatingSince, transformingSince, revealedDescendantError } = buildContainerFieldStateBase(state, segments, key, formInstanceId);
   return decorateWithDerivedProps(
     base,
     state,
     getFormMetaBase,
     key,
     validatingSince,
+    transformingSince,
     revealedDescendantError,
     segments.length === 0,
     getDisplayState
   );
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, revealedDescendantError, isRoot, getDisplayState) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, transformingSince, revealedDescendantError, isRoot, getDisplayState) {
   const firstError = base.errors[0];
   const predicate = getDisplayState ?? state.getDisplayState;
   const formMeta = getFormMetaBase();
@@ -799,6 +873,7 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     field: base,
     formMeta,
     validatingSince,
+    transformingSince,
     // The engine's clock. Frozen to 0 under SSR (no clock, nothing in
     // flight) so the reducer returns the plain verdict and hydration matches.
     now: state.ssr ? 0 : Date.now()
@@ -865,6 +940,15 @@ function liveKeysAtPath(state, segments) {
   if (typeof value === "object") return Object.keys(value);
   return [];
 }
+function liveContainerHasKey(state, segments, key) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0 || typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    const index = Number(key);
+    return Number.isInteger(index) && index >= 0 && index < value.length && String(index) === key;
+  }
+  return Object.hasOwn(value, key);
+}
 function isArrayPath(state, segments) {
   if (segments.length === 0) return false;
   return Array.isArray(getAtPath(state.form.value, segments));
@@ -893,6 +977,21 @@ const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
 }
+function callableInvokeShim(method, surface, getDescent) {
+  const fnMethod = Reflect.get(Function.prototype, method);
+  return new Proxy((() => {
+  }), {
+    apply: (_target, _thisArg, args) => Reflect.apply(fnMethod, surface, args),
+    get: (_target, key) => Reflect.get(getDescent(), key),
+    has: (_target, key) => Reflect.has(getDescent(), key),
+    ownKeys: () => Reflect.ownKeys(getDescent()),
+    getOwnPropertyDescriptor: (_target, key) => {
+      const descriptor = Reflect.getOwnPropertyDescriptor(getDescent(), key);
+      if (descriptor !== void 0) descriptor.configurable = true;
+      return descriptor;
+    }
+  });
+}
 function buildSurfaceProxy(opts) {
   const containerCache = /* @__PURE__ */ new Map();
   const leafViewCache = /* @__PURE__ */ new Map();
@@ -919,6 +1018,8 @@ function buildSurfaceProxy(opts) {
     const cacheKey = `${JSON.stringify(segments)}+${isArrayLike ? "A" : "O"}`;
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
+    const isFixedObject = opts.schema.isFixedObjectAtPath(segments);
+    const containerHasKey = (k) => opts.containerHasOwnKey !== void 0 ? opts.containerHasOwnKey(segments, k) : opts.containerOwnKeys?.(segments).includes(k) === true;
     const snapshotContainer = () => opts.materializeContainer === void 0 ? {} : opts.materializeContainer(segments);
     const {
       toString: containerToString,
@@ -926,8 +1027,9 @@ function buildSurfaceProxy(opts) {
       toJSON: containerToJSON,
       toPrimitive: containerToPrimitive
     } = makeReadonlyCoercion(snapshotContainer);
-    const target = isArrayLike ? [] : (() => {
-    });
+    const isRoot = segments.length === 0;
+    const target = isRoot ? (() => {
+    }) : isArrayLike ? [] : {};
     const proxy = new Proxy(target, {
       apply(_, __, args) {
         const arg = args[0];
@@ -958,7 +1060,16 @@ function buildSurfaceProxy(opts) {
             return key === "toString" ? containerToString : containerValueOf;
           }
         }
-        return descendOrTerminate(childSegs);
+        if (key === "hasOwnProperty" && !schemaHasPath(childSegs)) {
+          return Object.prototype.hasOwnProperty;
+        }
+        if (isRoot && (key === "call" || key === "apply" || key === "bind")) {
+          return callableInvokeShim(key, proxy, () => descendOrTerminate(childSegs));
+        }
+        if (opts.isTerminalAt?.(childSegs) === true || isFixedObject && schemaHasPath(childSegs) || containerHasKey(key)) {
+          return descendOrTerminate(childSegs);
+        }
+        return void 0;
       },
       has(_, key) {
         if (typeof key === "symbol") return Reflect.has(target, key);
@@ -1043,15 +1154,8 @@ function buildSurfaceProxy(opts) {
       toJSON: leafToJSONHandler,
       toPrimitive: leafToPrimitive
     } = makeReadonlyCoercion(snapshotLeaf);
-    const target = (() => {
-    });
+    const target = {};
     const proxy = new Proxy(target, {
-      apply(_, __, args) {
-        const arg = args[0];
-        if (arg === void 0) return opts.resolveCallTarget(segments);
-        const { segments: argSegs } = canonicalizePath(arg);
-        return opts.resolveCallTarget(argSegs);
-      },
       get(_, key) {
         if (typeof key === "symbol") {
           if (key === Symbol.toPrimitive) return leafToPrimitive;
@@ -1061,6 +1165,9 @@ function buildSurfaceProxy(opts) {
         if (key === "toString") return leafToString;
         if (key === "valueOf") return leafValueOf;
         if (key === "toJSON") return leafToJSONHandler;
+        if (key === "hasOwnProperty" && !schemaHasPath([...segments, keyToSegment(key)])) {
+          return Object.prototype.hasOwnProperty;
+        }
         if (leafKeys.has(key)) {
           const leaf = opts.resolveLeaf(segments);
           return readLeafKey(leaf, key);
@@ -1073,8 +1180,8 @@ function buildSurfaceProxy(opts) {
         return true;
       },
       // Iteration: leaf-views expose the leaf-key set so
-      // `JSON.stringify(form.fields.email)` produces a FieldState
-      // snapshot rather than the function-target placeholder.
+      // `Object.keys(form.fields.email)` / spread enumerate the
+      // FieldState props. (`JSON.stringify` routes through `toJSON` above.)
       ownKeys: () => Array.from(leafKeys),
       getOwnPropertyDescriptor(_, key) {
         if (typeof key !== "string") return void 0;
@@ -1183,6 +1290,12 @@ function buildErrorsProxy(state) {
     // library-produced verdicts (schema + derived-blank) at unreachable
     // paths stay hidden; user-supplied errors are unconditional.
     containerOwnKeys: (segments) => errorAwareContainerKeys(state, segments),
+    // Fast path: a key the live form data holds short-circuits before the
+    // O(n) error-store scan, so iterating `form.errors.<array>` over live
+    // indices stays linear. The scan still runs for a key with no live
+    // home — a server error at a non-schema key (`form.errors.ghost`) —
+    // so it keeps surfacing while a genuinely-absent key reads undefined.
+    containerHasOwnKey: (segments, key) => liveContainerHasKey(state, segments, key) || errorAwareContainerKeys(state, segments).includes(key),
     isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
@@ -1356,6 +1469,9 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "errors",
   "validating",
   "valid",
+  "transforming",
+  "busy",
+  "transformError",
   "displayState",
   "showErrors",
   "showPending",
@@ -1458,33 +1574,41 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
     terminalCache.set(cacheKey, proxy);
     return proxy;
   }
+  const surfaceSchema = state.schema;
   return buildSurfaceProxy({
-    schema: state.schema,
+    schema: surfaceSchema,
     resolveLeaf: (path) => getFieldStateAt(path),
     leafKeys: FIELD_STATE_KEYS,
     readLeafKey: (computed, key) => computed.value[key],
     materializeContainer: (segments) => materializeFields(state, segments, snapshotFieldStateAt),
-    resolveCallTarget: (path) => fieldStateTerminalAt(path),
+    // `form.fields(path)` resolves a FieldState for any path the SCHEMA
+    // declares — a leaf, a container, an inactive discriminated-union
+    // variant key, or an out-of-bounds array index (the element schema
+    // admits any index). A path the schema doesn't have is a typo, not a
+    // field, so it reads `undefined` rather than a phantom stub. The
+    // empty path (`form.fields()`) is the root object, always valid.
+    resolveCallTarget: (path) => surfaceSchema.getSlimPrimitiveTypesAtPath(path).size > 0 ? fieldStateTerminalAt(path) : void 0,
     containerOwnKeys: (segments) => liveKeysAtPath(state, segments),
+    containerHasOwnKey: (segments, key) => liveContainerHasKey(state, segments, key),
     isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
   const liveValue = getAtPath(state.form.value, containerSegments);
-  return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
+  return walk$1(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
 }
-function walk$2(value, basePath, schema, snapshotFieldStateAt) {
+function walk$1(value, basePath, schema, snapshotFieldStateAt) {
   if (schema.isLeafAtPath(basePath)) return snapshotFieldStateAt(basePath);
   if (value === null || value === void 0) return value;
   if (typeof value !== "object") {
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((_, i) => walk$2(value[i], [...basePath, i], schema, snapshotFieldStateAt));
+    return value.map((_, i) => walk$1(value[i], [...basePath, i], schema, snapshotFieldStateAt));
   }
   const result = {};
   for (const key of Object.keys(value)) {
-    result[key] = walk$2(
+    result[key] = walk$1(
       value[key],
       [...basePath, key],
       schema,
@@ -1568,47 +1692,42 @@ function mergeDeep(target, source, path, schema) {
   if (!isPlainRecord(source)) return source;
   if (schema !== void 0) {
     const du = schema.getUnionDiscriminatorAtPath(path);
-    if (du !== void 0) {
-      const sourceRecord = source;
-      const sourceDisc = sourceRecord[du.discriminatorKey];
-      if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
-        return { [du.discriminatorKey]: sourceDisc };
-      }
-      if (sourceDisc !== void 0) {
-        const variantDefault = du.getVariantDefault(sourceDisc);
-        if (isPlainRecord(variantDefault)) {
-          const out2 = { ...variantDefault };
-          for (const key of Object.keys(sourceRecord)) {
-            if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
-            safeAssign(
-              out2,
-              key,
-              mergeDeep(
-                safeOwnRead(out2, key),
-                safeOwnRead(sourceRecord, key),
-                [...path, key],
-                schema
-              )
-            );
-          }
-          return out2;
-        }
-      }
-      return {};
+    if (du !== void 0) return mergeDuAwareKeys(source, path, schema, du);
+  }
+  return mergeObjectKeys(target, source, path, schema);
+}
+function mergeDuAwareKeys(source, path, schema, du) {
+  const sourceDisc = source[du.discriminatorKey];
+  if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
+    return { [du.discriminatorKey]: sourceDisc };
+  }
+  if (sourceDisc !== void 0) {
+    const variantDefault = du.getVariantDefault(sourceDisc);
+    if (isPlainRecord(variantDefault)) {
+      return mergeVariantKeys(source, variantDefault, path, schema, du);
     }
   }
-  const mergeTarget = target;
-  const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
+  return {};
+}
+function mergeVariantKeys(source, variantDefault, path, schema, du) {
+  const out = { ...variantDefault };
   for (const key of Object.keys(source)) {
+    if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
     safeAssign(
       out,
       key,
-      mergeDeep(
-        safeOwnRead(out, key),
-        safeOwnRead(source, key),
-        [...path, key],
-        schema
-      )
+      mergeDeep(safeOwnRead(out, key), safeOwnRead(source, key), [...path, key], schema)
+    );
+  }
+  return out;
+}
+function mergeObjectKeys(target, source, path, schema) {
+  const out = isPlainRecord(target) ? { ...target } : {};
+  for (const key of Object.keys(source)) {
+    safeAssign(
+      out,
+      key,
+      mergeDeep(safeOwnRead(out, key), safeOwnRead(source, key), [...path, key], schema)
     );
   }
   return out;
@@ -1741,7 +1860,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     if (!result.ok) return result.error;
     return stripData(composeWithDerivedBlank(result.refinement, result.segments));
   }
-  async function process(pathInput) {
+  async function parse(pathInput) {
     const result = await runImperativeValidation(pathInput, {
       cancelInFlight: false,
       commitToSchemaErrors: false
@@ -1794,6 +1913,8 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.activeSubmissions.value += 1;
         state.submitting.value = true;
         state.submitError.value = null;
+        state.clearUserErrors();
+        while (state.activeTransforms.value > 0) await state.settleTransforms();
         state.cancelFieldValidation();
         state.displayEngine.clear();
         state.activeValidations.value += 1;
@@ -1832,9 +1953,8 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.emitSubmitSuccess();
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
-          state.submitError.value = err;
+          state.submitError.value = toError(err);
         }
-        throw err;
       } finally {
         if (!validationSettled) {
           state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
@@ -1848,7 +1968,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     };
     return submitHandler;
   };
-  return { validate, validateAsync, process, handleSubmit };
+  return { validate, validateAsync, parse, handleSubmit };
 }
 function toSegments(pathInput) {
   return canonicalizePath(pathInput).segments;
@@ -1906,6 +2026,33 @@ function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
   target.element.focus({ preventScroll: true });
 }
 
+function captureUserCallSite() {
+  const raw = new Error().stack;
+  if (typeof raw !== "string") return void 0;
+  const lines = raw.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const frame = lines[i];
+    if (frame === void 0) continue;
+    if (/attaform[/-]forms?/i.test(frame)) continue;
+    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
+    const trimmed = frame.trim();
+    if (trimmed.length === 0) continue;
+    return shortenSourceFrame(trimmed);
+  }
+  return void 0;
+}
+function shortenSourceFrame(frame) {
+  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
+  if (match === null) return frame;
+  const [, urlOrPath, line] = match;
+  if (urlOrPath === void 0 || line === void 0) return frame;
+  let path = urlOrPath;
+  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
+  path = path.replace(/^_nuxt\//, "");
+  path = path.replace(/^\//, "");
+  return `(${path}:${line})`;
+}
+
 function extractSchemaFields(schema) {
   try {
     const root = schema.getDefaultAtPath([]);
@@ -1964,9 +2111,9 @@ function isLeafValue(value) {
   return true;
 }
 function isSlimPrimitiveValid(schema, store, path, value) {
-  return walk$1(schema, store, path, value);
+  return walk(schema, store, path, value);
 }
-function walk$1(schema, store, path, value) {
+function walk(schema, store, path, value) {
   if (schema.isPreprocessOrCoerceLeaf(path)) return true;
   const accepted = schema.getSlimPrimitiveTypesAtPath(path);
   const kind = isLeafValue(value) ? slimKindOf(value) : Array.isArray(value) ? "array" : "object";
@@ -1976,13 +2123,13 @@ function walk$1(schema, store, path, value) {
   }
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      if (!walk$1(schema, store, [...path, i], value[i])) return false;
+      if (!walk(schema, store, [...path, i], value[i])) return false;
     }
     return true;
   }
   if (isPlainRecord(value)) {
     for (const key of Object.keys(value)) {
-      if (!walk$1(schema, store, [...path, key], value[key])) {
+      if (!walk(schema, store, [...path, key], value[key])) {
         return false;
       }
     }
@@ -2321,6 +2468,23 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       markConnectedOptimistically: () => {
         state.markConnectedOptimistically(segments);
       },
+      // --- Async transform lifecycle (internal; the directive's
+      // deferred orchestrator is the only legitimate consumer). Thin
+      // path-bound delegates to the store's per-path token / counter
+      // machinery — same pattern as `markBlank` / `setValueWithInternalPath`,
+      // so the directive (which holds only this RegisterValue, never the
+      // store) can drive the busy/discard/error bookkeeping. ---
+      beginTransform: (holder) => state.beginTransform(pathKey, holder),
+      isCurrentTransform: (token) => state.isCurrentTransform(pathKey, token),
+      endTransform: (token) => state.endTransform(pathKey, token),
+      setTransformError: (err) => state.setTransformError(pathKey, err),
+      // Synchronous read of "is a transform in flight at this path". The
+      // orchestrator's `beginTransform` bumps the count before the
+      // listener's force-sync block runs, so the directive reads this to
+      // skip reverting the DOM to stale storage mid-flight.
+      get transforming() {
+        return (state.fieldTransformCounts.get(pathKey) ?? 0) > 0;
+      },
       path: pathKey,
       // Frozen so a wrapper component can pass `rv.segments` directly
       // to `form.fields(...)` without defensive copying — and so test
@@ -2365,49 +2529,60 @@ function walkUnsetSentinels(values, schema) {
     walkUnspecified(rootSlim, [], paths);
     return { cleanedValues: void 0, paths };
   }
-  const cleaned = walk(values, [], schema, paths);
+  const cleaned = walkCore(values, [], schema, paths, true);
   return { cleanedValues: cleaned, paths };
 }
-function walk(input, segments, schema, paths) {
+function isOpaqueLeaf(value) {
+  return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function";
+}
+function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
   if (isUnset(input)) {
     return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
-    const slim = schema.getDefaultAtPath(segments);
-    return walkUnspecified(slim, segments, paths);
-  }
-  if (input === null) return null;
-  if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
+    if (synthesizeSchemaKeys) {
+      const slim = schema.getDefaultAtPath(segments);
+      return walkUnspecified(slim, segments, paths);
+    }
     return input;
   }
+  if (input === null) return null;
+  if (isOpaqueLeaf(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 = walk(input[i], [...segments, i], schema, paths);
+      const walked = walkCore(input[i], [...segments, i], schema, paths, synthesizeSchemaKeys);
       out[i] = walked;
       if (walked !== input[i]) mutated = true;
     }
     return mutated ? out : input;
   }
   if (typeof input === "object") {
-    const slim = schema.getDefaultAtPath(segments);
-    const inputKeys = Object.keys(input);
-    const inputKeysSet = new Set(inputKeys);
-    const allKeys = new Set(inputKeys);
-    if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !(slim instanceof Date) && !(slim instanceof RegExp) && !(slim instanceof Map) && !(slim instanceof Set)) {
-      for (const k of Object.keys(slim)) allKeys.add(k);
+    const obj = input;
+    const inputKeys = Object.keys(obj);
+    let keys = inputKeys;
+    let mutated = false;
+    let inputKeysSet = null;
+    if (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)) {
+        for (const k of Object.keys(slim)) allKeys.add(k);
+      }
+      keys = allKeys;
+      mutated = allKeys.size !== inputKeys.length;
     }
     const out = {};
-    let mutated = allKeys.size !== inputKeys.length;
-    for (const key of allKeys) {
-      const orig = input[key];
-      if (orig === void 0 && inputKeysSet.has(key)) {
+    for (const key of keys) {
+      const orig = obj[key];
+      if (synthesizeSchemaKeys && orig === void 0 && inputKeysSet?.has(key) === true) {
         safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
-      const walked = walk(orig, [...segments, key], schema, paths);
+      const walked = walkCore(orig, [...segments, key], schema, paths, synthesizeSchemaKeys);
       safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
@@ -2422,7 +2597,7 @@ function walkUnspecified(slim, segments, paths) {
     }
     return slim;
   }
-  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+  if (isOpaqueLeaf(slim)) {
     return slim;
   }
   if (Array.isArray(slim)) return slim;
@@ -2441,40 +2616,9 @@ function walkUnspecified(slim, segments, paths) {
 }
 function substituteUnsetSentinels(value, prefix, schema) {
   const paths = [];
-  const cleaned = substitute(value, [...prefix], schema, paths);
+  const cleaned = walkCore(value, [...prefix], schema, paths, false);
   return { cleanedValues: cleaned, paths };
 }
-function substitute(input, segments, schema, paths) {
-  if (isUnset(input)) {
-    return expandUnsetAt(segments, schema, paths);
-  }
-  if (input === void 0 || input === null) return input;
-  if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
-    return input;
-  }
-  if (Array.isArray(input)) {
-    let mutated = false;
-    const out = new Array(input.length);
-    for (let i = 0; i < input.length; i++) {
-      const walked = substitute(input[i], [...segments, i], schema, paths);
-      out[i] = walked;
-      if (walked !== input[i]) mutated = true;
-    }
-    return mutated ? out : input;
-  }
-  if (typeof input === "object") {
-    let mutated = false;
-    const out = {};
-    for (const key of Object.keys(input)) {
-      const orig = input[key];
-      const walked = substitute(orig, [...segments, key], schema, paths);
-      safeAssign(out, key, walked);
-      if (walked !== orig) mutated = true;
-    }
-    return mutated ? out : input;
-  }
-  return input;
-}
 function isPrimitiveOrEmpty(value) {
   if (value === null || value === void 0) return true;
   const t = typeof value;
@@ -2504,7 +2648,7 @@ function expandUnsetAt(segments, schema, paths) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
-  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+  if (isOpaqueLeaf(slim)) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
@@ -2519,7 +2663,9 @@ function expandUnsetAt(segments, schema, paths) {
 function buildCallableReadonlySnapshotProxy(opts) {
   const target = (() => {
   });
-  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(opts.snapshot);
+  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(
+    opts.coercionSnapshot ?? opts.snapshot
+  );
   const callResolve = opts.resolveCall ?? ((arg) => opts.resolveKey(String(arg)));
   return new Proxy(target, {
     apply(_, __, args) {
@@ -2568,27 +2714,52 @@ function buildCallableReadonlySnapshotProxy(opts) {
   });
 }
 
+function materializeFormValue(node) {
+  if (node === null || typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    const out2 = new Array(node.length);
+    for (let i = 0; i < node.length; i++) out2[i] = materializeFormValue(node[i]);
+    return out2;
+  }
+  if (!isPlainRecord(node)) return toRaw(node);
+  const rec = node;
+  const out = {};
+  for (const key of Object.keys(rec)) {
+    safeAssign(out, key, materializeFormValue(safeOwnRead(rec, key)));
+  }
+  return out;
+}
 function buildValuesProxy(form) {
   const inner = computed(() => readonly(form.value));
   return buildCallableReadonlySnapshotProxy({
     surface: "form.values",
     snapshot: () => inner.value,
+    // Faithful, reactivity-preserving serialisation: walk the reactive
+    // proxy with own-safe reads so `JSON.stringify(form.values)` /
+    // `String(form.values)` reflect the stored data — including a field
+    // literally named `hasOwnProperty` that Vue would otherwise shim —
+    // while still tracking the per-key reads that drive re-render.
+    coercionSnapshot: () => materializeFormValue(inner.value),
     // Read through the readonly proxy at access time so Vue's
     // dependency tracking lands inside the consumer's active effect
     // — `inner.value[key]` is what triggers per-key tracking.
-    resolveKey: (key) => inner.value[key],
-    // Dynamic path: walk segments through the readonly proxy. Each
-    // step reads through the proxy's own get traps so dependency
-    // tracking propagates at every level.
-    resolveCall: (arg) => {
-      const { segments } = canonicalizePath(arg);
-      let cursor = inner.value;
-      for (const seg of segments) {
-        if (cursor === null || cursor === void 0) return void 0;
-        cursor = cursor[seg];
-      }
-      return cursor;
-    },
+    //
+    // Prototype-shadowed names (`hasOwnProperty`, `constructor`, …) read
+    // off the RAW target instead: own-shadows-inherited semantics still
+    // hold (a data field by that name returns its stored value), but
+    // when there's no such field the inherited member resolves — so
+    // `form.values.hasOwnProperty('x')` keeps working as the real
+    // method. The raw read dodges Vue's `hasOwnProperty` proxy shim,
+    // which would otherwise mask a data field of that name. (`toString`
+    // / `valueOf` / `toJSON` never reach here — the base get trap
+    // intercepts them as coercion handlers first.)
+    resolveKey: (key) => isShadowedKey(key) ? toRaw(inner.value)[key] : inner.value[key],
+    // Dynamic path: walk segments through the readonly proxy with the
+    // same own-property-safe descent the rest of the runtime uses
+    // (`getAtPath`), so `form.values('a.hasOwnProperty')` resolves the
+    // stored value. Per-level reads still propagate Vue's tracking for
+    // ordinary keys.
+    resolveCall: (arg) => getAtPath(inner.value, canonicalizePath(arg).segments),
     ownKeys: () => Reflect.ownKeys(inner.value),
     hasKey: (key) => Reflect.has(inner.value, key),
     describeKey: (key) => {
@@ -2611,6 +2782,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
+  const reMarkBlanksAfterSubstitution = (paths) => {
+    for (const pathKey of paths) {
+      const blankSegments = segmentsForPathKey(pathKey);
+      if (blankSegments === null) continue;
+      state.setValueAtPath(
+        blankSegments,
+        state.getValueAtPath(blankSegments),
+        withInstanceMeta({ blank: true })
+      );
+    }
+  };
   const getFormMetaBase = () => {
     const { base: rootBase } = buildContainerFieldStateBase(
       state,
@@ -2649,12 +2831,12 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const {
     validate: validateBuilt,
     validateAsync: validateAsyncBuilt,
-    process: processBuilt,
+    parse: parseBuilt,
     handleSubmit
   } = buildProcessForm(state, formInstanceId, processOptions);
   const validate = (pathInput) => validateBuilt(pathInput);
   const validateAsync = (pathInput) => validateAsyncBuilt(pathInput);
-  const process = (pathInput) => processBuilt(pathInput);
+  const parse = (pathInput) => parseBuilt(pathInput);
   function pathToRef(pathInput) {
     const segments = canonicalizePath(pathInput).segments;
     return computed(() => getAtPath(state.form.value, segments));
@@ -2668,15 +2850,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
       if (!ok2) return false;
-      for (const pathKey of walked2.paths) {
-        const blankSegments = segmentsForPathKey(pathKey);
-        if (blankSegments === null) continue;
-        state.setValueAtPath(
-          blankSegments,
-          state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
-        );
-      }
+      reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
     }
     const segments = canonicalizePath(pathOrValue).segments;
@@ -2731,15 +2905,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     );
     const ok = state.setValueAtPath(segments, walked.cleanedValues, withInstanceMeta());
     if (!ok) return false;
-    for (const pathKey of walked.paths) {
-      const blankSegments = segmentsForPathKey(pathKey);
-      if (blankSegments === null) continue;
-      state.setValueAtPath(
-        blankSegments,
-        state.getValueAtPath(blankSegments),
-        withInstanceMeta({ blank: true })
-      );
-    }
+    reMarkBlanksAfterSubstitution(walked.paths);
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
@@ -2882,6 +3048,21 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // keep the explicit form-level computation for the gate.
       valid,
       errors: metaErrors,
+      // Whole-form transforming mirrors the global `activeTransforms`
+      // counter ORed with any per-leaf transform in flight (the root
+      // rollup), exactly as `validating` composes its lifecycle and
+      // per-field sources. `busy` is the union of both work signals at
+      // the form level. `transformError` is leaf-only, so the root
+      // rollup reads it as `null` (kept for FieldState-shape parity).
+      transforming: computed(
+        () => state.activeTransforms.value > 0 || rootFieldState.value.transforming
+      ),
+      busy: computed(
+        () => state.activeValidations.value > 0 || state.activeTransforms.value > 0 || rootFieldState.value.validating || rootFieldState.value.transforming
+      ),
+      get transformError() {
+        return rootFieldState.value.transformError;
+      },
       // `displayState` / the `show*` booleans / `firstError` flow
       // through the same root field-state computed as the rest of the
       // FieldState surface, so `form.meta.displayState` matches
@@ -3110,7 +3291,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     setValue: gated(setValueImpl),
     validate: gated(validate),
     validateAsync: gated(validateAsync),
-    process: gated(process),
+    parse: gated(parse),
+    settleTransforms: gated(state.settleTransforms),
     register: gated(register),
     key: state.formKey,
     // Auto-unwrapping views over the per-store async-defaults lifecycle
@@ -3977,6 +4159,106 @@ function createFormStore(options) {
       fieldValidationCounts.set(key, next);
     }
   }
+  const fieldTransformCounts = reactive(/* @__PURE__ */ new Map());
+  const fieldTransformingSince = reactive(/* @__PURE__ */ new Map());
+  const transformErrors = reactive(/* @__PURE__ */ new Map());
+  const activeTransforms = ref(0);
+  const transformRuns = /* @__PURE__ */ new Map();
+  let transformTokenSeq = 0;
+  const transformWaiters = [];
+  function incFieldTransform(key) {
+    fieldTransformingSince.set(key, ssr ? 0 : Date.now());
+    fieldTransformCounts.set(key, (fieldTransformCounts.get(key) ?? 0) + 1);
+  }
+  function decFieldTransform(key) {
+    const next = (fieldTransformCounts.get(key) ?? 0) - 1;
+    if (next <= 0) {
+      fieldTransformCounts.delete(key);
+      fieldTransformingSince.delete(key);
+    } else {
+      fieldTransformCounts.set(key, next);
+    }
+  }
+  function flushSettledTransformWaiters() {
+    if (transformWaiters.length === 0) return;
+    const globalIdle = activeTransforms.value === 0;
+    for (let i = transformWaiters.length - 1; i >= 0; i--) {
+      const w = transformWaiters[i];
+      if (w === void 0) continue;
+      const idle = w.key === null ? globalIdle : (fieldTransformCounts.get(w.key) ?? 0) === 0;
+      if (idle) {
+        transformWaiters.splice(i, 1);
+        w.resolve();
+      }
+    }
+  }
+  function releaseTransformRun(key, run) {
+    if (run.released) return;
+    run.released = true;
+    run.holder.aborted = true;
+    run.holder.controller?.abort();
+    activeTransforms.value = Math.max(0, activeTransforms.value - 1);
+    decFieldTransform(key);
+  }
+  function beginTransform(key, holder) {
+    const prior = transformRuns.get(key);
+    if (prior !== void 0) releaseTransformRun(key, prior);
+    const token = ++transformTokenSeq;
+    transformRuns.set(key, { token, holder, released: false });
+    incFieldTransform(key);
+    activeTransforms.value += 1;
+    if (transformErrors.has(key)) transformErrors.delete(key);
+    return token;
+  }
+  function isCurrentTransform(key, token) {
+    return transformRuns.get(key)?.token === token;
+  }
+  function endTransform(key, token) {
+    const run = transformRuns.get(key);
+    if (run?.token === token) {
+      if (!run.released) {
+        activeTransforms.value = Math.max(0, activeTransforms.value - 1);
+        decFieldTransform(key);
+      }
+      transformRuns.delete(key);
+    }
+    flushSettledTransformWaiters();
+  }
+  function setTransformError(key, err) {
+    transformErrors.set(key, err);
+  }
+  function cancelTransforms() {
+    for (const [key, run] of [...transformRuns]) {
+      releaseTransformRun(key, run);
+      transformRuns.delete(key);
+    }
+    if (transformErrors.size > 0) transformErrors.clear();
+    flushSettledTransformWaiters();
+  }
+  function cancelTransformsUnder(prefix) {
+    for (const [key, run] of [...transformRuns]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(prefix, segs)) continue;
+      releaseTransformRun(key, run);
+      transformRuns.delete(key);
+      transformErrors.delete(key);
+    }
+    flushSettledTransformWaiters();
+  }
+  function settleTransforms(path) {
+    if (path === void 0) {
+      if (activeTransforms.value === 0) return Promise.resolve();
+      return new Promise((resolve) => {
+        transformWaiters.push({ key: null, resolve });
+      });
+    }
+    const { key } = canonicalizePath(path);
+    if ((fieldTransformCounts.get(key) ?? 0) === 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      transformWaiters.push({ key, resolve });
+    });
+  }
   const initStamp = (/* @__PURE__ */ new Date()).toISOString();
   diffAndApply({}, schemaInitialData, [], (patch) => {
     if (patch.kind !== "added") return;
@@ -4126,6 +4408,7 @@ function createFormStore(options) {
         }
       }
     }
+    if (transformRuns.size !== 0) cancelTransformsUnder(path);
     if (meta?.skipDiscriminatorReshape !== true) {
       if (path.length > 0) {
         const last = path[path.length - 1];
@@ -4460,6 +4743,7 @@ function createFormStore(options) {
     drainHooks.length = 0;
     modules.clear();
     cancelFieldValidation();
+    cancelTransforms();
     fieldValidatingSince.clear();
     formChangeListeners.clear();
     submitSuccessListeners.clear();
@@ -4596,6 +4880,7 @@ function createFormStore(options) {
     if (remaining === 0) {
       elements.delete(key);
       touchFieldRecord(key, path, { connected: false, focused: null, blurred: null });
+      if (transformRuns.size !== 0) cancelTransformsUnder(path);
     }
     return remaining;
   }
@@ -4817,6 +5102,7 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    cancelTransforms();
     displayEngine.clear();
     fieldValidatingSince.clear();
     pathSnapshots.clear();
@@ -4835,6 +5121,7 @@ function createFormStore(options) {
     const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
     variantMemory.clearUnderPath(targetSegments);
     cancelFieldValidationUnder(targetSegments);
+    cancelTransformsUnder(targetSegments);
     for (const [snapKey] of [...pathSnapshots]) {
       const segs = segmentsForPathKey(snapKey);
       if (segs === null) continue;
@@ -4970,6 +5257,10 @@ function createFormStore(options) {
     pathHasAsyncValidationByKey,
     fieldValidationCounts,
     fieldValidatingSince,
+    fieldTransformCounts,
+    fieldTransformingSince,
+    transformErrors,
+    activeTransforms,
     displayEngine,
     applyFormReplacement,
     setValueAtPath,
@@ -4999,6 +5290,13 @@ function createFormStore(options) {
     getOriginalAtPath,
     getFirstErrorElement,
     cancelFieldValidation,
+    beginTransform,
+    isCurrentTransform,
+    endTransform,
+    setTransformError,
+    cancelTransforms,
+    cancelTransformsUnder,
+    settleTransforms,
     scheduleFieldValidation,
     onFormChange,
     onSubmitSuccess,
@@ -5030,6 +5328,20 @@ function captureErrorEntries(map) {
   for (const [k, v] of map) out.push([k, [...v]]);
   return out;
 }
+function pathsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let j = 0; j < a.length; j++) {
+    if (a[j] !== b[j]) return false;
+  }
+  return true;
+}
+function errorFieldsEqual(av, bvi) {
+  if (av === bvi) return true;
+  if (av.message !== bvi.message) return false;
+  if (av.code !== bvi.code) return false;
+  if (av.formKey !== bvi.formKey) return false;
+  return av.path === bvi.path || pathsEqual(av.path, bvi.path);
+}
 function errorsEqual(a, b) {
   if (a.length !== b.length) return false;
   const bMap = /* @__PURE__ */ new Map();
@@ -5039,18 +5351,7 @@ function errorsEqual(a, b) {
     if (bv === void 0) return false;
     if (v.length !== bv.length) return false;
     for (let i = 0; i < v.length; i++) {
-      const av = v[i];
-      const bvi = bv[i];
-      if (av === bvi) continue;
-      if (av.message !== bvi.message) return false;
-      if (av.code !== bvi.code) return false;
-      if (av.formKey !== bvi.formKey) return false;
-      if (av.path !== bvi.path) {
-        if (av.path.length !== bvi.path.length) return false;
-        for (let j = 0; j < av.path.length; j++) {
-          if (av.path[j] !== bvi.path[j]) return false;
-        }
-      }
+      if (!errorFieldsEqual(v[i], bv[i])) return false;
     }
   }
   return true;
@@ -5632,6 +5933,99 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
+const warnedNoParentRV = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+let warnedOutsideSetup = false;
+function makeRegisterValueProxy(capturedRegisterValue) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "__v_isRef") return true;
+      if (prop === "value") return capturedRegisterValue.value;
+      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;
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return false;
+      return Reflect.has(v, prop);
+    },
+    ownKeys(_target) {
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return [];
+      return Reflect.ownKeys(v);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return void 0;
+      const desc = Reflect.getOwnPropertyDescriptor(v, prop);
+      if (desc !== void 0) {
+        desc.configurable = true;
+      }
+      return desc;
+    }
+  });
+}
+function useRegister() {
+  const instance = getCurrentInstance();
+  if (instance === null) {
+    warnOutsideSetup();
+    return makeRegisterValueProxy(shallowRef(void 0));
+  }
+  ensureAttaformInstalled(instance.appContext.app);
+  const capturedRegisterValue = shallowRef(void 0);
+  const refreshAndStripBridgeAttrs = () => {
+    const rawAttrs = instance.attrs;
+    if ("registerValue" in rawAttrs) {
+      capturedRegisterValue.value = rawAttrs["registerValue"];
+      delete rawAttrs["registerValue"];
+    } else {
+      const dirs = instance.vnode.dirs;
+      if (dirs !== null && dirs !== void 0) {
+        for (const dir of dirs) {
+          const marked = dir.dir?.[V_REGISTER_MARKER];
+          if (marked === true) {
+            capturedRegisterValue.value = dir.value;
+            break;
+          }
+        }
+      }
+    }
+    if ("value" in rawAttrs) delete rawAttrs["value"];
+  };
+  refreshAndStripBridgeAttrs();
+  onBeforeMount(refreshAndStripBridgeAttrs);
+  onBeforeUpdate(refreshAndStripBridgeAttrs);
+  onMounted(() => {
+    const el = instance.vnode.el;
+    if (el !== null && el !== void 0 && typeof el === "object") {
+      el[REGISTER_OWNER_MARKER] = true;
+    }
+    if (capturedRegisterValue.value === void 0) {
+      warnNoParentRV(instance);
+    }
+  });
+  return makeRegisterValueProxy(capturedRegisterValue);
+}
+function warnOutsideSetup() {
+  if (!__DEV__) return;
+  if (warnedOutsideSetup) return;
+  warnedOutsideSetup = true;
+  const frame = captureUserCallSite();
+  console.warn(
+    `[attaform] useRegister() called outside a component setup; returning an unbound RegisterValue proxy. Fix: call it inside <script setup> or a setup() function \u2014 not from an event handler or async callback.` + (frame !== void 0 ? ` ${frame}` : "")
+  );
+}
+function warnNoParentRV(instance) {
+  if (!__DEV__ || warnedNoParentRV === null) return;
+  if (warnedNoParentRV.has(instance)) return;
+  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}` : "")
+  );
+}
+
 const LAZY_BRAND = Symbol.for("attaform/wizard-lazy");
 function lazy(resolve) {
   return { [LAZY_BRAND]: true, resolve };
@@ -5641,6 +6035,8 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
+  push() {
+  },
   replace() {
   },
   read() {
@@ -5655,6 +6051,9 @@ function createWizardHistory(param) {
   if (typeof window === "undefined") return NOOP_WIZARD_HISTORY;
   const subscribers = [];
   let disposed = false;
+  function currentKey() {
+    return new URL(window.location.href).searchParams.get(param) ?? void 0;
+  }
   function buildUrl(key) {
     const url = new URL(window.location.href);
     url.searchParams.set(param, key);
@@ -5662,25 +6061,29 @@ function createWizardHistory(param) {
   }
   function handlePopstate() {
     if (disposed) return;
-    const url = new URL(window.location.href);
-    const value = url.searchParams.get(param) ?? void 0;
+    const value = currentKey();
     for (const subscriber of subscribers) subscriber(value);
   }
   window.addEventListener("popstate", handlePopstate);
-  function safeReplaceState(key) {
+  function safeWrite(key, mode) {
     try {
-      window.history.replaceState({}, "", buildUrl(key));
+      if (mode === "push") window.history.pushState({}, "", buildUrl(key));
+      else window.history.replaceState({}, "", buildUrl(key));
     } catch {
     }
   }
   return {
+    push(key) {
+      if (disposed) return;
+      if (currentKey() === key) return;
+      safeWrite(key, "push");
+    },
     replace(key) {
       if (disposed) return;
-      safeReplaceState(key);
+      safeWrite(key, "replace");
     },
     read() {
-      const url = new URL(window.location.href);
-      return url.searchParams.get(param) ?? void 0;
+      return currentKey();
     },
     subscribe(callback) {
       if (disposed) return;
@@ -5718,6 +6121,7 @@ function buildNoopWizardSchema(formKey) {
     getEmptyValueAtPath: () => void 0,
     isPreprocessOrCoerceLeaf: () => false,
     arrayShapeAtPath: () => void 0,
+    isFixedObjectAtPath: (path) => path.length === 0,
     getSchemasAtPath: () => [],
     validateAtPath: () => success,
     getSlimPrimitiveTypesAtPath: () => new Set(EMPTY_SLIM_KINDS),
@@ -6171,7 +6575,10 @@ function useWizard(options) {
   };
   const persistCallback = options.persist === false ? void 0 : options.persist !== void 0 ? options.persist : (state) => {
     if (state.step === void 0) return;
-    historyHandle.replace(state.step);
+    const current = historyHandle.read();
+    const effectiveCurrent = current !== void 0 && isCompiledKey(current) ? current : firstKey();
+    if (state.step === effectiveCurrent) historyHandle.replace(state.step);
+    else historyHandle.push(state.step);
   };
   function isCompiledKey(key) {
     const list = compiledSteps.value;
@@ -6252,6 +6659,7 @@ function useWizard(options) {
   }
   const submitting = ref(false);
   const submissionAttempts = ref(0);
+  const submitError = ref(null);
   const done = ref(false);
   function activateForm(form) {
     const source = asSubmissionSource(form);
@@ -6379,7 +6787,7 @@ function useWizard(options) {
         formKey: form.key
       };
     }
-    return full.process();
+    return full.parse();
   }
   function collectErrors(results) {
     const out = [];
@@ -6410,6 +6818,7 @@ function useWizard(options) {
         return;
       }
       submitting.value = true;
+      submitError.value = null;
       try {
         const currentKey = activeKey.value;
         const final = isFinalStep.value;
@@ -6418,12 +6827,14 @@ function useWizard(options) {
         if (final) {
           await Promise.all(
             list.map(async (step) => {
+              registry.forms.get(step.key)?.clearUserErrors();
               const result = await processOne(step.form);
               results.set(step.key, result);
             })
           );
         } else {
           const active = activeForm.value;
+          registry.forms.get(active.key)?.clearUserErrors();
           const result = await processOne(active);
           results.set(active.key, result);
         }
@@ -6458,7 +6869,6 @@ function useWizard(options) {
             if (target !== void 0) moveTo(target.key);
           }
         } else {
-          if (onError !== void 0) await onError(errors);
           if (options.focusFirstError !== false) {
             const firstFailedKey = errors[0]?.formKey;
             if (firstFailedKey !== void 0 && isCompiledKey(firstFailedKey)) {
@@ -6473,7 +6883,16 @@ function useWizard(options) {
               }
             }
           }
+          if (onError !== void 0) {
+            try {
+              await onError(errors);
+            } catch (cause) {
+              throw new SubmitErrorHandlerError("User-provided onError threw", { cause });
+            }
+          }
         }
+      } catch (err) {
+        submitError.value = toError(err);
       } finally {
         submitting.value = false;
       }
@@ -6482,6 +6901,7 @@ function useWizard(options) {
   function reset() {
     submissionAttempts.value = 0;
     done.value = false;
+    submitError.value = null;
     lazyEpoch.value += 1;
     for (const step of compiledSteps.value) {
       const full = asSubmissionSource(step.form);
@@ -6557,6 +6977,9 @@ function useWizard(options) {
     get submissionAttempts() {
       return submissionAttempts.value;
     },
+    get submitError() {
+      return submitError.value;
+    },
     get visited() {
       return visited.value;
     }
@@ -6666,5 +7089,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, useAbstractForm as B, useWizard as C, DEFAULT_PERSISTENCE_DEBOUNCE_MS as D, PERSISTENCE_MODULE_KEY as P, DEFAULT_TIMINGS as a, applyPatchesForward as b, cleanupOrphanKeys as c, defaultCoercionRules as d, defaultDisplayState as e, defineCoercion as f, deleteAtPath as g, diffAndApply as h, getAtPath as i, humanize as j, injectForm as k, injectWizard as l, isPlainRecord as m, isUnset as n, lazy as o, makeDefaultDisplayState as p, mergeSparseHydration as q, normalizeNumericOption as r, normalizePersistConfig as s, resolveStorageKeyBase as t, safeAssign as u, safeOwnRead as v, setAtPath as w, slimKindOf as x, structuralSnapshot as y, unset as z };
-//# sourceMappingURL=attaform.DSqO6Db7.mjs.map
+export { AttaformErrorCode as A, deleteAtPath as B, safeOwnRead as C, DEFAULT_TIMINGS as D, humanize as E, PERSISTENCE_MODULE_KEY as P, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, isPlainRecord as e, safeAssign as f, diffAndApply as g, slimKindOf as h, injectForm as i, applyPatchesForward as j, normalizeNumericOption as k, lazy as l, defaultCoercionRules as m, normalizePersistConfig as n, defaultDisplayState as o, defineCoercion as p, makeDefaultDisplayState as q, useAbstractForm as r, structuralSnapshot as s, getAtPath as t, unset as u, setAtPath as v, resolveStorageKeyBase as w, DEFAULT_PERSISTENCE_DEBOUNCE_MS as x, cleanupOrphanKeys as y, mergeSparseHydration as z };
+//# sourceMappingURL=attaform.CTheKoTc.mjs.map