attaform 0.21.2 → 0.23.0

package/dist/shared/{attaform.CTheKoTc.mjs → attaform.CtJOd7ox.mjs}

@@ -1,5 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
-import { _ as __DEV__, a as canonicalizePath, s as segmentsForPathKey, l as isPathPrefix, F as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, t as toError, A as AnonPersistError, q as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, w as allowSensitivePersist, x as FORM_ERRORS_PATH, y as coerceToPathKey, z as isSensitivePath, B as createPersistOptInRegistry, d as InvalidUseFormConfigError, C as ensureAttaformInstalled, u as useRegistry, E as kFormContext, G as kFormInstanceId, h as ReservedFormKeyError, H as createIsSensitivePath, J as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, k as kAttaformWizardActiveStepResolver, K as kAttaformAncestorWizard } from './attaform.DP-u7_tk.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__, a as canonicalizePath, s as segmentsForPathKey, F as FORM_ERRORS_PATH_KEY, q as keyForSegments, S as SubmitErrorHandlerError, t as toError, r as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, w as FORM_ERRORS_PATH, d as ROOT_PATH_KEY, x as coerceToPathKey, b as InvalidUseFormConfigError, y as ensureAttaformInstalled, u as useRegistry, z as kFormContext, B as kFormInstanceId, f as ReservedFormKeyError, C as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, k as kAttaformWizardActiveStepResolver, D as kAttaformAncestorWizard } from './attaform.BhI9Icek.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -34,7 +34,7 @@ function descendStep(value, segment) {
   if (typeof value !== "object") return NOT_FOUND;
   if (Array.isArray(value)) {
     if (typeof segment !== "number") return NOT_FOUND;
-    if (segment < 0 || segment >= value.length) return NOT_FOUND;
+    if (!(segment in value)) return NOT_FOUND;
     return value[segment];
   }
   const record = value;
@@ -69,7 +69,7 @@ function hasAtPath(root, path) {
   if (current === null || current === void 0) return false;
   if (typeof current !== "object") return false;
   if (Array.isArray(current)) {
-    return typeof last === "number" && last >= 0 && last < current.length;
+    return typeof last === "number" && last in current;
   }
   const key = typeof last === "number" ? String(last) : last;
   if (isShadowedKey(key)) return safeOwnHas(current, key);
@@ -98,6 +98,31 @@ function setAtPathOffset(root, path, value, offset) {
   safeAssign(rec, head, setAtPathOffset(safeOwnRead(rec, head), path, value, nextOffset));
   return rec;
 }
+const NO_IN_PLACE = { applied: false };
+function tryInPlaceLeafWrite(root, path, value) {
+  if (path.length === 0) return NO_IN_PLACE;
+  let node = root;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (Array.isArray(node)) {
+      if (typeof seg !== "number" || seg < 0 || seg >= node.length) return NO_IN_PLACE;
+    } else if (isPlainRecord(node)) {
+      if (typeof seg !== "string" || isShadowedKey(seg) || !(seg in node)) return NO_IN_PLACE;
+    } else {
+      return NO_IN_PLACE;
+    }
+    const container = node;
+    if (i < path.length - 1) {
+      node = container[seg];
+      continue;
+    }
+    const old = container[seg];
+    if (isPlainRecord(old) || Array.isArray(old)) return NO_IN_PLACE;
+    container[seg] = value;
+    return { applied: true, old };
+  }
+  return NO_IN_PLACE;
+}
 function deleteAtPath(root, path) {
   return deleteAtPathOffset(root, path, 0);
 }
@@ -401,7 +426,7 @@ function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
     diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
   }
 }
