attaform 0.22.0 → 0.24.0

package/dist/shared/{attaform.CsB-iKbU.mjs → attaform.CuBdtfbe.mjs}

@@ -1,5 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, isRef, toValue, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
-import { q as pathsEqual, l as isPathPrefix, _ as __DEV__, a as canonicalizePath, s as segmentsForPathKey, F as FORM_ERRORS_PATH_KEY, r as keyForSegments, S as SubmitErrorHandlerError, t as toError, A as AnonPersistError, w as INTERACTIVE_TAG_NAMES, x as getOrAssignElementId, R as ROOT_PATH, y as allowSensitivePersist, z as FORM_ERRORS_PATH, e as ROOT_PATH_KEY, B as segmentsToDotted, C as coerceToPathKey, E as isSensitivePath, G as createPersistOptInRegistry, d as InvalidUseFormConfigError, H as ensureAttaformInstalled, u as useRegistry, J as kFormContext, K as kFormInstanceId, h as ReservedFormKeyError, L as createIsSensitivePath, M as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, k as kAttaformWizardActiveStepResolver, N as kAttaformAncestorWizard } from './attaform.BKFwekY2.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
+import { o as pathsEqual, j as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, q as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, r as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, w as coerceToPathKey, a as InvalidUseFormConfigError, x as ensureAttaformInstalled, u as useRegistry, y as kFormContext, z as kFormInstanceId, d as ReservedFormKeyError, B as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, m as kAttaformWizardActiveStepResolver, C as kAttaformAncestorWizard } from './attaform.Df-s8j1X.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -540,6 +540,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;
 }
@@ -595,54 +647,8 @@ 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_PERSISTENCE_DEBOUNCE_MS = 300;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
-const PERSISTENCE_KEY_PREFIX = "attaform:";
 const RESERVED_KEY_PREFIX = "__atta:";
 const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
 const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
@@ -1033,7 +1039,7 @@ function aggregateErrorsAt(state, prefix) {
       const segs = segmentsForPathKey(pathKey);
       if (segs === null) continue;
       if (!isPathPrefix(prefix, segs)) continue;
-      if (pathKey === 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 +1158,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 } = canonicalizePath(arg);
         return opts.resolveCallTarget(argSegs);
       },
@@ -1363,8 +1374,7 @@ function buildErrorsProxy(state) {
         return merged;
       }
       const { key } = canonicalizePath(path);
-      const isFormLevel = key === 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 +1382,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 +1439,6 @@ function errorAwareContainerKeys(state, segments) {
   const walk = (store, applyActivePathFilter) => {
     for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
-      if (pathKey === FORM_ERRORS_PATH_KEY) {
-        if (segments.length === 0) keys.add("");
-        continue;
-      }
       const decoded = segmentsForPathKey(pathKey);
       if (decoded === null) continue;
       if (decoded.length <= segments.length) continue;
@@ -1450,31 +1461,25 @@ function materializeErrors(state, containerSegments) {
       if (errors.length === 0) continue;
       const fullPath = 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, [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);
     }
@@ -1513,9 +1518,8 @@ function buildFieldArrayApi(state) {
     return Array.isArray(current) ? current.slice() : [];
   }
   function writeArray(path, next, arrayOp) {
-    const { segments, key } = canonicalizePath(path);
+    const { segments } = canonicalizePath(path);
     const meta = {
-      persist: state.persistOptIns.hasAnyOptInForPath(key),
       ...arrayOp !== void 0 ? { arrayOp } : {}
     };
     return state.setValueAtPath(segments, next, meta);
@@ -1737,121 +1741,6 @@ function walk$1(value, basePath, schema, snapshotFieldStateAt) {
   return result;
 }
 
-const PERSISTENCE_MODULE_KEY = "persistence";
-async function getStorageAdapter(storage) {
-  if (typeof storage === "object") return storage;
-  switch (storage) {
-    case "local": {
-      const { createLocalStorageAdapter } = await import('../chunks/local-storage.mjs');
-      return createLocalStorageAdapter();
-    }
-    case "session": {
-      const { createSessionStorageAdapter } = await import('../chunks/session-storage.mjs');
-      return createSessionStorageAdapter();
-    }
-    case "indexeddb": {
-      const { createIndexedDbAdapter } = await import('../chunks/indexeddb.mjs');
-      return createIndexedDbAdapter();
-    }
-  }
-}
-function resolveStorageKeyBase(config, formKey) {
-  return config.key ?? `${PERSISTENCE_KEY_PREFIX}${formKey}`;
-}
-async function removeMatchingKeys(adapter, base, keepKey) {
-  let keys;
-  try {
-    keys = await adapter.listKeys(base);
-  } catch {
-    return;
-  }
-  for (const key of keys) {
-    if (key === keepKey) continue;
-    if (key === base || key.startsWith(`${base}:`)) {
-      void adapter.removeItem(key).catch(() => void 0);
-    }
-  }
-}
-async function cleanupOrphanKeys(adapter, base, currentKey) {
-  await removeMatchingKeys(adapter, base, currentKey);
-}
-const STANDARD_STORAGE_KINDS = ["local", "session", "indexeddb"];
-function normalizePersistConfig(input) {
-  if (typeof input === "string") return { storage: input };
-  if ("storage" in input) return input;
-  return { storage: input };
-}
-async function sweepAllOrphansAcrossStandardStores(base) {
-  for (const kind of STANDARD_STORAGE_KINDS) {
-    try {
-      const adapter = await getStorageAdapter(kind);
-      await removeMatchingKeys(adapter, base);
-    } catch {
-    }
-  }
-}
-async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
-  const configuredKind = typeof configured === "string" ? configured : null;
-  for (const kind of STANDARD_STORAGE_KINDS) {
-    if (kind === configuredKind) continue;
-    try {
-      const adapter = await getStorageAdapter(kind);
-      await removeMatchingKeys(adapter, base);
-    } catch {
-    }
-  }
-}
-function mergeSparseHydration(schemaDefaults, sparse, schema) {
-  return mergeDeep(schemaDefaults, sparse, [], schema);
-}
-function mergeDeep(target, source, path, schema) {
-  if (source === void 0) return target;
-  if (source === null || typeof source !== "object") return source;
-  if (Array.isArray(source)) return source;
-  if (!isPlainRecord(source)) return source;
-  if (schema !== void 0) {
-    const du = schema.getUnionDiscriminatorAtPath(path);
-    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);
-    }
-  }
-  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)
-    );
-  }
-  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;
-}
-
 const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
