attaform 0.22.0 → 0.24.0

package/dist/shared/{attaform.CjMcwV7W.cjs → attaform.C42wL7EJ.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.01iKS_lz.cjs');
+const paths = require('./attaform.DwkU0oY9.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -542,6 +542,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,54 +649,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:`;
@@ -1035,7 +1041,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]);
@@ -1154,7 +1160,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);
       },
@@ -1365,8 +1376,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;
     },
@@ -1374,37 +1384,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`:
@@ -1426,10 +1441,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;
@@ -1452,31 +1463,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);
     }
@@ -1515,9 +1520,8 @@ function buildFieldArrayApi(state) {
     return Array.isArray(current) ? current.slice() : [];
   }
   function writeArray(path, next, arrayOp) {
-    const { segments, key } = paths.canonicalizePath(path);
+    const { segments } = paths.canonicalizePath(path);
     const meta = {
-      persist: state.persistOptIns.hasAnyOptInForPath(key),
       ...arrayOp !== void 0 ? { arrayOp } : {}
     };
     return state.setValueAtPath(segments, next, meta);
@@ -1739,121 +1743,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.cjs');
-      return createLocalStorageAdapter();
-    }
-    case "session": {
-      const { createSessionStorageAdapter } = await import('../chunks/session-storage.cjs');
-      return createSessionStorageAdapter();
-    }
-    case "indexeddb": {
-      const { createIndexedDbAdapter } = await import('../chunks/indexeddb.cjs');
-      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 = paths.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
@@ -2111,44 +2000,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 = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function shouldWarnOnce$1(store, key) {
   if (warnedRejections === null) return false;
@@ -2478,16 +2329,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,
@@ -2498,18 +2340,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       segments,
       coerceIndex
     );
-    if (persist && !state.ssr && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
-      throw new paths.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 ? vue.computed(() => getDisplayStateAt(segments)) : void 0;
-    let boundElement = null;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2519,8 +2353,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           segments,
           slimDefault,
           withInstanceMeta({
-            blank: true,
-            persist
+            blank: true
           })
         );
       },
@@ -2528,7 +2361,6 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         state.markInteracted(segments);
       },
       registerElement: (element) => {
-        boundElement = element;
         if (!paths.INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
         if (added) attachFocusListeners(state, segments, element, instanceMeta);
@@ -2536,11 +2368,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(paths.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="…">`.
@@ -2578,15 +2408,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 } : {},
@@ -3023,12 +2844,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     const segments = paths.canonicalizePath(pathInput).segments;
     return vue.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(
@@ -3096,62 +2915,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);
@@ -3320,7 +3133,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();
@@ -3335,16 +3147,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 = paths.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) {
@@ -3352,31 +3158,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
     return setValueImpl(pathInput, unset);
   }
-  const persist = async (pathInput, options2) => {
-    const segments = paths.canonicalizePath(pathInput).segments;
-    if (!paths.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 = paths.canonicalizePath(pathInput).segments;
-    await persistence.clearPersistedDraft(segments);
-  };
   function touch(pathInput) {
     const segments = pathInput === void 0 ? paths.ROOT_PATH : paths.canonicalizePath(pathInput).segments;
     state.touchAtPath(segments);
@@ -3450,29 +3231,17 @@ 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);
   }
-  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 (vue.getCurrentScope() !== void 0) vue.onScopeDispose(stop);
-    return stop;
-  }
   const api = {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
@@ -3526,11 +3295,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;
@@ -3538,8 +3304,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),
@@ -3560,10 +3324,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     get blankPaths() {
       void state.activate();
       return blankPathsView;
-    },
-    onChange: onChangeImpl
+    }
   };
-  formHandle.current = api;
   return api;
 }
 
@@ -4075,168 +3837,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 } = paths.canonicalizePath(entry);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push({ segments, key, dotted: paths.segmentsToDotted(segments) });
-  }
-  return out;
+function mergeSparseHydration(schemaDefaults, sparse, schema) {
+  return mergeDeep(schemaDefaults, sparse, [], schema);
 }
