attaform 0.21.0 → 0.21.1

package/dist/shared/{attaform.DSqO6Db7.mjs → attaform.DR6RmxWZ.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, 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, H as toError, 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, K as useRegistry, z as kFormContext, B as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.pmtahXKy.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) {
@@ -470,7 +479,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 +494,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 +509,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 };
   };
@@ -621,6 +636,8 @@ 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;
@@ -647,6 +664,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 +680,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 +710,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 +742,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,6 +768,19 @@ 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;
@@ -760,6 +804,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 +820,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 +846,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 +913,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 +950,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 +991,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 +1000,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 +1033,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 +1127,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 +1138,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 +1153,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 +1263,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 +1442,9 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "errors",
   "validating",
   "valid",
+  "transforming",
+  "busy",
+  "transformError",
   "displayState",
   "showErrors",
   "showPending",
@@ -1458,14 +1547,22 @@ 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)
   });
 }
@@ -1741,7 +1838,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 +1891,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 +1931,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 +1946,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;
@@ -2321,6 +2419,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
@@ -2519,7 +2634,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 +2685,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) => {
@@ -2649,12 +2791,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));
@@ -2882,6 +3024,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 +3267,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 +4135,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 +4384,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 +4719,7 @@ function createFormStore(options) {
     drainHooks.length = 0;
     modules.clear();
     cancelFieldValidation();
+    cancelTransforms();
     fieldValidatingSince.clear();
     formChangeListeners.clear();
     submitSuccessListeners.clear();
@@ -4596,6 +4856,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 +5078,7 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    cancelTransforms();
     displayEngine.clear();
     fieldValidatingSince.clear();
     pathSnapshots.clear();
@@ -4835,6 +5097,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 +5233,10 @@ function createFormStore(options) {
     pathHasAsyncValidationByKey,
     fieldValidationCounts,
     fieldValidatingSince,
+    fieldTransformCounts,
+    fieldTransformingSince,
+    transformErrors,
+    activeTransforms,
     displayEngine,
     applyFormReplacement,
     setValueAtPath,
@@ -4999,6 +5266,13 @@ function createFormStore(options) {
     getOriginalAtPath,
     getFirstErrorElement,
     cancelFieldValidation,
+    beginTransform,
+    isCurrentTransform,
+    endTransform,
+    setTransformError,
+    cancelTransforms,
+    cancelTransformsUnder,
+    settleTransforms,
     scheduleFieldValidation,
     onFormChange,
     onSubmitSuccess,
@@ -5641,6 +5915,8 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
+  push() {
+  },
   replace() {
   },
   read() {
@@ -5655,6 +5931,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 +5941,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 +6001,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 +6455,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 +6539,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 +6667,7 @@ function useWizard(options) {
         formKey: form.key
       };
     }
-    return full.process();
+    return full.parse();
   }
   function collectErrors(results) {
     const out = [];
@@ -6410,6 +6698,7 @@ function useWizard(options) {
         return;
       }
       submitting.value = true;
+      submitError.value = null;
       try {
         const currentKey = activeKey.value;
         const final = isFinalStep.value;
@@ -6418,12 +6707,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 +6749,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 +6763,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 +6781,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 +6857,9 @@ function useWizard(options) {
     get submissionAttempts() {
       return submissionAttempts.value;
     },
+    get submitError() {
+      return submitError.value;
+    },
     get visited() {
       return visited.value;
     }
@@ -6667,4 +6970,4 @@ 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
+//# sourceMappingURL=attaform.DR6RmxWZ.mjs.map