@@ -2109,44 +1998,6 @@ 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([]);
-    if (root !== null && typeof root === "object" && !Array.isArray(root)) {
-      return Object.keys(root);
-    }
-  } catch {
-  }
-  return [];
-}
-
 const warnedRejections = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function shouldWarnOnce$1(store, key) {
   if (warnedRejections === null) return false;
@@ -2476,16 +2327,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
     const slimTypes = state.schema.getSlimPrimitiveTypesAtPath(segments);
     const acceptsUndefined = slimTypes.has("undefined");
     const acceptsString = slimTypes.has("string");
-    const persist = options?.persist === true;
-    const acknowledgeSensitive = options?.acknowledgeSensitive === true;
-    const multiTab = options?.multiTab !== false;
     const transforms = options?.transforms ?? EMPTY_TRANSFORMS;
-    const markNoSync = !multiTab ? () => {
-      state.incrementNoSyncOptOut(pathKey);
-    } : void 0;
-    const unmarkNoSync = !multiTab ? () => {
-      state.decrementNoSyncOptOut(pathKey);
-    } : void 0;
     const coerce = buildCoerceFn(
       state.schema,
       segments,
@@ -2496,18 +2338,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       segments,
       coerceIndex
     );
-    if (persist && !state.ssr && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
-      throw new AnonPersistError({
-        cause: "register-without-config",
-        schemaFields: extractSchemaFields(state.schema),
-        callSite: captureUserCallSite()
-      });
-    }
     const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
     const isRequired = state.schema.isRequiredAtPath(segments);
     const ariaEnabled = options?.autoAria ?? formAutoAria;
     const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
-    let boundElement = null;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2517,8 +2351,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           segments,
           slimDefault,
           withInstanceMeta({
-            blank: true,
-            persist
+            blank: true
           })
         );
       },
@@ -2526,7 +2359,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         state.markInteracted(segments);
       },
       registerElement: (element) => {
-        boundElement = element;
         if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
         if (added) attachFocusListeners(state, segments, element, instanceMeta);
@@ -2534,11 +2366,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       deregisterElement: (element) => {
         detachFocusListeners(element);
         state.deregisterElement(segments, element);
-        if (boundElement === element) boundElement = null;
       },
       setValueWithInternalPath: (value, meta) => {
-        const resolvedMeta = meta === void 0 && boundElement !== null ? { persist: state.persistOptIns.hasOptIn(getOrAssignElementId(boundElement), pathKey) } : meta;
-        return state.setValueAtPath(segments, value, withInstanceMeta(resolvedMeta));
+        return state.setValueAtPath(segments, value, withInstanceMeta(meta));
       },
       // Called by the `vRegisterHint` compile-time transform's wrapping
       // IIFE on every server-side render of `<element v-register="…">`.
@@ -2576,15 +2406,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       segments: Object.freeze(segments.slice()),
       formKey: state.formKey,
       formInstanceId,
-      // --- Persistence opt-in (internal; the directive is the only
-      // legitimate consumer) ---
-      persist,
-      acknowledgeSensitive,
-      persistOptIns: state.persistOptIns,
-      isSensitivePath: state.isSensitivePath,
-      multiTab,
-      ...markNoSync !== void 0 ? { markNoSync } : {},
-      ...unmarkNoSync !== void 0 ? { unmarkNoSync } : {},
       transforms,
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {},
@@ -3021,12 +2842,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     const segments = canonicalizePath(pathInput).segments;
     return computed(() => getAtPath(state.form.value, segments));
   }