-function applyChangedKeys(target, source) {
+function applyChangedKeys(target, source, arrayOpPath, currentPath) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
@@ -419,11 +444,27 @@ function applyChangedKeys(target, source) {
   if (targetIsArray) {
     const t = target;
     const s = source;
-    if (t.length > s.length) t.length = s.length;
-    for (const idx of changedFirstSegments) {
-      if (typeof idx === "symbol") continue;
-      const i = typeof idx === "number" ? idx : Number(idx);
-      t[i] = s[i];
+    if (arrayOpPath === null || pathsEqual(currentPath, arrayOpPath)) {
+      if (t.length > s.length) t.length = s.length;
+      for (const idx of changedFirstSegments) {
+        if (typeof idx === "symbol") continue;
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        t[i] = s[i];
+      }
+    } else {
+      for (const idx of changedFirstSegments) {
+        if (typeof idx === "symbol") continue;
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        const childPath = appendSegment(currentPath, i);
+        const curEl = t[i];
+        const nextEl = s[i];
+        if (isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(curEl, nextEl, arrayOpPath, childPath)) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
     }
   } else {
     const t = target;
@@ -435,7 +476,14 @@ function applyChangedKeys(target, source) {
     for (const k of changedFirstSegments) {
       if (typeof k === "symbol") continue;
       const key = String(k);
-      safeAssign(t, key, safeOwnRead(s, key));
+      const nextVal = safeOwnRead(s, key);
+      if (arrayOpPath !== null) {
+        const curVal = safeOwnRead(t, key);
+        if (isDescendable(curVal) && isDescendable(nextVal) && applyChangedKeys(curVal, nextVal, arrayOpPath, appendSegment(currentPath, key))) {
+          continue;
+        }
+      }
+      safeAssign(t, key, nextVal);
     }
   }
   return true;
@@ -547,10 +595,52 @@ 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:`;
@@ -660,7 +750,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const original = state.originals.get(key)?.value;
   const pristine = state.isPristineAtPath(segments);
   const schemaForKey = state.schemaErrors.get(key);
-  const blankForKey = state.derivedBlankErrors.value.get(key);
+  const blankForKey = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments, state.formKey)] : void 0;
   const userForKey = state.userErrors.get(key);
   const errors = [];
   if (schemaForKey !== void 0) errors.push(...schemaForKey);
@@ -724,9 +814,32 @@ function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBa
     getDisplayState
   );
 }
+function visitActiveLeafPaths(value, base, visit) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const child = value[i];
+      if (Array.isArray(child) || isPlainRecord(child)) {
+        visitActiveLeafPaths(child, [...base, i], visit);
+      } else {
+        visit([...base, i]);
+      }
+    }
+    return;
+  }
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) {
+      const child = value[k];
+      if (Array.isArray(child) || isPlainRecord(child)) {
+        visitActiveLeafPaths(child, [...base, k], visit);
+      } else {
+        visit([...base, k]);
+      }
+    }
+  }
+}
 function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
-  const value = state.getValueAtPath(segments);
+  const value = getAtPath(formValue, segments);
   const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
@@ -745,12 +858,16 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let asyncPending = false;
   const submissionAttempts = state.submissionAttempts.value;
   const blurredLeafSegments = [];
-  for (const [leafKey, entry] of state.originals) {
-    if (!isPathPrefix(segments, entry.segments)) continue;
-    if (segments.length === entry.segments.length) continue;
-    if (!hasAtPath(formValue, entry.segments)) continue;
+  const descendantLeaves = [];
+  visitActiveLeafPaths(value, segments, (leafSegments) => {
+    const { key: leafKey } = keyForSegments(leafSegments);
+    const entry = state.originals.get(leafKey);
+    if (entry === void 0) return;
+    descendantLeaves.push({ key: leafKey, segments: entry.segments });
+  });
+  for (const { key: leafKey, segments: leafSeg } of descendantLeaves) {
     const leafRecord = state.fields.get(leafKey);
-    if (!state.isPristineAtPathByKey(leafKey, entry.segments)) {
+    if (!state.isPristineAtPathByKey(leafKey, leafSeg)) {
       pristine = false;
       dirty = true;
     }
@@ -761,7 +878,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (leafRecord?.interacted === true) interacted = true;
     if (leafRecord?.blurredAfterInteraction === true) {
       blurredAfterInteraction = true;
-      blurredLeafSegments.push(entry.segments);
+      blurredLeafSegments.push(leafSeg);
     }
     if (leafRecord?.connected === true) connected = true;
     if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) {
@@ -778,7 +895,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       if (leafGateOpen && since !== void 0 && (transformingSince === null || since < transformingSince))
         transformingSince = since;
     }
-    if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
+    if (state.pathHasAsyncValidationByKey(leafKey, leafSeg)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
@@ -1394,9 +1511,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);
@@ -1405,7 +1521,7 @@ function buildFieldArrayApi(state) {
     append(path, value) {
       const next = readArray(path);
       next.push(value);
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "insert", index: next.length - 1 });
     },
     prepend(path, value) {
       const next = readArray(path);
@@ -1618,157 +1734,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 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"
-};
-
 const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
@@ -2026,44 +1991,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;
@@ -2393,16 +2320,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,
@@ -2413,18 +2331,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,
@@ -2434,8 +2344,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           segments,
           slimDefault,
           withInstanceMeta({
-            blank: true,
-            persist
+            blank: true
           })
         );
       },
@@ -2443,7 +2352,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);
@@ -2451,11 +2359,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="…">`.
@@ -2493,15 +2399,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 } : {},
@@ -2794,19 +2691,116 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   const getFormMetaBase = () => {
-    const { base: rootBase } = buildContainerFieldStateBase(
+    let rollup;
+    const rootBase = () => rollup ?? (rollup = buildContainerFieldStateBase(
       state,
       ROOT_PATH,
       ROOT_PATH_KEY,
       formInstanceId
-    );
+    ).base);
     return {
-      ...rootBase,
+      // Rollup-derived (FieldStateBase) — the whole rollup builds once, on the
+      // first access of any of these.
+      get value() {
+        return rootBase().value;
+      },
+      get original() {
+        return rootBase().original;
+      },
+      get pristine() {
+        return rootBase().pristine;
+      },
+      get dirty() {
+        return rootBase().dirty;
+      },
+      get focused() {
+        return rootBase().focused;
+      },
+      get blurred() {
+        return rootBase().blurred;
+      },
+      get touched() {
+        return rootBase().touched;
+      },
+      get interacted() {
+        return rootBase().interacted;
+      },
+      get blurredAfterInteraction() {
+        return rootBase().blurredAfterInteraction;
+      },
+      get connected() {
+        return rootBase().connected;
+      },
+      get element() {
+        return rootBase().element;
+      },
+      get elements() {
+        return rootBase().elements;
+      },
+      get updatedAt() {
+        return rootBase().updatedAt;
+      },
+      get errors() {
+        return rootBase().errors;
+      },
+      get validating() {
+        return rootBase().validating;
+      },
+      get valid() {
+        return rootBase().valid;
+      },
+      get transforming() {
+        return rootBase().transforming;
+      },
+      get busy() {
+        return rootBase().busy;
+      },
+      get transformError() {
+        return rootBase().transformError;
+      },
+      get path() {
+        return rootBase().path;
+      },
+      get id() {
+        return rootBase().id;
+      },
+      get aria() {
+        return rootBase().aria;
+      },
+      get key() {
+        return rootBase().key;
+      },
+      get blank() {
+        return rootBase().blank;
+      },
+      get label() {
+        return rootBase().label;
+      },
+      get description() {
+        return rootBase().description;
+      },
+      get placeholder() {
+        return rootBase().placeholder;
+      },
+      get meta() {
+        return rootBase().meta;
+      },
+      get errorCount() {
+        return rootBase().errors.length;
+      },
+      // Form-level scalars — EAGER reads, tracked on every field-state eval.
+      // They are O(1) refs that never change on a keystroke, so tracking them
+      // per field costs nothing on the hot path. Kept eager (NOT lazy like the
+      // rollup) because behaviors beyond the predicate's own output depend on
+      // every field re-evaluating when they flip — most notably, the display
+      // engine is cleared on submit (revealing held spinners), and that
+      // imperative reset only becomes visible if `submitting` is a tracked dep
+      // of each field. Matches the pre-bust dependency set for these scalars
+      // exactly.
       submitting: state.submitting.value,
       submissionAttempts: state.submissionAttempts.value,
       departAttempts: state.departAttempts.value,
       submitError: state.submitError.value,
-      errorCount: rootBase.errors.length,
       submitted: state.submitted.value,
       instanceId: formInstanceId
     };
@@ -2842,13 +2836,16 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return computed(() => getAtPath(state.form.value, segments));
   }
   function setValueImpl(pathOrValue, maybeValue) {
-    if (arguments.length === 1) {
+    const argc = arguments.length;
+    const isPathForm = argc >= 2 && (typeof pathOrValue === "string" || Array.isArray(pathOrValue));
+    const writeMeta = (extra) => withInstanceMeta(extra);
+    if (!isPathForm) {
       const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
       const walked2 = walkUnsetSentinels(
         next,
         state.schema
       );
-      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, writeMeta());
       if (!ok2) return false;
       reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
@@ -2862,7 +2859,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
         if (parentDU?.discriminatorKey === last) {
           const slimDefault = state.schema.getEmptyValueAtPath(segments);
           const blank = blankForKind(slimDefault);
-          return state.setValueAtPath(segments, blank, withInstanceMeta({ blank: true }));
+          return state.setValueAtPath(segments, blank, writeMeta({ blank: true }));
         }
       }
       const blankPaths = [];
@@ -2873,9 +2870,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       const segmentsKey = canonicalizePath(segments).key;
       if (blankPaths.length === 1 && blankPaths[0] === segmentsKey) {
-        return state.setValueAtPath(segments, expanded, withInstanceMeta({ blank: true }));
+        return state.setValueAtPath(segments, expanded, writeMeta({ blank: true }));
       }
-      const ok2 = state.setValueAtPath(segments, expanded, withInstanceMeta());
+      const ok2 = state.setValueAtPath(segments, expanded, writeMeta());
       if (!ok2) return false;
       for (const pathKey of blankPaths) {
         const blankSegments = segmentsForPathKey(pathKey);
@@ -2883,7 +2880,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.setValueAtPath(
           blankSegments,
           state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
+          writeMeta({ blank: true })
         );
       }
       return true;
@@ -2903,7 +2900,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       segments,
       state.schema
     );
-    const ok = state.setValueAtPath(segments, walked.cleanedValues, withInstanceMeta());
+    const ok = state.setValueAtPath(segments, walked.cleanedValues, writeMeta());
     if (!ok) return false;
     reMarkBlanksAfterSubstitution(walked.paths);
     return true;
@@ -3133,7 +3130,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();
@@ -3148,16 +3144,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) {
@@ -3165,31 +3155,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);
@@ -3274,7 +3239,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
     return Object.freeze(out);
   }
-  return {
+  const api = {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
     // reactive containers (`meta`, `history`, `blankPaths`) are exposed
@@ -3339,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),
@@ -3363,6 +3326,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       return blankPathsView;
     }
   };
+  return api;
 }
 
 const IDLE = Object.freeze({ display: "idle" });