-function makeResolver(source) {
-  if (source === void 0) {
-    const root = [{ segments: paths.ROOT_PATH, key: paths.ROOT_PATH_KEY, dotted: "" }];
-    return () => root;
-  }
-  if (typeof source !== "function" && !vue.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(vue.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 (paths.__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 (paths.__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 (paths.__DEV__) console.error("[attaform] onChange source getter threw:", error);
-        continue;
-      }
-      for (const source of sources) {
-        let changed;
-        for (const patch of patches) {
-          if (paths.isPathPrefix(source.segments, patch.path) || paths.isPathPrefix(patch.path, source.segments)) {
-            (changed ?? (changed = [])).push(paths.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 (paths.__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) {
@@ -4372,27 +4021,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 = paths.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 ?? paths.isSensitivePath;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const fieldValidatingSince = vue.reactive(/* @__PURE__ */ new Map());
@@ -4740,7 +4370,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;
@@ -5181,33 +4810,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: [...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]);
       }
     }
   }
@@ -5232,14 +4846,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()]) {
@@ -5261,8 +4874,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);
@@ -5456,25 +5074,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) {
@@ -5487,7 +5105,7 @@ function createFormStore(options) {
     });
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
-    applyFormReplacement(next, { silent: true });
+    applyFormReplacement(next);
     arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -5707,7 +5325,7 @@ function createFormStore(options) {
     clearSchemaErrors,
     applySchemaErrorsForSubtree,
     setAllUserErrors,
-    addUserErrors,
+    setUserErrorsForPath,
     clearUserErrors,
     getErrorsForPath,
     ensurePathOrdinal,
@@ -5733,7 +5351,6 @@ function createFormStore(options) {
     settleTransforms,
     scheduleFieldValidation,
     onFormChange,
-    registerOnChange: onChangeRegistry.register,
     onSubmitSuccess,
     onReset,
     emitSubmitSuccess,
@@ -5741,11 +5358,6 @@ function createFormStore(options) {
     registerDrain,
     awaitPendingWrites,
     modules,
-    persistOptIns,
-    isSensitivePath: resolvedIsSensitivePath,
-    noSyncPaths,
-    incrementNoSyncOptOut,
-    decrementNoSyncOptOut,
     coerceIndex,
     blankPaths,
     originalBlankPaths,
@@ -5753,6 +5365,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;
@@ -5763,12 +5402,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;
@@ -5862,10 +5527,6 @@ function createHistoryModule(state, config) {
       clear();
       return;
     }
-    if (meta?.crossTab === true) {
-      currentSnapshot.value = captureSnapshot();
-      return;
-    }
     const newSnap = captureSnapshot();
     const prevSnap = currentSnapshot.value;
     const formPatches = [];
@@ -5886,9 +5547,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);
@@ -5939,28 +5598,6 @@ function createHistoryModule(state, config) {
   };
 }
 
-const warned = /* @__PURE__ */ new Set();
-function warnOnceInsecureContext(feature) {
-  if (!paths.__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 };
@@ -5989,18 +5626,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 paths.AnonPersistError({
-      cause: "no-key",
-      schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: captureUserCallSite()
-    });
-  }
   const existing = registry.forms.get(key);
   if (paths.__DEV__ && existing !== void 0) {
     void import('../chunks/dev-key-collision-warnings.cjs').then((m) => {
       void m.warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-      m.warnOnPersistDivergence(key, existing, configuration.persist);
     });
   }
   const hadPendingHydration = registry.pendingHydration.has(key);
@@ -6028,85 +5657,6 @@ function useAbstractForm(configuration, options) {
     const releaseConsumer = registry.trackConsumer(key);
     vue.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.cjs'),
-              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.cjs'), 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);
@@ -6148,14 +5698,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 (vue.getCurrentScope() !== void 0) vue.onScopeDispose(stop);
-  }
   return api;
 }
 function mergeWithDefaults(defaults, configuration) {
@@ -6168,8 +5710,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,
@@ -6182,8 +5722,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 }
   };
 }
@@ -6199,8 +5737,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 : paths.createIsSensitivePath(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -6228,8 +5764,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(
@@ -6268,34 +5803,6 @@ function resolveFormKey(key) {
   }
   return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
 }
-async function resolvePersistFingerprintToken(state) {
-  try {
-    return hashStableString(await state.schema.fingerprint());
-  } catch (err) {
-    if (paths.__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 (paths.__DEV__)
-    throw new paths.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) {
@@ -7523,16 +7030,10 @@ function warnIfAmbientWizardProviderHadDuplicates() {
 }
 
 exports.AttaformErrorCode = AttaformErrorCode;
-exports.DEFAULT_PERSISTENCE_DEBOUNCE_MS = DEFAULT_PERSISTENCE_DEBOUNCE_MS;
 exports.DEFAULT_TIMINGS = DEFAULT_TIMINGS;
-exports.PERSISTENCE_MODULE_KEY = PERSISTENCE_MODULE_KEY;
-exports.applyPatchesForward = applyPatchesForward;
-exports.cleanupOrphanKeys = cleanupOrphanKeys;
 exports.defaultCoercionRules = defaultCoercionRules;
 exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
-exports.deleteAtPath = deleteAtPath;
-exports.diffAndApply = diffAndApply;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
 exports.injectForm = injectForm;
@@ -7541,17 +7042,12 @@ exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
 exports.lazy = lazy;
 exports.makeDefaultDisplayState = makeDefaultDisplayState;
-exports.mergeSparseHydration = mergeSparseHydration;
-exports.normalizeNumericOption = normalizeNumericOption;
-exports.normalizePersistConfig = normalizePersistConfig;
-exports.resolveStorageKeyBase = resolveStorageKeyBase;
 exports.safeAssign = safeAssign;
 exports.safeOwnRead = safeOwnRead;
 exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
-exports.structuralSnapshot = structuralSnapshot;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.CjMcwV7W.cjs.map
+//# sourceMappingURL=attaform.C42wL7EJ.cjs.map