attaform 0.23.0 → 0.24.1

package/dist/shared/{attaform.DsQkXE3o.cjs → attaform.DRQjF16I.cjs}

@@ -1,7 +1,8 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.Db4E4IW6.cjs');
+const paths = require('./attaform.B7UdTs_o.cjs');
+const registerProtocol = require('./attaform.CjdepGnw.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -542,6 +543,58 @@ function structuralSnapshot(value) {
   return out;
 }
 
+const AttaformErrorCode = {
+  /** A required field is in the blank set — user hasn't supplied a value. */
+  NoValueSupplied: "atta:no-value-supplied",
+  /** The schema adapter's `validateAtPath` threw synchronously. */
+  AdapterThrew: "atta:adapter-threw",
+  /**
+   * User code inside a `z.preprocess`, `.refine`, or `.transform`
+   * threw (sync or async). The adapter caught the throw and surfaced
+   * it as a `ValidationError` at the field path so the form's normal
+   * error pipeline handles it instead of leaking as an unhandled
+   * rejection or routing through `submitError`.
+   */
+  ValidatorThrew: "atta:validator-threw",
+  /**
+   * A function-form `defaultValues` factory threw or its promise
+   * rejected. The runtime captures the raw error on `form.hydrateError`
+   * and ALSO surfaces a form-level `ValidationError` (path `[]`) so
+   * the standard error pipeline carries the signal. Critical for the
+   * SSR round-trip: `hydrateError` itself does not ride the wire
+   * payload, but `schemaErrors` does, so the client sees the failure
+   * after rehydration without an extra channel.
+   */
+  HydrationFailed: "atta:hydration-failed",
+  /** The supplied path didn't resolve to any node in the schema. */
+  PathNotFound: "atta:path-not-found",
+  /**
+   * A walked form's `activate()` (async `defaultValues` factory) threw
+   * during `wizard.handleSubmit`'s path walk. Surfaced as a synthetic
+   * `ValidationError` at the form-level path (`[]`) so the wizard's
+   * aggregate error pipeline can carry the failure alongside ordinary
+   * validation errors. The raw factory error remains on
+   * `form.hydrateError` for retry UX.
+   */
+  ActivationFailed: "atta:activation-failed",
+  /**
+   * Default code stamped on a manual error set through `form.setErrors`
+   * when the caller omits an explicit `code`. The `setErrors` input is
+   * lenient (`code` optional), so this is the fallback that keeps every
+   * produced `ValidationError` carrying a stable, branchable identifier.
+   * Override it per error by passing your own `code` (`api:…`, `auth:…`).
+   */
+  UserError: "atta:user-error"
+};
+function makeBlankRequiredError(segments, formKey) {
+  return {
+    message: "No value supplied",
+    path: [...segments],
+    formKey,
+    code: AttaformErrorCode.NoValueSupplied
+  };
+}
+
 function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
 }
@@ -597,50 +650,6 @@ function resolveGetDisplayState(config) {
   return config ?? defaultDisplayState;
 }
 
-const AttaformErrorCode = {
-  /** A required field is in the blank set — user hasn't supplied a value. */
-  NoValueSupplied: "atta:no-value-supplied",
-  /** The schema adapter's `validateAtPath` threw synchronously. */
-  AdapterThrew: "atta:adapter-threw",
-  /**
-   * User code inside a `z.preprocess`, `.refine`, or `.transform`
-   * threw (sync or async). The adapter caught the throw and surfaced
-   * it as a `ValidationError` at the field path so the form's normal
-   * error pipeline handles it instead of leaking as an unhandled
-   * rejection or routing through `submitError`.
-   */
-  ValidatorThrew: "atta:validator-threw",
-  /**
-   * A function-form `defaultValues` factory threw or its promise
-   * rejected. The runtime captures the raw error on `form.hydrateError`
-   * and ALSO surfaces a form-level `ValidationError` (path `[]`) so
-   * the standard error pipeline carries the signal. Critical for the
-   * SSR round-trip: `hydrateError` itself does not ride the wire
-   * payload, but `schemaErrors` does, so the client sees the failure
-   * after rehydration without an extra channel.
-   */
-  HydrationFailed: "atta:hydration-failed",
-  /** The supplied path didn't resolve to any node in the schema. */
-  PathNotFound: "atta:path-not-found",
-  /**
-   * A walked form's `activate()` (async `defaultValues` factory) threw
-   * during `wizard.handleSubmit`'s path walk. Surfaced as a synthetic
-   * `ValidationError` at the form-level path (`[]`) so the wizard's
-   * aggregate error pipeline can carry the failure alongside ordinary
-   * validation errors. The raw factory error remains on
-   * `form.hydrateError` for retry UX.
-   */
-  ActivationFailed: "atta:activation-failed"
-};
-function makeBlankRequiredError(segments, formKey) {
-  return {
-    message: "No value supplied",
-    path: [...segments],
-    formKey,
-    code: AttaformErrorCode.NoValueSupplied
-  };
-}
-
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
 const RESERVED_KEY_PREFIX = "__atta:";