@@ -3789,6 +3753,7 @@ function createArrayBookkeeping(deps) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -3816,6 +3781,7 @@ function createArrayBookkeeping(deps) {
     }));
     migrateSetSubtree(blankPaths, arrayPath, remap);
     migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateSetSubtree(authoredPaths, arrayPath, remap);
     migrateMapSubtree(fieldValidatingSince, arrayPath, remap, (since) => since);
     migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
     arrayIdentity.applyRemap(arrayPath, remap);
@@ -3859,7 +3825,7 @@ function createArrayBookkeeping(deps) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(key);
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -3871,6 +3837,57 @@ function createArrayBookkeeping(deps) {
   };
 }
 
+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;
+}
+
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
@@ -3955,6 +3972,17 @@ function walkAuthoredFromConstraints(value, prefix, out) {
     }
   }
 }
+function freshElementIndices(op) {
+  switch (op.kind) {
+    case "insert":
+    case "replace-at":
+      return [op.index];
+    case "remove":
+    case "swap":
+    case "move":
+      return [];
+  }
+}
 function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
   if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
     const left = withDefaults;
@@ -3993,26 +4021,8 @@ function createFormStore(options) {
   const formChangeListeners = /* @__PURE__ */ new Set();
   const submitSuccessListeners = /* @__PURE__ */ new Set();
   const resetListeners = /* @__PURE__ */ new Set();
-  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());
@@ -4031,11 +4041,8 @@ function createFormStore(options) {
     if (constraints !== void 0) {
       walkAuthoredFromConstraints(constraints, [], authoredPaths);
     }
-    const slimResponse = schema.getDefaultValues({
-      useDefaultSchemaValues: false,
-      strict
-    });
-    walkAuthoredFromSchemaDiff(schemaWithDefaultsData, slimResponse.data, [], authoredPaths);
+    const slimBaseline = schema.getEmptyValueAtPath([]);
+    walkAuthoredFromSchemaDiff(schemaWithDefaultsData, slimBaseline, [], authoredPaths);
   }
   rebuildAuthoredPaths(defaultValues, schemaInitialData);
   function filterAuthoredErrors(errors) {
@@ -4054,7 +4061,7 @@ function createFormStore(options) {
   });
   const form = ref(stubbedInitialData);
   const arrayIdentity = createArrayIdentity((arraySegs) => {
-    const v = getAtPath(form.value, arraySegs);
+    const v = getAtPath(toRaw(form.value), arraySegs);
     return Array.isArray(v) ? v.length : 0;
   });
   function arrayElementKey(path) {
@@ -4097,14 +4104,7 @@ function createFormStore(options) {
       const segments = segmentsForPathKey(pathKey);
       if (segments === null) continue;
       if (!schema.isRequiredAtPath(segments)) continue;
-      result.set(pathKey, [
-        {
-          message: "No value supplied",
-          path: [...segments],
-          formKey,
-          code: AttaformErrorCode.NoValueSupplied
-        }
-      ]);
+      result.set(pathKey, [makeBlankRequiredError(segments, formKey)]);
     }
     return result;
   });
