attaform 0.21.0 → 0.21.2

package/dist/shared/{attaform.BUszFoKq.cjs → attaform.D2ZuIOCf.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.BA3vRDos.cjs');
+const paths = require('./attaform.B5LNzqQh.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -15,10 +15,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];
 }
@@ -37,6 +41,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];
 }
@@ -66,6 +74,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) {
@@ -153,68 +162,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;
@@ -297,55 +318,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 });
@@ -369,6 +362,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);
@@ -472,7 +506,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) {
@@ -482,10 +521,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)
@@ -496,8 +536,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 };
   };
@@ -610,6 +650,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);
@@ -623,15 +669,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,
@@ -649,6 +695,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),
@@ -662,12 +711,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,
@@ -690,6 +741,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;
@@ -720,6 +773,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) {
@@ -739,11 +799,22 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     return blurredLeafSegments.some((s) => paths.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,
@@ -762,6 +833,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),
@@ -772,28 +849,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();
@@ -801,6 +875,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()
@@ -867,6 +942,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));
@@ -895,6 +979,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();
@@ -921,6 +1020,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,
@@ -928,8 +1029,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];
@@ -960,7 +1062,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);
@@ -1045,15 +1156,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 } = paths.canonicalizePath(arg);
-        return opts.resolveCallTarget(argSegs);
-      },
       get(_, key) {
         if (typeof key === "symbol") {
           if (key === Symbol.toPrimitive) return leafToPrimitive;
@@ -1063,6 +1167,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);
@@ -1075,8 +1182,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;
@@ -1185,6 +1292,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)
   });
 }
@@ -1358,6 +1471,9 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "errors",
   "validating",
   "valid",
+  "transforming",
+  "busy",
+  "transformError",
   "displayState",
   "showErrors",
   "showPending",
@@ -1460,33 +1576,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,
@@ -1570,47 +1694,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;
@@ -1743,7 +1862,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
@@ -1796,6 +1915,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;
@@ -1834,9 +1955,8 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.emitSubmitSuccess();
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
-          state.submitError.value = err;
+          state.submitError.value = paths.toError(err);
         }
-        throw err;
       } finally {
         if (!validationSettled) {
           state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
@@ -1850,7 +1970,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     };
     return submitHandler;
   };
-  return { validate, validateAsync, process, handleSubmit };
+  return { validate, validateAsync, parse, handleSubmit };
 }
 function toSegments(pathInput) {
   return paths.canonicalizePath(pathInput).segments;
@@ -1908,6 +2028,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([]);
@@ -1966,9 +2113,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";
@@ -1978,13 +2125,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;
       }
     }
@@ -2272,7 +2419,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       throw new paths.AnonPersistError({
         cause: "register-without-config",
         schemaFields: extractSchemaFields(state.schema),
-        callSite: paths.captureUserCallSite()
+        callSite: captureUserCallSite()
       });
     }
     const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
@@ -2323,6 +2470,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
@@ -2367,49 +2531,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;
     }
@@ -2424,7 +2599,7 @@ function walkUnspecified(slim, segments, paths$1) {
     }
     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;
@@ -2443,40 +2618,9 @@ function walkUnspecified(slim, segments, paths$1) {
 }
 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;
@@ -2506,7 +2650,7 @@ function expandUnsetAt(segments, schema, paths$1) {
     paths$1.push(paths.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$1.push(paths.canonicalizePath(segments).key);
     return slim;
   }
@@ -2521,7 +2665,9 @@ function expandUnsetAt(segments, schema, paths$1) {
 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) {
@@ -2570,27 +2716,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 vue.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 = vue.computed(() => vue.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 } = paths.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) ? vue.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, paths.canonicalizePath(arg).segments),
     ownKeys: () => Reflect.ownKeys(inner.value),
     hasKey: (key) => Reflect.has(inner.value, key),
     describeKey: (key) => {
@@ -2613,6 +2784,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
+  const reMarkBlanksAfterSubstitution = (paths$1) => {
+    for (const pathKey of paths$1) {
+      const blankSegments = paths.segmentsForPathKey(pathKey);
+      if (blankSegments === null) continue;
+      state.setValueAtPath(
+        blankSegments,
+        state.getValueAtPath(blankSegments),
+        withInstanceMeta({ blank: true })
+      );
+    }
+  };
   const getFormMetaBase = () => {
     const { base: rootBase } = buildContainerFieldStateBase(
       state,
@@ -2651,12 +2833,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 = paths.canonicalizePath(pathInput).segments;
     return vue.computed(() => getAtPath(state.form.value, segments));
@@ -2670,15 +2852,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 = paths.segmentsForPathKey(pathKey);
-        if (blankSegments === null) continue;
-        state.setValueAtPath(
-          blankSegments,
-          state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
-        );
-      }
+      reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
     }
     const segments = paths.canonicalizePath(pathOrValue).segments;
@@ -2733,15 +2907,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 = paths.segmentsForPathKey(pathKey);
-      if (blankSegments === null) continue;
-      state.setValueAtPath(
-        blankSegments,
-        state.getValueAtPath(blankSegments),
-        withInstanceMeta({ blank: true })
-      );
-    }
+    reMarkBlanksAfterSubstitution(walked.paths);
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
@@ -2884,6 +3050,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: vue.computed(
+        () => state.activeTransforms.value > 0 || rootFieldState.value.transforming
+      ),
+      busy: vue.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
@@ -3112,7 +3293,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
@@ -3979,6 +4161,106 @@ function createFormStore(options) {
       fieldValidationCounts.set(key, next);
     }
   }