@@ -1033,7 +1042,7 @@ function aggregateErrorsAt(state, prefix) {
       const segs = paths.segmentsForPathKey(pathKey);
       if (segs === null) continue;
       if (!paths.isPathPrefix(prefix, segs)) continue;
-      if (pathKey === paths.FORM_ERRORS_PATH_KEY) ; else if (segs.length > 0 && !hasAtPath(formValue, segs)) continue;
+      if (segs.length > 0 && !hasAtPath(formValue, segs)) continue;
       const ordinal = state.ensurePathOrdinal(pathKey);
       const existing = buckets.get(ordinal);
       if (existing === void 0) buckets.set(ordinal, [...list]);
@@ -1152,7 +1161,12 @@ function buildSurfaceProxy(opts) {
     const proxy = new Proxy(target, {
       apply(_, __, args) {
         const arg = args[0];
-        if (arg === void 0) return opts.resolveCallTarget(segments);
+        if (arg === void 0) {
+          if (segments.length === 0 && opts.resolveRootCall !== void 0) {
+            return opts.resolveRootCall();
+          }
+          return opts.resolveCallTarget(segments);
+        }
         const { segments: argSegs } = paths.canonicalizePath(arg);
         return opts.resolveCallTarget(argSegs);
       },
@@ -1363,8 +1377,7 @@ function buildErrorsProxy(state) {
         return merged;
       }
       const { key } = paths.canonicalizePath(path);
-      const isFormLevel = key === paths.FORM_ERRORS_PATH_KEY;
-      const active = isFormLevel || hasAtPath(state.form.value, path);
+      const active = hasAtPath(state.form.value, path);
       collectAtKey(key, active, merged);
       return merged;
     },
@@ -1372,37 +1385,42 @@ function buildErrorsProxy(state) {
     // undefined) IS the terminal.
     materializeContainer: (segments) => materializeErrors(state, segments),
     // Any path ending in `''` is a meaningful terminal at the proxy
-    // layer: at root it's the form-level bucket; at depth >= 1 it's
-    // the container-self sentinel that surfaces cross-field refines
-    // and container-targeted marks. `resolveLeaf` translates `[...,
-    // '']` lookups to the parent container path before querying the
-    // stores. When a schema legitimately owns a `''` field, the
-    // literal leaf and any container-self errors share the slot
-    // (errors concatenate) — vanishingly rare, accepted as the
-    // ergonomic cost of one unified sentinel convention at every
-    // depth.
+    // layer. A bare `['']` is the literal root `''` field; at depth
+    // >= 1 a trailing `''` is the container-self sentinel that surfaces
+    // cross-field refines and container-targeted marks (`resolveLeaf`
+    // translates `[..., '']` to the parent container path before
+    // querying the stores). When a schema legitimately owns a `''`
+    // field, the literal leaf and any container-self errors share the
+    // slot (errors concatenate) — vanishingly rare, accepted as the
+    // ergonomic cost of one unified sentinel convention at depth >= 1.
     isTerminalAt: (segs) => segs.length >= 1 && segs[segs.length - 1] === "",
     // Call-form aggregates: `form.errors(path)` returns a single
-    // `ValidationError[]` for any depth (leaf or container) — same
+    // `ValidationError[]` for any depth (leaf or container) via the
     // shared `aggregateErrorsAt` helper that `form.meta.errors` and
-    // `form.fields(path).errors` use, so the three surfaces never
-    // drift. Empty results return `undefined`, matching the leaf
-    // proxy's pre-existing semantic (`form.errors.email === undefined`
-    // when valid) so consumer code that branches on truthiness keeps
-    // working — the call-form just extends that semantic to
-    // containers and dynamic paths.
-    resolveCallTarget: (path) => aggregateErrorsAt(state, path),
+    // `form.fields(path).errors` also use, so the surfaces never drift.
+    //
+    // The root is the one carve-out. An EXPLICIT root path
+    // (`errors([])`) returns ONLY the global `[]` bucket (root
+    // `.refine()`, hydration failures, `setErrors`) via
+    // `getErrorsForPath`, giving consumers a dedicated channel for
+    // global messages undiluted by field errors. The no-arg `errors()`
+    // instead resolves the FULL aggregate through `resolveRootCall`
+    // below (identical to `meta.errors`).
+    resolveCallTarget: (path) => path.length === 0 ? state.getErrorsForPath([]) : aggregateErrorsAt(state, path),
+    // No-arg `errors()` = the whole-form aggregate, matching
+    // `meta.errors`. Distinct from `errors([])` (global bucket only);
+    // see `resolveCallTarget`.
+    resolveRootCall: () => aggregateErrorsAt(state, []),
     // Enumeration unions the live form-data keys at this path with the
     // first-child segments drawn from every error store. Without the
     // union, `Object.keys(form.errors)` / `{...form.errors}` /
-    // `v-for="(errs, k) in form.errors"` silently dropped two
-    // important error classes that the dot / call / JSON.stringify
-    // surfaces already exposed:
-    //
-    //   - **Form-level** errors at the synthetic `['']` path (set via
-    //     `setFormErrors` or root cross-field refines).
-    //   - **Server-only** errors at a key the schema doesn't know
-    //     about (`['ghost']`, `['address', 'ghost']`).
+    // `v-for="(errs, k) in form.errors"` would silently drop
+    // **server-only** errors at a key the schema doesn't know about
+    // (`['ghost']`, `['address', 'ghost']`) that the dot / call /
+    // JSON.stringify surfaces already expose. Global errors at the root
+    // `[]` are NOT a child key and never enumerate here (read them via
+    // `errors([])` / `meta.errors`); a literal `''` field enumerates
+    // under the key `''` like any other field.
     //
     // The union closes that gap so `ownKeys` agrees with the rest of
     // the surface. Active-path filter mirrors `resolveLeaf`:
@@ -1424,10 +1442,6 @@ function errorAwareContainerKeys(state, segments) {
   const walk = (store, applyActivePathFilter) => {
     for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
-      if (pathKey === paths.FORM_ERRORS_PATH_KEY) {
-        if (segments.length === 0) keys.add("");
-        continue;
-      }
       const decoded = paths.segmentsForPathKey(pathKey);
       if (decoded === null) continue;
       if (decoded.length <= segments.length) continue;
@@ -1450,31 +1464,25 @@ function materializeErrors(state, containerSegments) {
       if (errors.length === 0) continue;
       const fullPath = paths.segmentsForPathKey(pathKey);
       if (fullPath === null) continue;
-      const isSyntheticFormLevel = fullPath.length === 1 && fullPath[0] === "";
-      if (!isSyntheticFormLevel) {
-        if (fullPath.length < containerSegments.length) continue;
-        for (let i = 0; i < containerSegments.length; i++) {
-          if (fullPath[i] !== containerSegments[i]) continue entries;
-        }
-      } else if (containerSegments.length !== 0) {
+      if (fullPath.length === 0) {
+        if (containerSegments.length === 0) placeAt(tree, [paths.ROOT_PATH_KEY], errors);
         continue;
       }
-      if (applyActivePathFilter && !isSyntheticFormLevel && !hasAtPath(state.form.value, fullPath))
-        continue;
+      if (fullPath.length < containerSegments.length) continue;
+      for (let i = 0; i < containerSegments.length; i++) {
+        if (fullPath[i] !== containerSegments[i]) continue entries;
+      }
+      if (applyActivePathFilter && !hasAtPath(state.form.value, fullPath)) continue;
+      const relativePath = fullPath.slice(containerSegments.length);
       let placePath;
-      if (isSyntheticFormLevel) {
+      if (relativePath.length === 0) {
         placePath = [""];
+      } else if (state.schema.isLeafAtPath(fullPath)) {
+        placePath = relativePath;
+      } else if (state.schema.getSlimPrimitiveTypesAtPath(fullPath).size > 0) {
+        placePath = [...relativePath, ""];
       } else {
-        const relativePath = fullPath.slice(containerSegments.length);
-        if (relativePath.length === 0) {
-          placePath = [""];
-        } else if (state.schema.isLeafAtPath(fullPath)) {
-          placePath = relativePath;
-        } else if (state.schema.getSlimPrimitiveTypesAtPath(fullPath).size > 0) {
-          placePath = [...relativePath, ""];
-        } else {
-          placePath = relativePath;
-        }
+        placePath = relativePath;
       }
       placeAt(tree, placePath, errors);
     }
@@ -1914,6 +1922,19 @@ function buildProcessForm(state, formInstanceId, options = {}) {
           state.clearSchemaErrors();
         }
         await onSubmit(merged.data);
+        if (state.userErrors.size > 0) {
+          if (state.submissionGeneration.value === genAtEntry) {
+            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+          }
+          if (onError !== void 0) {
+            try {
+              await onError(Array.from(state.userErrors.values()).flat());
+            } catch (cause) {
+              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+            }
+          }
+          return;
+        }
         if (state.submissionGeneration.value === genAtEntry) {
           state.submitted.value = true;
         }
@@ -2908,62 +2929,56 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
-  function filterToOwnFormKey(errors, op) {
-    const own = [];
-    let dropped = 0;
-    for (const e of errors) {
-      if (e.formKey === state.formKey) own.push(e);
-      else dropped++;
-    }
-    if (paths.__DEV__ && dropped > 0) {
-      console.warn(
-        `[attaform] ${op}: dropped ${dropped} error(s) with non-matching formKey (this form's key is "${String(state.formKey)}"). Errors are scoped to the form that produced them \u2014 pass them to the matching form instance.`
-      );
+  function normalizeErrorInput(item, scope) {
+    if (item instanceof Error) {
+      return {
+        message: item.message.length > 0 ? item.message : "Unknown error",
+        path: scope !== void 0 ? [...scope] : [],
+        formKey: state.formKey,
+        code: AttaformErrorCode.UserError
+      };
     }
-    return own;
+    const entry = {
+      message: typeof item.message === "string" && item.message.length > 0 ? item.message : "Unknown error",
+      path: scope !== void 0 ? [...scope] : Array.isArray(item.path) ? [...item.path] : [],
+      formKey: state.formKey,
+      code: typeof item.code === "string" && item.code.length > 0 ? item.code : AttaformErrorCode.UserError
+    };
+    if (item.data !== void 0) entry.data = item.data;
+    return entry;
   }
-  function setFieldErrors(errors) {
-    const preserved = state.userErrors.get(paths.FORM_ERRORS_PATH_KEY);
-    state.setAllUserErrors(filterToOwnFormKey(errors, "setFieldErrors"));
-    if (preserved !== void 0 && preserved.length > 0) {
-      state.userErrors.set(paths.FORM_ERRORS_PATH_KEY, preserved);
+  function normalizeErrorInputs(input, scope) {
+    const items = Array.isArray(input) ? input : [input];
+    return items.map((item) => normalizeErrorInput(item, scope));
+  }
+  function flattenUserErrors() {
+    const all = [];
+    for (const errs of state.userErrors.values()) all.push(...errs);
+    return all;
+  }
+  function setErrors(arg1, arg2) {
+    const isScoped = arguments.length >= 2 && (typeof arg1 === "string" || Array.isArray(arg1));
+    if (isScoped) {
+      const { segments, key } = paths.canonicalizePath(arg1);
+      const input2 = arg2;
+      const resolved2 = typeof input2 === "function" ? input2((state.userErrors.get(key) ?? []).slice()) : input2;
+      state.setUserErrorsForPath(segments, normalizeErrorInputs(resolved2, segments));
+      return;
     }
+    const input = arg1;
+    const resolved = typeof input === "function" ? input(flattenUserErrors()) : input;
+    state.setAllUserErrors(normalizeErrorInputs(resolved, void 0));
   }
-  function addFieldErrors(errors) {
-    state.addUserErrors(filterToOwnFormKey(errors, "addFieldErrors"));
-  }
-  function clearFieldErrors(path) {
+  function clearErrors(path) {
     if (path === void 0) {
-      const preserved = state.userErrors.get(paths.FORM_ERRORS_PATH_KEY);
       state.clearSchemaErrors();
       state.clearUserErrors();
-      if (preserved !== void 0 && preserved.length > 0) {
-        state.userErrors.set(paths.FORM_ERRORS_PATH_KEY, preserved);
-      }
       return;
     }
     const segments = paths.canonicalizePath(path).segments;
     state.clearSchemaErrors(segments);
     state.clearUserErrors(segments);
   }
-  function setFormErrors(errors) {
-    if (errors.length === 0) {
-      state.userErrors.delete(paths.FORM_ERRORS_PATH_KEY);
-      return;
-    }
-    state.userErrors.set(
-      paths.FORM_ERRORS_PATH_KEY,
-      errors.map((e) => ({
-        path: [...paths.FORM_ERRORS_PATH],
-        message: e.message,
-        formKey: state.formKey,
-        code: e.code ?? "atta:form-error"
-      }))
-    );
-  }
-  function clearFormErrors() {
-    state.userErrors.delete(paths.FORM_ERRORS_PATH_KEY);
-  }
   const submitting = vue.computed(() => state.submitting.value);
   const submissionAttempts = vue.computed(() => state.submissionAttempts.value);
   const submitted = vue.computed(() => state.submitted.value);
@@ -3230,14 +3245,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const EMPTY_FIELD_RECORD = Object.freeze({});
   function record(path) {
-    const { segments } = paths.canonicalizePath(path);
+    const segments = path === void 0 ? [] : paths.canonicalizePath(path).segments;
     const value = state.getValueAtPath(segments);
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
       return EMPTY_FIELD_RECORD;
     }
     const out = {};
     for (const key of Object.keys(value)) {
-      safeAssign(out, key, callTerminal(`${path}.${key}`));
+      safeAssign(out, key, callTerminal(segments.length === 0 ? key : `${path}.${key}`));
     }
     return Object.freeze(out);
   }
@@ -3294,11 +3309,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       return errorsProxy;
     },
     toRef: gated(pathToRef),
-    setFieldErrors: gated(setFieldErrors),
-    addFieldErrors: gated(addFieldErrors),
-    clearFieldErrors: gated(clearFieldErrors),
-    setFormErrors: gated(setFormErrors),
-    clearFormErrors: gated(clearFormErrors),
+    setErrors: gated(setErrors),
+    clearErrors: gated(clearErrors),
     get meta() {
       void state.activate();
       return formMeta;
@@ -4816,25 +4828,14 @@ function createFormStore(options) {
   function getValueAtPath(path) {
     return getAtPath(form.value, path);
   }
-  function rerouteFormLevelEntry(err) {
-    if (err.path.length === 0) {
-      return { ...err, path: [...paths.FORM_ERRORS_PATH] };
-    }
-    return err;
-  }
-  function pathKeyForEntry(err) {
-    if (err.path.length === 0) return paths.FORM_ERRORS_PATH_KEY;
-    return paths.canonicalizePath(err.path).key;
-  }
   function appendErrorsTo(map, entries) {
     for (const raw of entries) {
-      const err = rerouteFormLevelEntry(raw);
-      const key = pathKeyForEntry(err);
+      const { key } = paths.canonicalizePath(raw.path);
       const current = map.get(key);
       if (current === void 0) {
-        map.set(key, [err]);
+        map.set(key, [raw]);
       } else {
-        map.set(key, [...current, err]);
+        map.set(key, [...current, raw]);
       }
     }
   }
@@ -4859,14 +4860,13 @@ function createFormStore(options) {
     schemaErrors.set(key, [...entries]);
   }
   function applySchemaErrorsForSubtree(path, entries) {
-    const parentKey = path.length === 0 ? paths.FORM_ERRORS_PATH_KEY : paths.canonicalizePath(path).key;
+    const parentKey = paths.canonicalizePath(path).key;
     const grouped = /* @__PURE__ */ new Map();
     for (const raw of entries) {
-      const err = rerouteFormLevelEntry(raw);
-      const key = pathKeyForEntry(err);
+      const { key } = paths.canonicalizePath(raw.path);
       const list = grouped.get(key);
-      if (list === void 0) grouped.set(key, [err]);
-      else list.push(err);
+      if (list === void 0) grouped.set(key, [raw]);
+      else list.push(raw);
     }
     if (!grouped.has(parentKey)) schemaErrors.delete(parentKey);
     for (const existingKey of [...schemaErrors.keys()]) {
@@ -4888,8 +4888,13 @@ function createFormStore(options) {
   function setAllUserErrors(entries) {
     replaceErrorsIn(userErrors, entries);
   }
-  function addUserErrors(entries) {
-    appendErrorsTo(userErrors, entries);
+  function setUserErrorsForPath(path, entries) {
+    const { key } = paths.canonicalizePath(path);
+    if (entries.length === 0) {
+      userErrors.delete(key);
+      return;
+    }
+    userErrors.set(key, [...entries]);
   }
   function clearUserErrors(path) {
     clearErrorsIn(userErrors, path);
@@ -5083,25 +5088,25 @@ function createFormStore(options) {
     }
   }
   function clearHydrationFailedEntry() {
-    const existing = schemaErrors.get(paths.FORM_ERRORS_PATH_KEY);
+    const existing = schemaErrors.get(paths.ROOT_PATH_KEY);
     if (existing === void 0) return;
     const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
     if (filtered.length === 0) {
-      schemaErrors.delete(paths.FORM_ERRORS_PATH_KEY);
+      schemaErrors.delete(paths.ROOT_PATH_KEY);
     } else {
-      schemaErrors.set(paths.FORM_ERRORS_PATH_KEY, filtered);
+      schemaErrors.set(paths.ROOT_PATH_KEY, filtered);
     }
   }
   function appendHydrationFailedEntry(error) {
     const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Hydration failed";
     const entry = {
       message,
-      path: [...paths.FORM_ERRORS_PATH],
+      path: [...paths.ROOT_PATH],
       formKey,
       code: AttaformErrorCode.HydrationFailed
     };
-    const existing = schemaErrors.get(paths.FORM_ERRORS_PATH_KEY) ?? [];
-    schemaErrors.set(paths.FORM_ERRORS_PATH_KEY, [...existing, entry]);
+    const existing = schemaErrors.get(paths.ROOT_PATH_KEY) ?? [];
+    schemaErrors.set(paths.ROOT_PATH_KEY, [...existing, entry]);
     return entry;
   }
   function reset(nextDefaultValues) {
@@ -5334,7 +5339,7 @@ function createFormStore(options) {
     clearSchemaErrors,
     applySchemaErrorsForSubtree,
     setAllUserErrors,
-    addUserErrors,
+    setUserErrorsForPath,
     clearUserErrors,
     getErrorsForPath,
     ensurePathOrdinal,
@@ -5411,12 +5416,38 @@ function captureErrorEntries(map) {
   for (const [k, v] of map) out.push([k, [...v]]);
   return out;
 }
+function dataEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || a === void 0 || b === void 0) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!dataEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(b)) return false;
+  if (typeof a === "object") {
+    const ao = a;
+    const bo = b;
+    const keys = Object.keys(ao);
+    if (keys.length !== Object.keys(bo).length) return false;
+    for (const k of keys) {
+      if (!Object.prototype.hasOwnProperty.call(bo, k)) return false;
+      if (!dataEqual(ao[k], bo[k])) return false;
+    }
+    return true;
+  }
+  return false;
+}
 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 || paths.pathsEqual(av.path, bvi.path);
+  if (av.path !== bvi.path && !paths.pathsEqual(av.path, bvi.path)) return false;
+  return dataEqual(av.data, bvi.data);
 }
 function errorsEqual(a, b) {
   if (a.length !== b.length) return false;
@@ -5906,7 +5937,7 @@ function useRegister() {
       const dirs = instance.vnode.dirs;
       if (dirs !== null && dirs !== void 0) {
         for (const dir of dirs) {
-          const marked = dir.dir?.[paths.V_REGISTER_MARKER];
+          const marked = dir.dir?.[registerProtocol.V_REGISTER_MARKER];
           if (marked === true) {
             capturedRegisterValue.value = dir.value;
             break;
@@ -5922,7 +5953,7 @@ function useRegister() {
   vue.onMounted(() => {
     const el = instance.vnode.el;
     if (el !== null && el !== void 0 && typeof el === "object") {
-      el[paths.REGISTER_OWNER_MARKER] = true;
+      el[registerProtocol.REGISTER_OWNER_MARKER] = true;
     }
     if (capturedRegisterValue.value === void 0) {
       warnNoParentRV(instance);
@@ -6721,6 +6752,30 @@ function useWizard(options) {
     }
     return out;
   }
+  function collectCallbackErrors(keys) {
+    const out = [];
+    for (const key of keys) {
+      const store = registry.forms.get(key);
+      if (store === void 0) continue;
+      for (const errs of store.userErrors.values()) {
+        for (const err of errs) out.push(toWizardAggregateError(err, key));
+      }
+    }
+    return out;
+  }
+  async function focusFirstWizardError(errors) {
+    if (options.focusFirstError === false) return;
+    const firstFailedKey = errors[0]?.formKey;
+    if (firstFailedKey === void 0 || !isCompiledKey(firstFailedKey)) return;
+    moveTo(firstFailedKey);
+    await vue.nextTick();
+    const failedForm = formsRecord.value[firstFailedKey];
+    if (failedForm === void 0) return;
+    const failedSource = asSubmissionSource(failedForm);
+    if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
+      failedSource.applyInvalidSubmitPolicy();
+    }
+  }
   function handleSubmit(onSubmit, onError) {
     return async function submitHandler(event) {
       if (event !== void 0 && typeof event.preventDefault === "function") {
@@ -6783,6 +6838,18 @@ function useWizard(options) {
           }
           const ctx = buildSubmitContext(valuesMap, currentKey, final);
           await onSubmit(ctx);
+          const callbackErrors = collectCallbackErrors(results.keys());
+          if (callbackErrors.length > 0) {
+            await focusFirstWizardError(callbackErrors);
+            if (onError !== void 0) {
+              try {
+                await onError(callbackErrors);
+              } catch (cause) {
+                throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+              }
+            }
+            return;
+          }
           if (final) {
             done.value = true;
           } else {
@@ -6792,20 +6859,7 @@ function useWizard(options) {
             if (target !== void 0) moveTo(target.key);
           }
         } else {
-          if (options.focusFirstError !== false) {
-            const firstFailedKey = errors[0]?.formKey;
-            if (firstFailedKey !== void 0 && isCompiledKey(firstFailedKey)) {
-              moveTo(firstFailedKey);
-              await vue.nextTick();
-              const failedForm = formsRecord.value[firstFailedKey];
-              if (failedForm !== void 0) {
-                const failedSource = asSubmissionSource(failedForm);
-                if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
-                  failedSource.applyInvalidSubmitPolicy();
-                }
-              }
-            }
-          }
+          await focusFirstWizardError(errors);
           if (onError !== void 0) {
             try {
               await onError(errors);
@@ -7025,7 +7079,6 @@ exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
 exports.lazy = lazy;
 exports.makeDefaultDisplayState = makeDefaultDisplayState;
-exports.normalizeNumericOption = normalizeNumericOption;
 exports.safeAssign = safeAssign;
 exports.safeOwnRead = safeOwnRead;
 exports.setAtPath = setAtPath;
@@ -7034,4 +7087,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.DsQkXE3o.cjs.map
+//# sourceMappingURL=attaform.DRQjF16I.cjs.map