@@ -4344,6 +4344,7 @@ function createFormStore(options) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -4353,17 +4354,8 @@ function createFormStore(options) {
     touchFieldRecord,
     decFieldValidation
   });
-  function applyFormReplacement(next, meta) {
-    const prev = form.value;
-    if (Object.is(prev, next)) return;
+  function commitWritePatches(patches, meta) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const patches = [];
-    diffAndApply(prev, next, [], (patch) => {
-      patches.push(patch);
-    });
-    if (!applyChangedKeys(prev, next)) {
-      form.value = next;
-    }
     for (const patch of patches) {
       const { key } = canonicalizePath(patch.path);
       if (patch.kind === "added" && !originals.has(key)) {
@@ -4379,9 +4371,61 @@ function createFormStore(options) {
       }
     }
   }
+  function applyFormReplacementWithPath(next, meta, arrayOpPath) {
+    const prev = form.value;
+    if (Object.is(prev, next)) return;
+    const patches = [];
+    diffAndApply(prev, next, [], (patch) => {
+      patches.push(patch);
+    });
+    if (!applyChangedKeys(prev, next, arrayOpPath, [])) {
+      form.value = next;
+    } else if (patches.some(
+      (p) => p.path.length > 0 && typeof p.path[0] === "string" && isShadowedKey(p.path[0])
+    )) {
+      triggerRef(form);
+    }
+    commitWritePatches(patches, meta);
+  }
+  function applyFormReplacement(next, meta) {
+    applyFormReplacementWithPath(next, meta, null);
+  }
+  function applyTargetedWrite(path, completedValue, meta) {
+    const result = tryInPlaceLeafWrite(form.value, path, completedValue);
+    if (!result.applied) {
+      applyFormReplacementWithPath(
+        setAtPathWithSchemaFill(form.value, schema, path, completedValue),
+        meta,
+        meta?.arrayOp !== void 0 ? path : null
+      );
+      return;
+    }
+    const patches = [];
+    diffAndApply(result.old, completedValue, path, (patch) => {
+      patches.push(patch);
+    });
+    commitWritePatches(patches, meta);
+  }
   function setValueAtPath(path, value, meta) {
-    value = stripSymbolsDeep(value);
-    if (!isSlimPrimitiveValid(schema, form, path, value)) {
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        value[idx] = stripSymbolsDeep(value[idx]);
+      }
+    } else {
+      value = stripSymbolsDeep(value);
+    }
+    let slimOk = true;
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        if (!isSlimPrimitiveValid(schema, form, [...path, idx], value[idx])) {
+          slimOk = false;
+          break;
+        }
+      }
+    } else {
+      slimOk = isSlimPrimitiveValid(schema, form, path, value);
+    }
+    if (!slimOk) {
       return false;
     }
     if (path.length >= 2) {
@@ -4474,22 +4518,37 @@ function createFormStore(options) {
         }
       }
     }