-  function setValueImpl(pathOrValue, maybeValue, maybeOptions) {
+  function setValueImpl(pathOrValue, maybeValue) {
     const argc = arguments.length;
     const isPathForm = argc >= 2 && (typeof pathOrValue === "string" || Array.isArray(pathOrValue));
-    const options2 = isPathForm ? maybeOptions : argc >= 2 ? maybeValue : void 0;
-    const silent = options2?.silent === true;
-    const writeMeta = (extra) => withInstanceMeta(silent ? { ...extra, silent: true } : extra);
+    const writeMeta = (extra) => withInstanceMeta(extra);
     if (!isPathForm) {
       const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
       const walked2 = walkUnsetSentinels(
@@ -3094,62 +2913,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 (__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(FORM_ERRORS_PATH_KEY);
-    state.setAllUserErrors(filterToOwnFormKey(errors, "setFieldErrors"));
-    if (preserved !== void 0 && preserved.length > 0) {
-      state.userErrors.set(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 } = 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(FORM_ERRORS_PATH_KEY);
       state.clearSchemaErrors();
       state.clearUserErrors();
-      if (preserved !== void 0 && preserved.length > 0) {
-        state.userErrors.set(FORM_ERRORS_PATH_KEY, preserved);
-      }
       return;
     }
     const segments = canonicalizePath(path).segments;
     state.clearSchemaErrors(segments);
     state.clearUserErrors(segments);
   }
-  function setFormErrors(errors) {
-    if (errors.length === 0) {
-      state.userErrors.delete(FORM_ERRORS_PATH_KEY);
-      return;
-    }
-    state.userErrors.set(
-      FORM_ERRORS_PATH_KEY,
-      errors.map((e) => ({
-        path: [...FORM_ERRORS_PATH],
-        message: e.message,
-        formKey: state.formKey,
-        code: e.code ?? "atta:form-error"
-      }))
-    );
-  }
-  function clearFormErrors() {
-    state.userErrors.delete(FORM_ERRORS_PATH_KEY);
-  }
   const submitting = computed(() => state.submitting.value);
   const submissionAttempts = computed(() => state.submissionAttempts.value);
   const submitted = computed(() => state.submitted.value);
@@ -3318,7 +3131,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
       instanceId: formInstanceId
     })
   );
-  const persistenceHandle = state.modules.get(PERSISTENCE_MODULE_KEY);
   const reset = (nextDefaultValues) => {
     if (nextDefaultValues === void 0) {
       state.reset();
@@ -3333,16 +3145,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.originalBlankPaths.add(pathKey);
       }
     }
-    if (persistenceHandle !== void 0) {
-      void persistenceHandle.ready.then((m) => m?.clearPersistedDraft()).catch(() => void 0);
-    }
   };
   const resetField = (pathInput) => {
     const segments = canonicalizePath(pathInput).segments;
     state.resetField(segments);
-    if (persistenceHandle !== void 0) {
-      void persistenceHandle.ready.then((m) => m?.clearPersistedDraft(segments)).catch(() => void 0);
-    }
   };
   function clear(pathInput) {
     if (pathInput === void 0) {
@@ -3350,31 +3156,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
     return setValueImpl(pathInput, unset);
   }
-  const persist = async (pathInput, options2) => {
-    const segments = canonicalizePath(pathInput).segments;
-    if (!allowSensitivePersist(
-      segments,
-      options2?.acknowledgeSensitive === true,
-      state.isSensitivePath
-    )) {
-      return;
-    }
-    if (persistenceHandle === void 0) return;
-    const persistence = await persistenceHandle.ready;
-    if (persistence === void 0) return;
-    await persistence.writePathImmediately(segments);
-  };
-  const clearPersistedDraft = async (pathInput) => {
-    if (persistenceHandle === void 0) return;
-    const persistence = await persistenceHandle.ready;
-    if (persistence === void 0) return;
-    if (pathInput === void 0) {
-      await persistence.clearPersistedDraft();
-      return;
-    }
-    const segments = canonicalizePath(pathInput).segments;
-    await persistence.clearPersistedDraft(segments);
-  };
   function touch(pathInput) {
     const segments = pathInput === void 0 ? ROOT_PATH : canonicalizePath(pathInput).segments;
     state.touchAtPath(segments);
@@ -3448,29 +3229,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const EMPTY_FIELD_RECORD = Object.freeze({});
   function record(path) {
-    const { segments } = canonicalizePath(path);
+    const segments = path === void 0 ? [] : 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);
   }
-  const formHandle = {
-    current: void 0
-  };
-  function onChangeImpl(a, b, c) {
-    const sourced = typeof b === "function";
-    const source = sourced ? a : void 0;
-    const handler = sourced ? b : a;
-    const options2 = sourced ? c : b;
-    const stop = state.registerOnChange(source, handler, options2, () => formHandle.current);
-    if (getCurrentScope() !== void 0) onScopeDispose(stop);
-    return stop;
-  }
   const api = {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
@@ -3524,11 +3293,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;
@@ -3536,8 +3302,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     reset: gated(reset),
     resetField: gated(resetField),
     clear: gated(clear),
-    persist: gated(persist),
-    clearPersistedDraft: gated(clearPersistedDraft),
     focusFirstError: gated(focusFirstError),
     scrollToFirstError: gated(scrollToFirstError),
     applyInvalidSubmitPolicy: gated(applyInvalidSubmitPolicyPublic),
@@ -3558,10 +3322,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     get blankPaths() {
       void state.activate();
       return blankPathsView;
-    },
-    onChange: onChangeImpl
+    }
   };