+  const fieldTransformCounts = vue.reactive(/* @__PURE__ */ new Map());
+  const fieldTransformingSince = vue.reactive(/* @__PURE__ */ new Map());
+  const transformErrors = vue.reactive(/* @__PURE__ */ new Map());
+  const activeTransforms = vue.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 = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.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 } = paths.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;
@@ -4128,6 +4410,7 @@ function createFormStore(options) {
         }
       }
     }
+    if (transformRuns.size !== 0) cancelTransformsUnder(path);
     if (meta?.skipDiscriminatorReshape !== true) {
       if (path.length > 0) {
         const last = path[path.length - 1];
@@ -4462,6 +4745,7 @@ function createFormStore(options) {
     drainHooks.length = 0;
     modules.clear();
     cancelFieldValidation();
+    cancelTransforms();
     fieldValidatingSince.clear();
     formChangeListeners.clear();
     submitSuccessListeners.clear();
@@ -4598,6 +4882,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;
   }
@@ -4819,6 +5104,7 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    cancelTransforms();
     displayEngine.clear();
     fieldValidatingSince.clear();
     pathSnapshots.clear();
@@ -4837,6 +5123,7 @@ function createFormStore(options) {
     const { key: targetKey, segments: targetSegments } = paths.canonicalizePath(path);
     variantMemory.clearUnderPath(targetSegments);
     cancelFieldValidationUnder(targetSegments);
+    cancelTransformsUnder(targetSegments);
     for (const [snapKey] of [...pathSnapshots]) {
       const segs = paths.segmentsForPathKey(snapKey);
       if (segs === null) continue;
@@ -4972,6 +5259,10 @@ function createFormStore(options) {
     pathHasAsyncValidationByKey,
     fieldValidationCounts,
     fieldValidatingSince,
+    fieldTransformCounts,
+    fieldTransformingSince,
+    transformErrors,
+    activeTransforms,
     displayEngine,
     applyFormReplacement,
     setValueAtPath,
@@ -5001,6 +5292,13 @@ function createFormStore(options) {
     getOriginalAtPath,
     getFirstErrorElement,
     cancelFieldValidation,
+    beginTransform,
+    isCurrentTransform,
+    endTransform,
+    setTransformError,
+    cancelTransforms,
+    cancelTransformsUnder,
+    settleTransforms,
     scheduleFieldValidation,
     onFormChange,
     onSubmitSuccess,
@@ -5032,6 +5330,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();
@@ -5041,18 +5353,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;
@@ -5266,7 +5567,7 @@ function useAbstractForm(configuration, options) {
     throw new paths.AnonPersistError({
       cause: "no-key",
       schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: paths.captureUserCallSite()
+      callSite: captureUserCallSite()
     });
   }
   const existing = registry.forms.get(key);
@@ -5515,7 +5816,7 @@ function recordAmbientProvide(ssr) {
   if (instance === null) return;
   const instanceKey = instance;
   const entry = {
-    source: paths.captureUserCallSite()
+    source: captureUserCallSite()
   };
   const existing = ambientProvideHistory.get(instanceKey);
   if (existing === void 0) {
@@ -5554,7 +5855,7 @@ function enforceAnonPersistRule(formKey, ssr) {
   if (paths.__DEV__)
     throw new paths.AnonPersistError({
       cause: "no-key",
-      callSite: paths.captureUserCallSite()
+      callSite: captureUserCallSite()
     });
   if (!ssr && !warnedAnonPersistKeys.has(formKey)) {
     warnedAnonPersistKeys.add(formKey);
@@ -5611,7 +5912,7 @@ function resolveState(key, registry) {
 }
 function warnMiss$1(detail, ssr) {
   if (!paths.__DEV__ || ssr) return;
-  const frame = paths.captureUserCallSite();
+  const frame = captureUserCallSite();
   console.warn(
     `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
   );
@@ -5634,6 +5935,99 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
+const warnedNoParentRV = paths.__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 = vue.getCurrentInstance();
+  if (instance === null) {
+    warnOutsideSetup();
+    return makeRegisterValueProxy(vue.shallowRef(void 0));
+  }
+  paths.ensureAttaformInstalled(instance.appContext.app);
+  const capturedRegisterValue = vue.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?.[paths.V_REGISTER_MARKER];
+          if (marked === true) {
+            capturedRegisterValue.value = dir.value;
+            break;
+          }
+        }
+      }
+    }
+    if ("value" in rawAttrs) delete rawAttrs["value"];
+  };
+  refreshAndStripBridgeAttrs();
+  vue.onBeforeMount(refreshAndStripBridgeAttrs);
+  vue.onBeforeUpdate(refreshAndStripBridgeAttrs);
+  vue.onMounted(() => {
+    const el = instance.vnode.el;
+    if (el !== null && el !== void 0 && typeof el === "object") {
+      el[paths.REGISTER_OWNER_MARKER] = true;
+    }
+    if (capturedRegisterValue.value === void 0) {
+      warnNoParentRV(instance);
+    }
+  });
+  return makeRegisterValueProxy(capturedRegisterValue);
+}
+function warnOutsideSetup() {
+  if (!paths.__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 (!paths.__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 };
@@ -5643,6 +6037,8 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
+  push() {
+  },
   replace() {
   },
   read() {
@@ -5657,6 +6053,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);
@@ -5664,25 +6063,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;
@@ -5720,6 +6123,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),
@@ -6173,7 +6577,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;
@@ -6254,6 +6661,7 @@ function useWizard(options) {
   }
   const submitting = vue.ref(false);
   const submissionAttempts = vue.ref(0);
+  const submitError = vue.ref(null);
   const done = vue.ref(false);
   function activateForm(form) {
     const source = asSubmissionSource(form);
@@ -6381,7 +6789,7 @@ function useWizard(options) {
         formKey: form.key
       };
     }
-    return full.process();
+    return full.parse();
   }
   function collectErrors(results) {
     const out = [];
@@ -6412,6 +6820,7 @@ function useWizard(options) {
         return;
       }
       submitting.value = true;
+      submitError.value = null;
       try {
         const currentKey = activeKey.value;
         const final = isFinalStep.value;
@@ -6420,12 +6829,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);
         }
@@ -6460,7 +6871,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)) {
@@ -6475,7 +6885,16 @@ function useWizard(options) {
               }
             }
           }
+          if (onError !== void 0) {
+            try {
+              await onError(errors);
+            } catch (cause) {
+              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+            }
+          }
         }
+      } catch (err) {
+        submitError.value = paths.toError(err);
       } finally {
         submitting.value = false;
       }
@@ -6484,6 +6903,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);
@@ -6559,6 +6979,9 @@ function useWizard(options) {
     get submissionAttempts() {
       return submissionAttempts.value;
     },
+    get submitError() {
+      return submitError.value;
+    },
     get visited() {
       return visited.value;
     }
@@ -6589,7 +7012,7 @@ function recordAmbientWizardProvide(ssr) {
   if (instance === null) return;
   const instanceKey = instance;
   const entry = {
-    source: paths.captureUserCallSite()
+    source: captureUserCallSite()
   };
   const existing = ambientWizardProvideHistory.get(instanceKey);
   if (existing === void 0) {
@@ -6644,7 +7067,7 @@ function availableKeysHint(wizards) {
 }
 function warnMiss(detail, ssr, hint) {
   if (!paths.__DEV__ || ssr) return;
-  const frame = paths.captureUserCallSite();
+  const frame = captureUserCallSite();
   const parts = [`[attaform] injectWizard: ${detail}. Returning null.`];
   if (hint !== void 0) parts.push(hint);
   if (frame !== void 0) parts.push(frame);
@@ -6698,5 +7121,6 @@ exports.slimKindOf = slimKindOf;
 exports.structuralSnapshot = structuralSnapshot;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
+exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.BUszFoKq.cjs.map
+//# sourceMappingURL=attaform.D2ZuIOCf.cjs.map