+    const currentValue = getAtPath(form.value, path);
     const pathKey = canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
     } else {
       if (blankPaths.has(pathKey)) blankPaths.delete(pathKey);
-      if (meta?.arrayOp === void 0) {
+      if (meta?.arrayOp === void 0 && (isPlainRecord(currentValue) || Array.isArray(currentValue))) {
         for (const existingKey of [...blankPaths]) {
           if (isPathKeyUnder(existingKey, path)) blankPaths.delete(existingKey);
         }
       }
     }
     const wasAuthoredBefore = authoredPaths.has(pathKey);
-    walkAuthoredFromConstraints(value, path, authoredPaths);
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      if (path.length > 0) authoredPaths.add(pathKey);
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        walkAuthoredFromConstraints(value[idx], [...path, idx], authoredPaths);
+      }
+    } else {
+      walkAuthoredFromConstraints(value, path, authoredPaths);
+    }
     const newlyAuthored = !wasAuthoredBefore && authoredPaths.has(pathKey);
-    const completedValue = mergeStructural(schema, path, value);
-    const currentValue = getAtPath(form.value, path);
+    let completedValue;
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        value[idx] = mergeStructural(schema, [...path, idx], value[idx]);
+      }
+      completedValue = value;
+    } else {
+      completedValue = mergeStructural(schema, path, value);
+    }
     if (Object.is(currentValue, completedValue)) {
       if (newlyAuthored && schema.isPreprocessOrCoerceLeaf(path)) {
         const modeForAuthoringTransition = meta?.instance?.validateOn ?? fieldValidationMode;
@@ -4503,8 +4562,7 @@ function createFormStore(options) {
       return true;
     }
     const oldArrayLength = Array.isArray(currentValue) ? currentValue.length : 0;
-    const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
-    applyFormReplacement(nextForm, meta);
+    applyTargetedWrite(path, completedValue, meta);
     if (meta?.arrayOp !== void 0) {
       const remap = remapForOp(meta.arrayOp, oldArrayLength);
       arrayBookkeeping.migrateElementState(path, remap);
@@ -4587,7 +4645,7 @@ function createFormStore(options) {
         const prevValidation = fieldValidationState.get(parentKey2);
         if (prevValidation !== void 0) {
           if (prevValidation.timer !== null) clearTimeout(prevValidation.timer);
-          prevValidation.controller.abort();
+          prevValidation.aborted = true;
           fieldValidationState.delete(parentKey2);
         }
         appliedSync = true;
@@ -4611,15 +4669,19 @@ function createFormStore(options) {
     const prev = fieldValidationState.get(key);
     if (prev !== void 0) {
       if (prev.timer !== null) clearTimeout(prev.timer);
-      prev.controller.abort();
+      prev.aborted = true;
     }
-    const controller = new AbortController();
-    const fresh = { controller, timer: null, settled: false, released: false };
+    const fresh = {
+      aborted: false,
+      timer: null,
+      settled: false,
+      released: false
+    };
     fieldValidationState.set(key, fresh);
     const myEpoch = ++scheduleEpoch;
     const run = () => {
       fresh.timer = null;
-      if (controller.signal.aborted) return;
+      if (fresh.aborted) return;
       let activeIncremented = false;
       try {
         activeValidations.value += 1;
@@ -4636,7 +4698,7 @@ function createFormStore(options) {
       const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
       const scopeKey = subtreeScope ? canonicalizePath(path).key : ROOT_PATH_KEY;
       void Promise.resolve().then(() => schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
-        if (controller.signal.aborted) return;
+        if (fresh.aborted) return;
         if (myEpoch <= lastCommittedEpoch) return;
         lastCommittedEpoch = myEpoch;
         if (effectiveMode === "blur") {
@@ -4673,7 +4735,7 @@ function createFormStore(options) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(pkey);
       }
-      entry.controller.abort();
+      entry.aborted = true;
     }
     fieldValidationState.clear();
   }
@@ -4689,7 +4751,7 @@ function createFormStore(options) {
         decFieldValidation(key);
         entry.released = true;
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -4748,9 +4810,6 @@ function createFormStore(options) {
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
-    persistOptIns.clear();
-    noSyncPaths.clear();
-    noSyncPathCounts.clear();
   }
   function getValueAtPath(path) {
     return getAtPath(form.value, path);
@@ -5306,11 +5365,6 @@ function createFormStore(options) {
     registerDrain,
     awaitPendingWrites,
     modules,
-    persistOptIns,
-    isSensitivePath: resolvedIsSensitivePath,
-    noSyncPaths,
-    incrementNoSyncOptOut,
-    decrementNoSyncOptOut,
     coerceIndex,
     blankPaths,
     originalBlankPaths,
@@ -5318,6 +5372,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;
@@ -5328,13 +5409,6 @@ function captureErrorEntries(map) {
   for (const [k, v] of map) out.push([k, [...v]]);
   return out;
 }
-function pathsEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let j = 0; j < a.length; j++) {
-    if (a[j] !== b[j]) return false;
-  }
-  return true;
-}
 function errorFieldsEqual(av, bvi) {
   if (av === bvi) return true;
   if (av.message !== bvi.message) return false;
@@ -5434,10 +5508,6 @@ function createHistoryModule(state, config) {
       clear();
       return;
     }
-    if (meta?.crossTab === true) {
-      currentSnapshot.value = captureSnapshot();
-      return;
-    }
     const newSnap = captureSnapshot();
     const prevSnap = currentSnapshot.value;
     const formPatches = [];
@@ -5458,9 +5528,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);
@@ -5511,28 +5579,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 };
@@ -5561,18 +5607,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);
@@ -5600,85 +5638,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);
@@ -5719,11 +5678,8 @@ function useAbstractForm(configuration, options) {
   if (merged.autoAria !== void 0) {
     apiOptions.autoAria = merged.autoAria;
   }
-  return buildFormApi(
-    state,
-    formInstanceId,
-    apiOptions
-  );
+  const api = buildFormApi(state, formInstanceId, apiOptions);
+  return api;
 }
 function mergeWithDefaults(defaults, configuration) {
   const strict = configuration.strict ?? defaults.strict;
@@ -5735,8 +5691,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,
@@ -5749,8 +5703,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 }
   };
 }
@@ -5766,8 +5718,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,
@@ -5795,8 +5745,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(
@@ -5835,34 +5784,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) {
@@ -7089,5 +7010,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.CTheKoTc.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, normalizeNumericOption as n, slimKindOf as o, humanize as p, getAtPath as q, setAtPath as r, safeOwnRead as s, unset as u };
+//# sourceMappingURL=attaform.CtJOd7ox.mjs.map