-  formHandle.current = api;
   return api;
 }
 
@@ -4073,168 +3835,55 @@ function createArrayBookkeeping(deps) {
   };
 }
 
-const NOOP_STOP = () => {
-};
-function isThenable(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function isSuppressed(meta) {
-  return meta?.hydration === true || meta?.crossTab === true || meta?.silent === true;
-}
-function canonicalizeSourceList(raw) {
-  const list = typeof raw === "string" ? [raw] : raw;
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of list) {
-    const { segments, key } = canonicalizePath(entry);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push({ segments, key, dotted: segmentsToDotted(segments) });
-  }
-  return out;
+function mergeSparseHydration(schemaDefaults, sparse, schema) {
+  return mergeDeep(schemaDefaults, sparse, [], schema);
 }
-function makeResolver(source) {
-  if (source === void 0) {
-    const root = [{ segments: ROOT_PATH, key: ROOT_PATH_KEY, dotted: "" }];
-    return () => root;
-  }
-  if (typeof source !== "function" && !isRef(source)) {
-    const fixed = canonicalizeSourceList(source);
-    return () => fixed;
+function mergeDeep(target, source, path, schema) {
+  if (source === void 0) return target;
+  if (source === null || typeof source !== "object") return source;
+  if (Array.isArray(source)) return source;
+  if (!isPlainRecord(source)) return source;
+  if (schema !== void 0) {
+    const du = schema.getUnionDiscriminatorAtPath(path);
+    if (du !== void 0) return mergeDuAwareKeys(source, path, schema, du);
   }
-  return () => canonicalizeSourceList(toValue(source));
+  return mergeObjectKeys(target, source, path, schema);
 }
-function createOnChangeRegistry(deps) {
-  const handlers = /* @__PURE__ */ new Set();
-  function isCurrent(reg, key, token) {
-    return reg.runs.get(key)?.token === token;
-  }
-  function routeError(reg, error, source, changed, value, previous, attempt, token) {
-    if (reg.onError === void 0) {
-      if (__DEV__) {
-        console.error(
-          `[attaform] onChange handler threw for path '${source.dotted}' \u2014 error swallowed. Pass { onError } to handle it. Original error:`,
-          error
-        );
-      }
-      return;
-    }
-    const retry = () => {
-      if (!isCurrent(reg, source.key, token)) return;
-      runHandler(reg, source, changed, value, previous, attempt + 1);
-    };
-    const errCtx = {
-      path: source.dotted,
-      value,
-      attempt,
-      retry,
-      form: reg.getForm()
-    };
-    try {
-      reg.onError(error, errCtx);
-    } catch (err) {
-      if (__DEV__) console.error("[attaform] onChange onError threw:", err);
-    }
-  }
-  function runHandler(reg, source, changed, value, previous, attempt) {
-    const prior = reg.runs.get(source.key);
-    if (prior) prior.controller.abort();
-    const controller = new AbortController();
-    const token = ++reg.seq;
-    reg.runs.set(source.key, { token, controller });
-    const ctx = {
-      path: source.dotted,
-      previous,
-      signal: controller.signal,
-      attempt,
-      form: reg.getForm(),
-      changed
-    };
-    let result;
-    try {
-      result = reg.handler(value, ctx);
-    } catch (error) {
-      routeError(reg, error, source, changed, value, previous, attempt, token);
-      return;
-    }
-    if (isThenable(result)) {
-      result.then(void 0, (error) => {
-        if (isCurrent(reg, source.key, token)) {
-          routeError(reg, error, source, changed, value, previous, attempt, token);
-        }
-      });
-    }
+function mergeDuAwareKeys(source, path, schema, du) {
+  const sourceDisc = source[du.discriminatorKey];
+  if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
+    return { [du.discriminatorKey]: sourceDisc };
   }
-  function dispatch(patches, meta) {
-    if (handlers.size === 0 || isSuppressed(meta)) return;
-    for (const reg of handlers) {
-      let sources;
-      try {
-        sources = reg.resolve();
-      } catch (error) {
-        if (__DEV__) console.error("[attaform] onChange source getter threw:", error);
-        continue;
-      }
-      for (const source of sources) {
-        let changed;
-        for (const patch of patches) {
-          if (isPathPrefix(source.segments, patch.path) || isPathPrefix(patch.path, source.segments)) {
-            (changed ?? (changed = [])).push(segmentsToDotted(patch.path));
-          }
-        }
-        if (changed === void 0) continue;
-        const value = deps.getValueAtPath(source.segments);
-        const previous = reg.previous.has(source.key) ? reg.previous.get(source.key) : value;
-        reg.previous.set(source.key, value);
-        runHandler(reg, source, changed, value, previous, 0);
-      }
+  if (sourceDisc !== void 0) {
+    const variantDefault = du.getVariantDefault(sourceDisc);
+    if (isPlainRecord(variantDefault)) {
+      return mergeVariantKeys(source, variantDefault, path, schema, du);
     }
   }
-  function register(source, handler, options, getForm) {
-    if (deps.ssr) return NOOP_STOP;
-    const reg = {
-      handler,
-      onError: options?.onError,
-      getForm,
-      resolve: makeResolver(source),
-      previous: /* @__PURE__ */ new Map(),
-      runs: /* @__PURE__ */ new Map(),
-      seq: 0
-    };
-    try {
-      for (const { key, segments } of reg.resolve()) {
-        reg.previous.set(key, deps.getValueAtPath(segments));
-      }
-    } catch (error) {
-      if (__DEV__) console.error("[attaform] onChange source getter threw at registration:", error);
-    }
-    handlers.add(reg);
-    let stopped = false;
-    return () => {
-      if (stopped) return;
-      stopped = true;
-      handlers.delete(reg);
-      for (const run of reg.runs.values()) run.controller.abort();
-      reg.runs.clear();
-      reg.previous.clear();
-    };
+  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)
+    );
   }
-  function dispose() {
-    for (const reg of handlers) {
-      for (const run of reg.runs.values()) run.controller.abort();
-      reg.runs.clear();
-      reg.previous.clear();
-    }
-    handlers.clear();
+  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 {
-    get active() {
-      return handlers.size > 0;
-    },
-    register,
-    dispatch,
-    dispose
-  };
+  return out;
 }
 
 function isHydratedFieldRecord(value) {
@@ -4370,27 +4019,8 @@ function createFormStore(options) {
   const formChangeListeners = /* @__PURE__ */ new Set();
   const submitSuccessListeners = /* @__PURE__ */ new Set();
   const resetListeners = /* @__PURE__ */ new Set();
-  const onChangeRegistry = createOnChangeRegistry({ getValueAtPath, ssr });
-  const persistOptIns = createPersistOptInRegistry();
-  const noSyncPaths = /* @__PURE__ */ new Set();
-  const noSyncPathCounts = /* @__PURE__ */ new Map();
-  function incrementNoSyncOptOut(path) {
-    const next = (noSyncPathCounts.get(path) ?? 0) + 1;
-    noSyncPathCounts.set(path, next);
-    if (next === 1) noSyncPaths.add(path);
-  }
-  function decrementNoSyncOptOut(path) {
-    const current = noSyncPathCounts.get(path) ?? 0;
-    if (current <= 1) {
-      noSyncPathCounts.delete(path);
-      noSyncPaths.delete(path);
-      return;
-    }
-    noSyncPathCounts.set(path, current - 1);
-  }
   const coerceIndex = resolveCoercionIndex(options.coerce);
   const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
-  const resolvedIsSensitivePath = options.isSensitivePath ?? isSensitivePath;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const fieldValidatingSince = reactive(/* @__PURE__ */ new Map());
@@ -4738,7 +4368,6 @@ function createFormStore(options) {
         console.error("[attaform] onFormChange threw:", err);
       }
     }
-    if (onChangeRegistry.active) onChangeRegistry.dispatch(patches, meta);
   }
   function applyFormReplacementWithPath(next, meta, arrayOpPath) {
     const prev = form.value;
@@ -5179,33 +4808,18 @@ function createFormStore(options) {
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
-    onChangeRegistry.dispose();
-    persistOptIns.clear();
-    noSyncPaths.clear();
-    noSyncPathCounts.clear();
   }
   function getValueAtPath(path) {
     return getAtPath(form.value, path);
   }
-  function rerouteFormLevelEntry(err) {
-    if (err.path.length === 0) {
-      return { ...err, path: [...FORM_ERRORS_PATH] };
-    }
-    return err;
-  }
-  function pathKeyForEntry(err) {
-    if (err.path.length === 0) return FORM_ERRORS_PATH_KEY;
-    return canonicalizePath(err.path).key;
-  }
   function appendErrorsTo(map, entries) {
     for (const raw of entries) {
-      const err = rerouteFormLevelEntry(raw);
-      const key = pathKeyForEntry(err);
+      const { key } = 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]);
       }
     }
   }
@@ -5230,14 +4844,13 @@ function createFormStore(options) {
     schemaErrors.set(key, [...entries]);
   }
   function applySchemaErrorsForSubtree(path, entries) {
-    const parentKey = path.length === 0 ? FORM_ERRORS_PATH_KEY : canonicalizePath(path).key;
+    const parentKey = canonicalizePath(path).key;
     const grouped = /* @__PURE__ */ new Map();
     for (const raw of entries) {
-      const err = rerouteFormLevelEntry(raw);
-      const key = pathKeyForEntry(err);
+      const { key } = 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()]) {
@@ -5259,8 +4872,13 @@ function createFormStore(options) {
   function setAllUserErrors(entries) {
     replaceErrorsIn(userErrors, entries);
   }
-  function addUserErrors(entries) {
-    appendErrorsTo(userErrors, entries);
+  function setUserErrorsForPath(path, entries) {
+    const { key } = canonicalizePath(path);
+    if (entries.length === 0) {
+      userErrors.delete(key);
+      return;
+    }
+    userErrors.set(key, [...entries]);
   }
   function clearUserErrors(path) {
     clearErrorsIn(userErrors, path);
@@ -5454,25 +5072,25 @@ function createFormStore(options) {
     }
   }
   function clearHydrationFailedEntry() {
-    const existing = schemaErrors.get(FORM_ERRORS_PATH_KEY);
+    const existing = schemaErrors.get(ROOT_PATH_KEY);
     if (existing === void 0) return;
     const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
     if (filtered.length === 0) {
-      schemaErrors.delete(FORM_ERRORS_PATH_KEY);
+      schemaErrors.delete(ROOT_PATH_KEY);
     } else {
-      schemaErrors.set(FORM_ERRORS_PATH_KEY, filtered);
+      schemaErrors.set(ROOT_PATH_KEY, filtered);
     }
   }
   function appendHydrationFailedEntry(error) {
     const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Hydration failed";
     const entry = {
       message,
-      path: [...FORM_ERRORS_PATH],
+      path: [...ROOT_PATH],
       formKey,
       code: AttaformErrorCode.HydrationFailed
     };
-    const existing = schemaErrors.get(FORM_ERRORS_PATH_KEY) ?? [];
-    schemaErrors.set(FORM_ERRORS_PATH_KEY, [...existing, entry]);
+    const existing = schemaErrors.get(ROOT_PATH_KEY) ?? [];
+    schemaErrors.set(ROOT_PATH_KEY, [...existing, entry]);
     return entry;
   }
   function reset(nextDefaultValues) {
@@ -5485,7 +5103,7 @@ function createFormStore(options) {
     });
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
-    applyFormReplacement(next, { silent: true });
+    applyFormReplacement(next);
     arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -5705,7 +5323,7 @@ function createFormStore(options) {
     clearSchemaErrors,
     applySchemaErrorsForSubtree,
     setAllUserErrors,
-    addUserErrors,
+    setUserErrorsForPath,
     clearUserErrors,
     getErrorsForPath,
     ensurePathOrdinal,
@@ -5731,7 +5349,6 @@ function createFormStore(options) {
     settleTransforms,
     scheduleFieldValidation,
     onFormChange,
-    registerOnChange: onChangeRegistry.register,
     onSubmitSuccess,
     onReset,
     emitSubmitSuccess,
@@ -5739,11 +5356,6 @@ function createFormStore(options) {
     registerDrain,
     awaitPendingWrites,
     modules,
-    persistOptIns,
-    isSensitivePath: resolvedIsSensitivePath,
-    noSyncPaths,
-    incrementNoSyncOptOut,
-    decrementNoSyncOptOut,
     coerceIndex,
     blankPaths,
     originalBlankPaths,
@@ -5751,6 +5363,33 @@ function createFormStore(options) {
   };
 }
 
+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 getComputedSchema(formKey, schemaOrCallback, options) {
   if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey, options);
   return schemaOrCallback;
@@ -5761,12 +5400,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 || pathsEqual(av.path, bvi.path);
+  if (av.path !== bvi.path && !pathsEqual(av.path, bvi.path)) return false;
+  return dataEqual(av.data, bvi.data);
 }
 function errorsEqual(a, b) {
   if (a.length !== b.length) return false;
@@ -5860,10 +5525,6 @@ function createHistoryModule(state, config) {
       clear();
       return;
     }
-    if (meta?.crossTab === true) {
-      currentSnapshot.value = captureSnapshot();
-      return;
-    }
     const newSnap = captureSnapshot();
     const prevSnap = currentSnapshot.value;
     const formPatches = [];
@@ -5884,9 +5545,7 @@ function createHistoryModule(state, config) {
     suppressNext = true;
     state.blankPaths.clear();
     for (const key of snap.blankPaths) state.blankPaths.add(key);
-    state.applyFormReplacement(snap.form, {
-      persist: !state.persistOptIns.isEmpty()
-    });
+    state.applyFormReplacement(snap.form);
     const schemaFlat = snap.schemaErrors.flatMap(([, errs]) => errs);
     const userFlat = snap.userErrors.flatMap(([, errs]) => errs);
     state.setAllSchemaErrors(schemaFlat);
@@ -5937,28 +5596,6 @@ function createHistoryModule(state, config) {
   };
 }
 
-const warned = /* @__PURE__ */ new Set();
-function warnOnceInsecureContext(feature) {
-  if (!__DEV__) return;
-  if (warned.has(feature)) return;
-  warned.add(feature);
-  const message = featureMessage(feature);
-  console.warn(`[attaform] ${message}`);
-}
-function featureMessage(feature) {
-  switch (feature) {
-    case "multiTab":
-      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
-    case "persist:local":
-      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
-    case "persist:session":
-      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
-  }
-}
-function isSecureContext() {
-  return typeof window !== "undefined" && window.isSecureContext === true;
-}
-
 function resolveTrichotomy(input) {
   if (typeof input === "function") {
     return { kind: "async", factory: input };
@@ -5987,18 +5624,10 @@ function useAbstractForm(configuration, options) {
     defaultValue: DEFAULT_MAX_RECURSION_DEPTH
   });
   const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
-  if (configuration.persist !== void 0 && configuration.key === void 0) {
-    throw new AnonPersistError({
-      cause: "no-key",
-      schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: captureUserCallSite()
-    });
-  }
   const existing = registry.forms.get(key);
   if (__DEV__ && existing !== void 0) {
     void import('../chunks/dev-key-collision-warnings.mjs').then((m) => {
       void m.warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-      m.warnOnPersistDivergence(key, existing, configuration.persist);
     });
   }
   const hadPendingHydration = registry.pendingHydration.has(key);
@@ -6026,85 +5655,6 @@ function useAbstractForm(configuration, options) {
     const releaseConsumer = registry.trackConsumer(key);
     onScopeDispose(releaseConsumer);
   }
-  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
-  if (existing === void 0 && !registry.ssr) {
-    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
-      const resolvedPersist = normalizePersistConfig(merged.persist);
-      const storageKind = resolvedPersist.storage;
-      const isBuiltinStorage = typeof storageKind === "string";
-      const secureContextOk = !isBuiltinStorage || isSecureContext();
-      if (!secureContextOk) {
-        const feature = storageKind === "session" ? "persist:session" : "persist:local";
-        warnOnceInsecureContext(feature);
-        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
-      } else {
-        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
-        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
-        const adapterPromise = getStorageAdapter(resolvedPersist.storage);
-        let persistDisposed = false;
-        state.registerCleanup(() => {
-          persistDisposed = true;
-        });
-        const ready = (async () => {
-          try {
-            const [{ wirePersistence }, fingerprintToken] = await Promise.all([
-              import('../chunks/wire-persistence.mjs'),
-              resolvePersistFingerprintToken(state)
-            ]);
-            if (persistDisposed) return void 0;
-            const persistenceModule = wirePersistence(
-              state,
-              resolvedPersist,
-              adapterPromise,
-              fingerprintToken
-            );
-            state.registerDrain(() => persistenceModule.awaitPendingWrites());
-            state.registerCleanup(() => persistenceModule.dispose());
-            return persistenceModule;
-          } catch {
-            return void 0;
-          }
-        })();
-        const persistenceHandle = { config: resolvedPersist, ready };
-        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceHandle);
-      }
-    } else {
-      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
-    }
-  }
-  if (existing === void 0 && merged.multiTab === true && configuration.key !== void 0 && !registry.ssr) {
-    const hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
-    const secureContext = isSecureContext();
-    if (hasBroadcastChannel && secureContext) {
-      let formDisposed = false;
-      state.registerCleanup(() => {
-        formDisposed = true;
-      });
-      void (async () => {
-        try {
-          const [{ createMultiTabSyncModule, MULTI_TAB_SYNC_MODULE_KEY }, fingerprint] = await Promise.all([import('../chunks/multi-tab-sync.mjs'), state.schema.fingerprint()]);
-          if (formDisposed) return;
-          const channelName = `attaform:sync:${state.formKey}:${hashStableString(fingerprint)}`;
-          const syncModule = createMultiTabSyncModule(state, channelName, {
-            isSensitivePath: state.isSensitivePath,
-            noSyncPaths: state.noSyncPaths,
-            validateForm: (form) => {
-              const result = state.schema.validateAtPath(form, void 0, { sync: true });
-              if (result instanceof Promise) return;
-              if (!result.success) {
-                throw new Error("attaform multi-tab sync: post-apply schema validation failed");
-              }
-            }
-          });
-          state.modules.set(MULTI_TAB_SYNC_MODULE_KEY, syncModule);
-          state.registerCleanup(() => syncModule.dispose());
-        } catch {
-        }
-      })();
-    } else if (hasBroadcastChannel && !secureContext) {
-      warnOnceInsecureContext("multiTab");
-    }
-  }
   if (existing === void 0 && merged.history !== void 0) {
     const historyModule = createHistoryModule(state, merged.history);
     state.modules.set(HISTORY_MODULE_KEY, historyModule);
@@ -6146,14 +5696,6 @@ function useAbstractForm(configuration, options) {
     apiOptions.autoAria = merged.autoAria;
   }
   const api = buildFormApi(state, formInstanceId, apiOptions);
-  const onChangeConfig = configuration.onChange;
-  if (onChangeConfig !== void 0) {
-    const handler = typeof onChangeConfig === "function" ? onChangeConfig : onChangeConfig.handler;
-    const onError = typeof onChangeConfig === "function" ? void 0 : onChangeConfig.onError;
-    const options2 = onError === void 0 ? void 0 : { onError };
-    const stop = state.registerOnChange(void 0, handler, options2, () => api);
-    if (getCurrentScope() !== void 0) onScopeDispose(stop);
-  }
   return api;
 }
 function mergeWithDefaults(defaults, configuration) {
@@ -6166,8 +5708,6 @@ function mergeWithDefaults(defaults, configuration) {
   const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
   const getDisplayState = configuration.getDisplayState ?? defaults.getDisplayState;
   const maxRecursionDepth = configuration.maxRecursionDepth ?? defaults.maxRecursionDepth;
-  const sensitiveNames = configuration.sensitiveNames ?? defaults.sensitiveNames;
-  const multiTab = configuration.multiTab ?? defaults.multiTab;
   const autoAria = configuration.autoAria ?? defaults.autoAria;
   return {
     ...configuration,
@@ -6180,8 +5720,6 @@ function mergeWithDefaults(defaults, configuration) {
     ...debounceMs === void 0 ? {} : { debounceMs },
     ...getDisplayState === void 0 ? {} : { getDisplayState },
     ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
-    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
-    ...multiTab === void 0 ? {} : { multiTab },
     ...autoAria === void 0 ? {} : { autoAria }
   };
 }
@@ -6197,8 +5735,6 @@ function buildFreshState(key, schema, configuration, registry) {
   if (pending === void 0) {
     initialBlankPaths = walked.paths;
   }
-  const resolvedSensitiveNames = configuration.sensitiveNames;
-  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : createIsSensitivePath(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -6226,8 +5762,7 @@ function buildFreshState(key, schema, configuration, registry) {
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
     ...configuration.getDisplayState !== void 0 ? { getDisplayState: configuration.getDisplayState } : {},
-    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {},
-    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {}
+    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {}
   };
   const state = createFormStore(createOptions);
   registry.forms.set(
@@ -6266,34 +5801,6 @@ function resolveFormKey(key) {
   }
   return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
 }
-async function resolvePersistFingerprintToken(state) {
-  try {
-    return hashStableString(await state.schema.fingerprint());
-  } catch (err) {
-    if (__DEV__) {
-      console.warn(
-        `[attaform] Could not fingerprint the schema for form '${state.formKey}': ${err instanceof Error ? err.message : String(err)}. Persistence falls back to a fingerprint-free key, so a schema change won't auto-invalidate a saved draft.`
-      );
-    }
-    return "unfingerprinted";
-  }
-}
-const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
-function enforceAnonPersistRule(formKey, ssr) {
-  if (!formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return false;
-  if (__DEV__)
-    throw new AnonPersistError({
-      cause: "no-key",
-      callSite: captureUserCallSite()
-    });
-  if (!ssr && !warnedAnonPersistKeys.has(formKey)) {
-    warnedAnonPersistKeys.add(formKey);
-    console.warn(
-      "[attaform] persist: ignored \u2014 anonymous useForm() can't safely persist (key drift + cross-form collision risk).\n  Persistence is disabled for this form; the app keeps working.\n  Fix: useForm({ schema, key: 'login', persist: '...' })"
-    );
-  }
-  return true;
-}
 
 let injectedInstanceCounter = 0;
 function injectForm(input) {
@@ -7520,5 +7027,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, deleteAtPath as B, safeOwnRead as C, DEFAULT_TIMINGS as D, humanize as E, PERSISTENCE_MODULE_KEY as P, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, isPlainRecord as e, safeAssign as f, diffAndApply as g, slimKindOf as h, injectForm as i, applyPatchesForward as j, normalizeNumericOption as k, lazy as l, defaultCoercionRules as m, normalizePersistConfig as n, defaultDisplayState as o, defineCoercion as p, makeDefaultDisplayState as q, useAbstractForm as r, structuralSnapshot as s, getAtPath as t, unset as u, setAtPath as v, resolveStorageKeyBase as w, DEFAULT_PERSISTENCE_DEBOUNCE_MS as x, cleanupOrphanKeys as y, mergeSparseHydration as z };
-//# sourceMappingURL=attaform.CsB-iKbU.mjs.map
+export { AttaformErrorCode as A, DEFAULT_TIMINGS as D, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, defaultCoercionRules as e, defaultDisplayState as f, defineCoercion as g, useAbstractForm as h, injectForm as i, isPlainRecord as j, safeAssign as k, lazy as l, makeDefaultDisplayState as m, slimKindOf as n, humanize as o, getAtPath as p, setAtPath as q, safeOwnRead as s, unset as u };
+//# sourceMappingURL=attaform.CuBdtfbe.mjs.map