attaform 0.19.0 → 0.20.1

package/dist/shared/{attaform.BTi-PsHr.mjs → attaform.BqZuwLTK.mjs}

@@ -1,5 +1,28 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
-import { _ as __DEV__, i as canonicalizePath, H as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, E as pathKeyToDotted, g as SubmitErrorHandlerError, A as AnonPersistError, j as captureUserCallSite, d as ROOT_PATH_KEY, R as ROOT_PATH, q as enforceSensitiveCheck, F as FORM_ERRORS_PATH, k as coerceToPathKey, G as segmentMatchesSensitive, v as isSensitivePath, n as createPersistOptInRegistry, c as InvalidUseFormConfigError, r as ensureAttaformInstalled, K as useRegistry, z as kFormContext, B as kFormInstanceId, f as ReservedFormKeyError, m as createIsSensitivePath, p as createSegmentMatchesSensitive, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.CrpjyXdO.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, toRaw, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
+import { _ as __DEV__, j as canonicalizePath, E as segmentsForPathKey, s as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, u as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, H as useRegistry, y as kFormContext, z as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, x as kAttaformWizardActiveStepResolver, v as kAttaformAncestorWizard } from './attaform.BKozEdTr.mjs';
+
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function safeOwnRead(target, key) {
+  if (key === "__proto__") {
+    const desc = Object.getOwnPropertyDescriptor(target, "__proto__");
+    return desc?.value;
+  }
+  return target[key];
+}
+function safeOwnHas(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -63,7 +86,7 @@ function setAtPathOffset(root, path, value, offset) {
     return arr;
   }
   const rec = isPlainRecord(root) ? { ...root } : {};
-  rec[head] = setAtPathOffset(rec[head], path, value, nextOffset);
+  safeAssign(rec, head, setAtPathOffset(safeOwnRead(rec, head), path, value, nextOffset));
   return rec;
 }
 function deleteAtPath(root, path) {
@@ -92,9 +115,9 @@ function deleteAtPathOffset(root, path, offset) {
     delete rec2[head];
     return rec2;
   }
-  if (!(head in root)) return root;
+  if (!safeOwnHas(root, head)) return root;
   const rec = { ...root };
-  rec[head] = deleteAtPathOffset(rec[head], path, nextOffset);
+  safeAssign(rec, head, deleteAtPathOffset(safeOwnRead(rec, head), path, nextOffset));
   return rec;
 }
 function resolveArrayShape(schema, scratch) {
@@ -165,25 +188,25 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
     let mutated = false;
     const out = { ...consumer };
     for (const key of Object.keys(defaultValue)) {
-      if (!(key in consumer)) {
-        const defAtKey = defaultValue[key];
+      if (!safeOwnHas(consumer, key)) {
+        const defAtKey = safeOwnRead(defaultValue, key);
         scratch.push(key);
         const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
         scratch.pop();
         if (filled !== void 0) {
-          out[key] = filled;
+          safeAssign(out, key, filled);
           mutated = true;
         }
       }
     }
     for (const key of Object.keys(consumer)) {
-      const cVal = consumer[key];
+      const cVal = safeOwnRead(consumer, key);
       if (cVal === void 0) continue;
       scratch.push(key);
-      const merged = mergeStructuralImpl(schema, scratch, cVal, defaultValue[key]);
+      const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
       scratch.pop();
       if (merged !== cVal) {
-        out[key] = merged;
+        safeAssign(out, key, merged);
         mutated = true;
       }
     }
@@ -377,7 +400,8 @@ function applyChangedKeys(target, source) {
     }
     for (const k of changedFirstSegments) {
       if (typeof k === "symbol") continue;
-      t[String(k)] = s[String(k)];
+      const key = String(k);
+      safeAssign(t, key, safeOwnRead(s, key));
     }
   }
   return true;
@@ -429,7 +453,7 @@ function structuralSnapshot(value) {
   const src = value;
   const out = {};
   for (const k of Object.keys(src)) {
-    out[k] = structuralSnapshot(src[k]);
+    safeAssign(out, k, structuralSnapshot(safeOwnRead(src, k)));
   }
   return out;
 }
@@ -488,7 +512,7 @@ function hashStableString(input, seed = 0) {
 const ANON_STEM = "atta";
 function readableFormKeyStem(formKey) {
   if (formKey === "" || formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return ANON_STEM;
-  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|(?<!-)-+$/g, "");
   return sanitized === "" ? ANON_STEM : sanitized;
 }
 function fieldIdToken(formInstanceId, pathKey) {
@@ -522,6 +546,7 @@ function humanize(segment) {
   }).join(" ");
 }
 
+const warnedDisplayStatePredicates = /* @__PURE__ */ new WeakSet();
 function isUnderStubAncestor(state, segments) {
   for (let i = 0; i < segments.length; i++) {
     const ancestorPath = segments.slice(0, i);
@@ -605,7 +630,7 @@ function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBa
 function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
   const value = state.getValueAtPath(segments);
-  const original = state.originals.get(canonicalizePath(segments).key)?.value;
+  const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
   let dirty = false;
@@ -618,13 +643,12 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let validating = false;
   let updatedAt = null;
   let asyncPending = false;
-  for (const [, entry] of state.originals) {
+  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 leafKey = canonicalizePath(entry.segments).key;
     const leafRecord = state.fields.get(leafKey);
-    if (!state.isPristineAtPath(entry.segments)) {
+    if (!state.isPristineAtPathByKey(leafKey, entry.segments)) {
       pristine = false;
       dirty = true;
     }
@@ -636,7 +660,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (leafRecord?.blurredAfterInteraction === true) blurredAfterInteraction = true;
     if (leafRecord?.connected === true) connected = true;
     if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) validating = true;
-    if (state.pathHasAsyncValidation(entry.segments)) asyncPending = true;
+    if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
@@ -691,7 +715,14 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState)
   let displayState;
   try {
     displayState = predicate(base, formMeta);
-  } catch {
+  } catch (err) {
+    if (__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
+      warnedDisplayStatePredicates.add(predicate);
+      console.warn(
+        "[attaform] custom getDisplayState threw \u2014 falling back to defaultDisplayState. Subsequent throws from the same predicate will not warn again.",
+        err
+      );
+    }
     displayState = defaultDisplayState(base, formMeta);
   }
   return {
@@ -728,6 +759,41 @@ function aggregateErrorsAt(state, prefix) {
 }
 const EMPTY_ELEMENTS = Object.freeze([]);
 
+function liveKeysAtPath(state, segments) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    const keys = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
+    return keys;
+  }
+  if (typeof value === "object") return Object.keys(value);
+  return [];
+}
+function isArrayPath(state, segments) {
+  if (segments.length === 0) return false;
+  return Array.isArray(getAtPath(state.form.value, segments));
+}
+
+function warnReadOnly(surface, action, key) {
+  if (!__DEV__) return;
+  const phrase = action === "write" ? `write to "${String(key)}"` : `${action} of "${String(key)}"`;
+  console.warn(
+    `[attaform] ${surface} is read-only \u2014 ${phrase} was ignored. Mutate the form via setValue / the directive / field-array helpers instead.`
+  );
+}
+function makeReadonlyCoercion(snapshot) {
+  const toString = () => JSON.stringify(snapshot());
+  return {
+    toString,
+    valueOf() {
+      return this;
+    },
+    toJSON: snapshot,
+    toPrimitive: (hint) => hint === "number" ? NaN : toString()
+  };
+}
+
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
@@ -759,12 +825,12 @@ function buildSurfaceProxy(opts) {
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const snapshotContainer = () => opts.materializeContainer === void 0 ? {} : opts.materializeContainer(segments);
-    const containerToJSON = () => snapshotContainer();
-    const containerToString = () => JSON.stringify(snapshotContainer());
-    function containerValueOf() {
-      return this;
-    }
-    const containerToPrimitive = (hint) => hint === "number" ? NaN : containerToString();
+    const {
+      toString: containerToString,
+      valueOf: containerValueOf,
+      toJSON: containerToJSON,
+      toPrimitive: containerToPrimitive
+    } = makeReadonlyCoercion(snapshotContainer);
     const target = isArrayLike ? [] : (() => {
     });
     const proxy = new Proxy(target, {
@@ -789,6 +855,9 @@ function buildSurfaceProxy(opts) {
           return opts.containerOwnKeys === void 0 ? 0 : opts.containerOwnKeys(segments).length;
         }
         const childSegs = [...segments, keyToSegment(key)];
+        if ((isArrayLike || opts.isArrayContainer?.(segments) === true) && typeof keyToSegment(key) === "string" && key in Array.prototype) {
+          return Reflect.get(Array.prototype, key);
+        }
         if (key === "toString" || key === "valueOf") {
           if (!schemaHasPath(childSegs)) {
             return key === "toString" ? containerToString : containerValueOf;
@@ -833,10 +902,25 @@ function buildSurfaceProxy(opts) {
         };
       },
       // Block writes at the proxy boundary. Mutations go through
-      // `setValue`, the directive, or the field-array helpers.
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // `setValue`, the directive, or the field-array helpers. Each
+      // trap returns `true` (warn-and-noop) — returning `false` from a
+      // `set`/`delete`/`defineProperty` trap throws `TypeError` under
+      // strict mode (every ESM / `<script setup>`), which would surface
+      // a host-level exception in consumer code that the library
+      // documents as "writes are ignored." Aligns with the contract on
+      // `form.values` / `wizard.statuses`.
+      set: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "write", key);
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "delete", key);
+        return true;
+      },
+      defineProperty: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "define", key);
+        return true;
+      }
     });
     containerCache.set(cacheKey, proxy);
     return proxy;
@@ -858,11 +942,12 @@ function buildSurfaceProxy(opts) {
       }
       return snapshot;
     };
-    const leafToString = () => JSON.stringify(snapshotLeaf());
-    function leafValueOf() {
-      return this;
-    }
-    const leafToPrimitive = (hint) => hint === "number" ? NaN : leafToString();
+    const {
+      toString: leafToString,
+      valueOf: leafValueOf,
+      toJSON: leafToJSONHandler,
+      toPrimitive: leafToPrimitive
+    } = makeReadonlyCoercion(snapshotLeaf);
     const target = (() => {
     });
     const proxy = new Proxy(target, {
@@ -880,7 +965,7 @@ function buildSurfaceProxy(opts) {
         if (typeof key !== "string") return void 0;
         if (key === "toString") return leafToString;
         if (key === "valueOf") return leafValueOf;
-        if (key === "toJSON") return snapshotLeaf;
+        if (key === "toJSON") return leafToJSONHandler;
         if (leafKeys.has(key)) {
           const leaf = opts.resolveLeaf(segments);
           return readLeafKey(leaf, key);
@@ -907,9 +992,22 @@ function buildSurfaceProxy(opts) {
           writable: false
         };
       },
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // Same warn-and-noop contract as the container traps above.
+      // Returning `true` keeps strict-mode callers from throwing on
+      // `form.fields.email.value = …`; the actual readonly guarantee
+      // is the absence of any mutation, not the host-level reject.
+      set: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "write", key);
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "delete", key);
+        return true;
+      },
+      defineProperty: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "define", key);
+        return true;
+      }
     });
     leafViewCache.set(cacheKey, proxy);
     return proxy;
@@ -973,29 +1071,49 @@ function buildErrorsProxy(state) {
     // working — the call-form just extends that semantic to
     // containers and dynamic paths.
     resolveCallTarget: (path) => aggregateErrorsAt(state, path),
-    // Mirror `form.fields` enumeration: `Object.keys(form.errors.items)`
-    // and `v-for="(errs, idx) in form.errors.items"` walk the live
-    // array indices / object keys at the path. Iteration yields the
-    // descended sub-proxies (one per live key), so consumers can
-    // `form.errors.items[idx]` straight from the entry.
-    containerOwnKeys: (segments) => liveKeysAtPath$1(state, segments),
-    isArrayContainer: (segments) => isArrayPath$1(state, segments)
+    // 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']`).
+    //
+    // The union closes that gap so `ownKeys` agrees with the rest of
+    // the surface. Active-path filter mirrors `resolveLeaf`:
+    // library-produced verdicts (schema + derived-blank) at unreachable
+    // paths stay hidden; user-supplied errors are unconditional.
+    containerOwnKeys: (segments) => errorAwareContainerKeys(state, segments),
+    isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
-function liveKeysAtPath$1(state, segments) {
-  const value = getAtPath(state.form.value, segments);
-  if (value === null || value === void 0) return [];
-  if (Array.isArray(value)) {
-    const keys = new Array(value.length);
-    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
-    return keys;
-  }
-  if (typeof value === "object") return Object.keys(value);
-  return [];
-}
-function isArrayPath$1(state, segments) {
-  if (segments.length === 0) return false;
-  return Array.isArray(getAtPath(state.form.value, segments));
+function errorAwareContainerKeys(state, segments) {
+  const keys = new Set(liveKeysAtPath(state, segments));
+  const formValue = state.form.value;
+  const walk = (store, applyActivePathFilter) => {
+    for (const [pathKey, errors] of store) {
+      if (errors.length === 0) continue;
+      if (pathKey === FORM_ERRORS_PATH_KEY) {
+        if (segments.length === 0) keys.add("");
+        continue;
+      }
+      const decoded = segmentsForPathKey(pathKey);
+      if (decoded === null) continue;
+      if (decoded.length <= segments.length) continue;
+      if (!isPathPrefix(segments, decoded)) continue;
+      if (applyActivePathFilter && !hasAtPath(formValue, decoded)) continue;
+      const nextSeg = decoded[segments.length];
+      keys.add(typeof nextSeg === "number" ? String(nextSeg) : nextSeg);
+    }
+  };
+  walk(state.schemaErrors, true);
+  walk(state.derivedBlankErrors.value, true);
+  walk(state.userErrors, false);
+  return [...keys];
 }
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
@@ -1047,18 +1165,18 @@ function placeAt(tree, path, errors) {
     const nextSeg = path[i + 1];
     const key = typeof seg === "number" ? String(seg) : seg;
     const cursorRecord2 = cursor;
-    let child = cursorRecord2[key];
+    let child = safeOwnRead(cursorRecord2, key);
     if (child === null || child === void 0 || typeof child !== "object") {
       child = typeof nextSeg === "number" ? [] : {};
-      cursorRecord2[key] = child;
+      safeAssign(cursorRecord2, key, child);
     }
     cursor = child;
   }
   const lastSeg = path[path.length - 1];
   const lastKey = typeof lastSeg === "number" ? String(lastSeg) : lastSeg;
   const cursorRecord = cursor;
-  const existing = cursorRecord[lastKey];
-  cursorRecord[lastKey] = Array.isArray(existing) ? [...existing, ...errors] : errors;
+  const existing = safeOwnRead(cursorRecord, lastKey);
+  safeAssign(cursorRecord, lastKey, Array.isArray(existing) ? [...existing, ...errors] : errors);
 }
 
 function buildFieldArrayApi(state) {
@@ -1088,9 +1206,10 @@ function buildFieldArrayApi(state) {
     },
     insert(path, index, value) {
       const next = readArray(path);
-      next.splice(index, 0, value);
-      const clampedIndex = Math.max(0, Math.min(index, next.length));
-      return writeArray(path, next, { kind: "insert", index: clampedIndex });
+      const preLen = next.length;
+      const insertIndex = index < 0 ? Math.max(0, preLen + index) : Math.min(index, preLen);
+      next.splice(insertIndex, 0, value);
+      return writeArray(path, next, { kind: "insert", index: insertIndex });
     },
     remove(path, index) {
       const next = readArray(path);
@@ -1212,9 +1331,34 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
           writable: false
         };
       },
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // Warn-and-noop: returning `false` here throws `TypeError` under
+      // strict mode (`form.fields('email').value = 1` from any ESM
+      // module), which would violate the documented "writes are
+      // ignored" contract. Mirrors `values-proxy` / `wizard-statuses-proxy`.
+      set: (_, key) => {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
+          );
+        }
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 delete of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      },
+      defineProperty: (_, key) => {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 define of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      }
     });
     terminalCache.set(cacheKey, proxy);
     return proxy;
@@ -1230,21 +1374,6 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
     isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
-function liveKeysAtPath(state, segments) {
-  const value = getAtPath(state.form.value, segments);
-  if (value === null || value === void 0) return [];
-  if (Array.isArray(value)) {
-    const keys = new Array(value.length);
-    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
-    return keys;
-  }
-  if (typeof value === "object") return Object.keys(value);
-  return [];
-}
-function isArrayPath(state, segments) {
-  if (segments.length === 0) return false;
-  return Array.isArray(getAtPath(state.form.value, segments));
-}
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
   const liveValue = getAtPath(state.form.value, containerSegments);
   return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
@@ -1288,7 +1417,7 @@ async function getStorageAdapter(storage) {
     }
   }
 }
-const PERSISTED_ENVELOPE_VERSION = 5;
+const PERSISTED_ENVELOPE_VERSION = 6;
 function readPersistedPayload(value) {
   if (value === null || value === void 0 || typeof value !== "object") return null;
   const envelope = value;
@@ -1312,12 +1441,7 @@ function warnVersionMismatch(observedVersion) {
 function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
   let transientList;
   if (blankPaths !== void 0 && blankPaths.size > 0) {
-    const dotted = [];
-    for (const key of blankPaths) {
-      const d = pathKeyToDotted(key);
-      if (d !== null) dotted.push(d);
-    }
-    transientList = dotted.length > 0 ? dotted : void 0;
+    transientList = [...blankPaths];
   }
   if (include === "form") {
     if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
@@ -1339,30 +1463,35 @@ function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPat
 function createDebouncedWriter(write, debounceMs) {
   let timer = null;
   let pending = null;
+  let writeGeneration = 0;
+  function runWrite() {
+    const gen = ++writeGeneration;
+    pending = write().finally(() => {
+      if (writeGeneration === gen) pending = null;
+    });
+  }
   function schedule() {
     if (timer !== null) clearTimeout(timer);
     if (debounceMs === 0) {
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
       return;
     }
     timer = setTimeout(() => {
       timer = null;
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
     }, debounceMs);
   }
   async function flush() {
     if (timer !== null) {
       clearTimeout(timer);
       timer = null;
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
+    }
+    while (pending !== null) {
+      const awaited = pending;
+      await awaited;
+      if (pending === awaited) break;
     }
-    if (pending !== null) await pending;
   }
   function cancel() {
     if (timer !== null) {
@@ -1375,7 +1504,7 @@ function createDebouncedWriter(write, debounceMs) {
 function resolveStorageKeyBase(config, formKey) {
   return config.key ?? `${PERSISTENCE_KEY_PREFIX}${formKey}`;
 }
-async function cleanupOrphanKeys(adapter, base, currentKey) {
+async function removeMatchingKeys(adapter, base, keepKey) {
   let keys;
   try {
     keys = await adapter.listKeys(base);
@@ -1383,12 +1512,15 @@ async function cleanupOrphanKeys(adapter, base, currentKey) {
     return;
   }
   for (const key of keys) {
-    if (key === currentKey) continue;
+    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 };
@@ -1399,12 +1531,7 @@ async function sweepAllOrphansAcrossStandardStores(base) {
   for (const kind of STANDARD_STORAGE_KINDS) {
     try {
       const adapter = await getStorageAdapter(kind);
-      const keys = await adapter.listKeys(base);
-      for (const key of keys) {
-        if (key === base || key.startsWith(`${base}:`)) {
-          void adapter.removeItem(key).catch(() => void 0);
-        }
-      }
+      await removeMatchingKeys(adapter, base);
     } catch {
     }
   }
@@ -1415,12 +1542,7 @@ async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
     if (kind === configuredKind) continue;
     try {
       const adapter = await getStorageAdapter(kind);
-      const keys = await adapter.listKeys(base);
-      for (const key of keys) {
-        if (key === base || key.startsWith(`${base}:`)) {
-          void adapter.removeItem(key).catch(() => void 0);
-        }
-      }
+      await removeMatchingKeys(adapter, base);
     } catch {
     }
   }
@@ -1436,6 +1558,29 @@ function pluckPaths(form, pathKeys) {
   }
   return sparse ?? {};
 }
+function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
+  const acknowledgedSensitive = [];
+  for (const key of optedInPaths) {
+    const segs = segmentsForPathKey(key);
+    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
+  }
+  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => isPathPrefix(prefix, path));
+  const walk = (path, value) => {
+    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {
+      return void 0;
+    }
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
+    if (!isPlainRecord(value)) return value;
+    const out = {};
+    for (const key of Object.keys(value)) {
+      const walked = walk([...path, key], value[key]);
+      if (walked !== void 0) safeAssign(out, key, walked);
+    }
+    return out;
+  };
+  return walk([], form);
+}
 function filterErrorsByPaths(errors, pathKeys) {
   const out = /* @__PURE__ */ new Map();
   for (const [key, value] of errors) {
@@ -1464,8 +1609,17 @@ function mergeDeep(target, source, path, schema) {
         if (isPlainRecord(variantDefault)) {
           const out2 = { ...variantDefault };
           for (const key of Object.keys(sourceRecord)) {
-            if (!(key in variantDefault) && key !== du.discriminatorKey) continue;
-            out2[key] = mergeDeep(out2[key], sourceRecord[key], [...path, key], schema);
+            if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
+            safeAssign(
+              out2,
+              key,
+              mergeDeep(
+                safeOwnRead(out2, key),
+                safeOwnRead(sourceRecord, key),
+                [...path, key],
+                schema
+              )
+            );
           }
           return out2;
         }
@@ -1476,7 +1630,16 @@ function mergeDeep(target, source, path, schema) {
   const mergeTarget = target;
   const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
   for (const key of Object.keys(source)) {
-    out[key] = mergeDeep(out[key], source[key], [...path, key], schema);
+    safeAssign(
+      out,
+      key,
+      mergeDeep(
+        safeOwnRead(out, key),
+        safeOwnRead(source, key),
+        [...path, key],
+        schema
+      )
+    );
   }
   return out;
 }
@@ -1577,39 +1740,44 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     }
     return result;
   }
-  async function validateAsync(pathInput) {
+  async function runImperativeValidation(pathInput, config) {
     const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
     const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
     try {
       state.activeValidations.value += 1;
-      state.cancelFieldValidation();
+      if (config.cancelInFlight) state.cancelFieldValidation();
       const refinement = await runRefinementValidation(dataAtPath, segments);
-      const scopePath = segments ?? [];
-      const errors = refinement.success ? [] : refinement.errors;
-      const reStamped = segments === void 0 ? errors : errors.map((err) => ({
-        ...err,
-        path: [...segments, ...err.path]
-      }));
-      state.applySchemaErrorsForSubtree(scopePath, reStamped);
-      return stripData(composeWithDerivedBlank(refinement, segments));
+      if (config.commitToSchemaErrors) {
+        const scopePath = segments ?? [];
+        const errors = refinement.success ? [] : refinement.errors;
+        const reStamped = segments === void 0 ? errors : errors.map((err) => ({
+          ...err,
+          path: [...segments, ...err.path]
+        }));
+        state.applySchemaErrorsForSubtree(scopePath, reStamped);
+      }
+      return { ok: true, refinement, segments };
     } catch (err) {
-      return adapterThrowResponse(err);
+      return { ok: false, error: adapterThrowResponse(err) };
     } finally {
       state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
     }
   }
+  async function validateAsync(pathInput) {
+    const result = await runImperativeValidation(pathInput, {
+      cancelInFlight: true,
+      commitToSchemaErrors: true
+    });
+    if (!result.ok) return result.error;
+    return stripData(composeWithDerivedBlank(result.refinement, result.segments));
+  }
   async function process(pathInput) {
-    const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
-    const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
-    try {
-      state.activeValidations.value += 1;
-      const refinement = await runRefinementValidation(dataAtPath, segments);
-      return composeWithDerivedBlank(refinement, segments);
-    } catch (err) {
-      return adapterThrowResponse(err);
-    } finally {
-      state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
-    }
+    const result = await runImperativeValidation(pathInput, {
+      cancelInFlight: false,
+      commitToSchemaErrors: false
+    });
+    if (!result.ok) return result.error;
+    return composeWithDerivedBlank(result.refinement, result.segments);
   }
   function adapterThrowResponse(err) {
     return {
@@ -2047,7 +2215,6 @@ function coerceValue(value, accepted, elementAccepted, index) {
 }
 
 const EMPTY_TRANSFORMS = Object.freeze([]);
-const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 const attaformListenersSymbol = Symbol.for("attaform:focus-listeners");
 function attachFocusListeners(state, segments, element, instanceMeta) {
   const target = element;
@@ -2098,7 +2265,11 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       if (typed !== null && typeof raw === "number" && parseFloat(typed) === raw) {
         return typed;
       }
-      return String(raw);
+      try {
+        return String(raw);
+      } catch {
+        return Object.prototype.toString.call(raw);
+      }
     });
     const slimDefault = state.schema.getDefaultAtPath(segments);
     const slimTypes = state.schema.getSlimPrimitiveTypesAtPath(segments);
@@ -2257,12 +2428,12 @@ function walk(input, segments, schema, paths) {
     for (const key of allKeys) {
       const orig = input[key];
       if (orig === void 0 && inputKeysSet.has(key)) {
-        out[key] = void 0;
+        safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
       const walked = walk(orig, [...segments, key], schema, paths);
-      out[key] = walked;
+      safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
     return mutated ? out : input;
@@ -2283,7 +2454,11 @@ function walkUnspecified(slim, segments, paths) {
   if (slim !== null && typeof slim === "object") {
     const out = {};
     for (const key of Object.keys(slim)) {
-      out[key] = walkUnspecified(slim[key], [...segments, key], paths);
+      safeAssign(
+        out,
+        key,
+        walkUnspecified(slim[key], [...segments, key], paths)
+      );
     }
     return out;
   }
@@ -2318,7 +2493,7 @@ function substitute(input, segments, schema, paths) {
     for (const key of Object.keys(input)) {
       const orig = input[key];
       const walked = substitute(orig, [...segments, key], schema, paths);
-      out[key] = walked;
+      safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
     return mutated ? out : input;
@@ -2366,70 +2541,86 @@ function expandUnsetAt(segments, schema, paths) {
   return result;
 }
 
-function buildValuesProxy(form) {
-  const inner = computed(() => readonly(form.value));
+function buildCallableReadonlySnapshotProxy(opts) {
   const target = (() => {
   });
-  const valuesToString = () => JSON.stringify(inner.value);
-  const valuesToPrimitive = (hint) => hint === "number" ? NaN : valuesToString();
+  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(opts.snapshot);
+  const callResolve = opts.resolveCall ?? ((arg) => opts.resolveKey(String(arg)));
   return new Proxy(target, {
     apply(_, __, args) {
       const arg = args[0];
-      if (arg === void 0) return inner.value;
-      const { segments } = canonicalizePath(arg);
-      let cursor = inner.value;
-      for (const seg of segments) {
-        if (cursor === null || cursor === void 0) return void 0;
-        cursor = cursor[seg];
-      }
-      return cursor;
+      if (arg === void 0) return opts.snapshot();
+      return callResolve(arg);
     },
     get(_, key) {
       if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return valuesToPrimitive;
+        if (key === Symbol.toPrimitive) return toPrimitive;
         return Reflect.get(target, key);
       }
-      if (key === "toJSON") return () => inner.value;
-      if (key === "toString") return valuesToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      return inner.value[key];
+      if (key === "toJSON") return toJSON;
+      if (key === "toString") return toString;
+      if (key === "valueOf") return valueOf;
+      return opts.resolveKey(key);
     },
     has(_, key) {
       if (typeof key === "symbol") return Reflect.has(target, key);
-      return Reflect.has(inner.value, key);
-    },
-    ownKeys() {
-      return Reflect.ownKeys(inner.value);
+      return opts.hasKey(key);
     },
+    ownKeys: () => opts.ownKeys(),
     getOwnPropertyDescriptor(_, key) {
-      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
-      if (desc !== void 0) desc.configurable = true;
-      return desc;
+      if (typeof key !== "string") return void 0;
+      if (opts.describeKey !== void 0) return opts.describeKey(key);
+      if (!opts.hasKey(key)) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: opts.resolveKey(key)
+      };
     },
-    // Match Vue's `readonly()` semantics: writes warn (in dev) and
-    // silently noop (return true). Returning false would throw
-    // TypeError in strict-mode consumers, surprising users who
-    // assigned through the proxy and expected it to be ignored.
-    set(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
-        );
-      }
+    set: (_, key) => {
+      warnReadOnly(opts.surface, "write", key);
       return true;
     },
-    deleteProperty(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
+    deleteProperty: (_, key) => {
+      warnReadOnly(opts.surface, "delete", key);
+      return true;
+    },
+    defineProperty: (_, key) => {
+      warnReadOnly(opts.surface, "define", key);
       return true;
+    }
+  });
+}
+
+function buildValuesProxy(form) {
+  const inner = computed(() => readonly(form.value));
+  return buildCallableReadonlySnapshotProxy({
+    surface: "form.values",
+    snapshot: () => inner.value,
+    // Read through the readonly proxy at access time so Vue's
+    // dependency tracking lands inside the consumer's active effect
+    // — `inner.value[key]` is what triggers per-key tracking.
+    resolveKey: (key) => inner.value[key],
+    // Dynamic path: walk segments through the readonly proxy. Each
+    // step reads through the proxy's own get traps so dependency
+    // tracking propagates at every level.
+    resolveCall: (arg) => {
+      const { segments } = canonicalizePath(arg);
+      let cursor = inner.value;
+      for (const seg of segments) {
+        if (cursor === null || cursor === void 0) return void 0;
+        cursor = cursor[seg];
+      }
+      return cursor;
     },
-    defineProperty: () => true
+    ownKeys: () => Reflect.ownKeys(inner.value),
+    hasKey: (key) => Reflect.has(inner.value, key),
+    describeKey: (key) => {
+      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
+      if (desc !== void 0) desc.configurable = true;
+      return desc;
+    }
   });
 }
 
@@ -2495,10 +2686,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
         next,
         state.schema
       );
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      if (!ok2) return false;
       for (const pathKey of walked2.paths) {
-        state.blankPaths.add(pathKey);
+        const blankSegments = segmentsForPathKey(pathKey);
+        if (blankSegments === null) continue;
+        state.setValueAtPath(
+          blankSegments,
+          state.getValueAtPath(blankSegments),
+          withInstanceMeta({ blank: true })
+        );
       }
-      return state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      return true;
     }
     const segments = canonicalizePath(pathOrValue).segments;
     const writeUnsetAt = () => {
@@ -2647,23 +2846,45 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const rootFieldState = getRootFieldStateAt([]);
   const formMeta = readonly(
     reactive({
-      // FieldState fields — read through one shared root computed. Each
-      // property accesses `rootFieldState.value[X]`, so any descendant
-      // change re-evaluates the root computed once (Vue's reactive
-      // graph dedupes the dependent re-renders).
-      value: computed(() => rootFieldState.value.value),
-      original: computed(() => rootFieldState.value.original),
-      pristine: computed(() => rootFieldState.value.pristine),
-      dirty: computed(() => rootFieldState.value.dirty),
-      focused: computed(() => rootFieldState.value.focused),
-      blurred: computed(() => rootFieldState.value.blurred),
-      touched: computed(() => rootFieldState.value.touched),
-      interacted: computed(() => rootFieldState.value.interacted),
-      blurredAfterInteraction: computed(() => rootFieldState.value.blurredAfterInteraction),
-      connected: computed(() => rootFieldState.value.connected),
-      element: computed(() => rootFieldState.value.element),
-      elements: computed(() => rootFieldState.value.elements),
-      updatedAt: computed(() => rootFieldState.value.updatedAt),
+      get value() {
+        return rootFieldState.value.value;
+      },
+      get original() {
+        return rootFieldState.value.original;
+      },
+      get pristine() {
+        return rootFieldState.value.pristine;
+      },
+      get dirty() {
+        return rootFieldState.value.dirty;
+      },
+      get focused() {
+        return rootFieldState.value.focused;
+      },
+      get blurred() {
+        return rootFieldState.value.blurred;
+      },
+      get touched() {
+        return rootFieldState.value.touched;
+      },
+      get interacted() {
+        return rootFieldState.value.interacted;
+      },
+      get blurredAfterInteraction() {
+        return rootFieldState.value.blurredAfterInteraction;
+      },
+      get connected() {
+        return rootFieldState.value.connected;
+      },
+      get element() {
+        return rootFieldState.value.element;
+      },
+      get elements() {
+        return rootFieldState.value.elements;
+      },
+      get updatedAt() {
+        return rootFieldState.value.updatedAt;
+      },
       // Whole-form validating mirrors the LIFECYCLE counter
       // (`state.activeValidations`) ORed with any per-leaf validation
       // in flight (via `rootFieldState.validating`). A submit-time
@@ -2686,21 +2907,51 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // FieldState surface, so `form.meta.displayState` matches
       // `form.fields().displayState` exactly — the predicate runs once
       // at the root and the result is shared.
-      displayState: computed(() => rootFieldState.value.displayState),
-      showErrors: computed(() => rootFieldState.value.showErrors),
-      showPending: computed(() => rootFieldState.value.showPending),
-      showSuccess: computed(() => rootFieldState.value.showSuccess),
-      showIdle: computed(() => rootFieldState.value.showIdle),
-      firstError: computed(() => rootFieldState.value.firstError),
-      path: computed(() => rootFieldState.value.path),
-      id: computed(() => rootFieldState.value.id),
-      aria: computed(() => rootFieldState.value.aria),
-      key: computed(() => rootFieldState.value.key),
-      blank: computed(() => rootFieldState.value.blank),
-      label: computed(() => rootFieldState.value.label),
-      description: computed(() => rootFieldState.value.description),
-      placeholder: computed(() => rootFieldState.value.placeholder),
-      meta: computed(() => rootFieldState.value.meta),
+      get displayState() {
+        return rootFieldState.value.displayState;
+      },
+      get showErrors() {
+        return rootFieldState.value.showErrors;
+      },
+      get showPending() {
+        return rootFieldState.value.showPending;
+      },
+      get showSuccess() {
+        return rootFieldState.value.showSuccess;
+      },
+      get showIdle() {
+        return rootFieldState.value.showIdle;
+      },
+      get firstError() {
+        return rootFieldState.value.firstError;
+      },
+      get path() {
+        return rootFieldState.value.path;
+      },
+      get id() {
+        return rootFieldState.value.id;
+      },
+      get aria() {
+        return rootFieldState.value.aria;
+      },
+      get key() {
+        return rootFieldState.value.key;
+      },
+      get blank() {
+        return rootFieldState.value.blank;
+      },
+      get label() {
+        return rootFieldState.value.label;
+      },
+      get description() {
+        return rootFieldState.value.description;
+      },
+      get placeholder() {
+        return rootFieldState.value.placeholder;
+      },
+      get meta() {
+        return rootFieldState.value.meta;
+      },
       // Lifecycle (form-level only — not on FieldState).
       submitting,
       submissionAttempts,
@@ -2709,7 +2960,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // Scalar mirror over the array — meta is a single sticky surface
       // for both templates and `useWizard`'s `FormStatus`, so the
       // projection lives here.
-      errorCount: computed(() => metaErrors.value.length),
+      get errorCount() {
+        return metaErrors.value.length;
+      },
       submitted,
       // Per-`useForm()`-call identity. Stable for one mount; new on
       // re-mount; orthogonal to `form.key` (which is the user-supplied
@@ -2746,12 +2999,20 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   function clear(pathInput) {
-    const segments = pathInput === void 0 ? ROOT_PATH : canonicalizePath(pathInput).segments;
-    return state.clear(segments);
+    if (pathInput === void 0) {
+      return setValueImpl(unset);
+    }
+    return setValueImpl(pathInput, unset);
   }
   const persist = async (pathInput, options2) => {
     const segments = canonicalizePath(pathInput).segments;
-    enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
+    if (!allowSensitivePersist(
+      segments,
+      options2?.acknowledgeSensitive === true,
+      state.isSensitivePath
+    )) {
+      return;
+    }
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2817,7 +3078,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
     getFormMetaBase,
     fieldStateAccessorOptions
   );
+  const needsLazyGate = state.defaultValuesFactory.value !== void 0 || state.hasSsrPrefetch;
   function gated(fn) {
+    if (!needsLazyGate) return fn;
     return ((...args) => {
       void state.activate();
       return fn(...args);
@@ -2842,7 +3105,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
     const out = {};
     for (const key of Object.keys(value)) {
-      out[key] = callTerminal(`${path}.${key}`);
+      safeAssign(out, key, callTerminal(`${path}.${key}`));
     }
     return Object.freeze(out);
   }
@@ -2936,9 +3199,132 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
 }
 
-function createArrayIdentity(getArrayLength) {
-  const tokens = /* @__PURE__ */ new Map();
-  const baselines = /* @__PURE__ */ new Map();
+function applyDuStubs(schema, data, options = {}) {
+  const warned = options.warn === true ? /* @__PURE__ */ new Set() : void 0;
+  return walkDuStubs(schema, data, options.basePath ?? [], warned);
+}
+function walkDuStubs(schema, value, path, warned) {
+  if (value === null || value === void 0 || typeof value !== "object") return value;
+  if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, i) => walkDuStubs(schema, item, [...path, i], warned));
+  }
+  const rec = value;
+  const du = schema.getUnionDiscriminatorAtPath(path);
+  if (du !== void 0) {
+    const discValue = rec[du.discriminatorKey];
+    if (discValue !== void 0 && !du.isVariantSelected(discValue)) {
+      const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
+      if (!isKindBlank && warned !== void 0 && __DEV__) {
+        const dotted = path.map((s) => String(s)).join(".") || "(root)";
+        const key = `${dotted}::${String(discValue)}`;
+        if (!warned.has(key)) {
+          warned.add(key);
+          console.warn(
+            `[attaform] defaultValues at '${dotted}' carries discriminator '${du.discriminatorKey}=${JSON.stringify(discValue)}' which isn't a known variant. Form mounts in a stub holding only the discriminator key. Validation will surface the mismatch.`
+          );
+        }
+      }
+      const stub = {};
+      safeAssign(stub, du.discriminatorKey, discValue);
+      return stub;
+    }
+  }
+  const out = {};
+  for (const k of Object.keys(rec)) {
+    safeAssign(out, k, walkDuStubs(schema, rec[k], [...path, k], warned));
+  }
+  return out;
+}
+
+function createVariantMemory() {
+  const memory = /* @__PURE__ */ new Map();
+  function clearAtArrayIndices(arrayPath, indexFilter) {
+    for (const memKey of [...memory.keys()]) {
+      const segs = segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= arrayPath.length) continue;
+      const idxSeg = segs[arrayPath.length];
+      if (typeof idxSeg !== "number") continue;
+      if (indexFilter(idxSeg)) memory.delete(memKey);
+    }
+  }
+  return {
+    clear() {
+      memory.clear();
+    },
+    clearUnderPath(parentPath) {
+      for (const memKey of [...memory.keys()]) {
+        const segs = segmentsForPathKey(memKey);
+        if (segs === null) continue;
+        if (isPathPrefix(parentPath, segs)) memory.delete(memKey);
+      }
+    },
+    applyArrayOp(arrayPath, op) {
+      switch (op.kind) {
+        case "insert":
+        case "remove":
+          clearAtArrayIndices(arrayPath, (i) => i >= op.index);
+          return;
+        case "move": {
+          const lo = Math.min(op.from, op.to);
+          const hi = Math.max(op.from, op.to);
+          clearAtArrayIndices(arrayPath, (i) => i >= lo && i <= hi);
+          return;
+        }
+        case "swap":
+          clearAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
+          return;
+        case "replace-at":
+          clearAtArrayIndices(arrayPath, (i) => i === op.index);
+          return;
+      }
+    },
+    recordOutgoing(unionKey, discValue, snapshot) {
+      let perUnion = memory.get(unionKey);
+      if (perUnion === void 0) {
+        perUnion = /* @__PURE__ */ new Map();
+        memory.set(unionKey, perUnion);
+      }
+      perUnion.set(discValue, snapshot);
+    },
+    lookupIncoming(unionKey, discValue) {
+      return memory.get(unionKey)?.get(discValue);
+    }
+  };
+}
+function cloneVariantSnapshot(value) {
+  if (value === null || typeof value !== "object") return value;
+  const raw = toRaw(value);
+  if (raw instanceof Date) return new Date(raw.getTime());
+  if (raw instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of raw.entries()) out2.set(cloneVariantSnapshot(k), cloneVariantSnapshot(v));
+    return out2;
+  }
+  if (raw instanceof Set) {
+    const out2 = /* @__PURE__ */ new Set();
+    for (const v of raw) out2.add(cloneVariantSnapshot(v));
+    return out2;
+  }
+  if (raw instanceof RegExp) return new RegExp(raw.source, raw.flags);
+  if (Array.isArray(raw)) {
+    const out2 = new Array(raw.length);
+    for (let i = 0; i < raw.length; i++) out2[i] = cloneVariantSnapshot(raw[i]);
+    return out2;
+  }
+  const src = raw;
+  const out = {};
+  for (const k of Object.keys(src)) safeAssign(out, k, cloneVariantSnapshot(src[k]));
+  return out;
+}
+
+function createArrayIdentity(getArrayLength) {
+  const tokens = /* @__PURE__ */ new Map();
+  const baselines = /* @__PURE__ */ new Map();
   let counter = 0;
   const allocate = () => `k${(counter++).toString(36)}`;
   function ensure(arrayKey, expectedLen) {
@@ -2998,6 +3384,36 @@ function createArrayIdentity(getArrayLength) {
           return;
       }
     },
+    applyRemap(arrayPath, remap) {
+      if (remap.moved.size === 0 && remap.vacated.size === 0 && remap.fresh.size === 0) return;
+      const relocate = (store) => {
+        const idxPos = arrayPath.length;
+        const snapshots = [];
+        for (const [key, value] of store) {
+          const segments = segmentsForPathKey(key);
+          if (segments === null) continue;
+          if (!isPathPrefix(arrayPath, segments)) continue;
+          if (segments.length <= idxPos) continue;
+          const idxSeg = segments[idxPos];
+          if (typeof idxSeg !== "number") continue;
+          if (!remap.moved.has(idxSeg) && !remap.vacated.has(idxSeg) && !remap.fresh.has(idxSeg)) {
+            continue;
+          }
+          snapshots.push({ segments: [...segments], index: idxSeg, value });
+        }
+        if (snapshots.length === 0) return;
+        for (const snap of snapshots) store.delete(canonicalizePath(snap.segments).key);
+        for (const snap of snapshots) {
+          const target = remap.moved.get(snap.index);
+          if (target === void 0) continue;
+          const relocated = snap.segments.slice();
+          relocated[idxPos] = target;
+          store.set(canonicalizePath(relocated).key, snap.value);
+        }
+      };
+      relocate(tokens);
+      relocate(baselines);
+    },
     realign(arraySegs) {
       ensure(canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
     },
@@ -3112,6 +3528,94 @@ function migrateSetSubtree(set, arrayPath, remap) {
   }
 }
 
+function createArrayBookkeeping(deps) {
+  const {
+    form,
+    fields,
+    userErrors,
+    originals,
+    blankPaths,
+    originalBlankPaths,
+    fieldValidationCounts,
+    fieldValidationState,
+    schemaErrors,
+    activeValidations,
+    arrayIdentity,
+    touchFieldRecord,
+    decFieldValidation
+  } = deps;
+  function migrateElementState(arrayPath, remap) {
+    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
+    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
+      ...record,
+      path: segments
+    }));
+    migrateMapSubtree(
+      userErrors,
+      arrayPath,
+      remap,
+      (errors, segments) => errors.map((error) => ({ ...error, path: [...segments] }))
+    );
+    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
+      segments,
+      value: record.value
+    }));
+    migrateSetSubtree(blankPaths, arrayPath, remap);
+    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
+    arrayIdentity.applyRemap(arrayPath, remap);
+  }
+  function seedFreshElement(arrayPath, freshIndex) {
+    const elementPath = [...arrayPath, freshIndex];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = canonicalizePath(patch.path);
+      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
+      touchFieldRecord(key, patch.path, { updatedAt: now });
+    });
+  }
+  function dropSchemaErrorsAtChangedIndices(arrayPath, remap) {
+    const changed = changedIndices(remap);
+    if (changed.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const key of [...schemaErrors.keys()]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
+    }
+  }
+  function abortValidationAtVacatedIndices(arrayPath, remap) {
+    if (remap.vacated.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
+      }
+      entry.controller.abort();
+      fieldValidationState.delete(key);
+    }
+  }
+  return {
+    migrateElementState,
+    seedFreshElement,
+    dropSchemaErrorsAtChangedIndices,
+    abortValidationAtVacatedIndices
+  };
+}
+
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
@@ -3135,43 +3639,6 @@ function warnMalformedHydration(formKey, kind, rawKey) {
     `[attaform] hydration: skipping malformed ${kind} entry at key '${rawKey}' on form '${formKey}'. This usually means the SSR bundle is on a different version than the client (rolling deploy / stale cache).`
   );
 }
-function applyDuStubs(schema, data, options = {}) {
-  const warned = options.warn === true ? /* @__PURE__ */ new Set() : void 0;
-  return walkDuStubs(schema, data, options.basePath ?? [], warned);
-}
-function walkDuStubs(schema, value, path, warned) {
-  if (value === null || value === void 0 || typeof value !== "object") return value;
-  if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item, i) => walkDuStubs(schema, item, [...path, i], warned));
-  }
-  const rec = value;
-  const du = schema.getUnionDiscriminatorAtPath(path);
-  if (du !== void 0) {
-    const discValue = rec[du.discriminatorKey];
-    if (discValue !== void 0 && !du.isVariantSelected(discValue)) {
-      const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
-      if (!isKindBlank && warned !== void 0 && __DEV__) {
-        const dotted = path.map((s) => String(s)).join(".") || "(root)";
-        const key = `${dotted}::${String(discValue)}`;
-        if (!warned.has(key)) {
-          warned.add(key);
-          console.warn(
-            `[attaform] defaultValues at '${dotted}' carries discriminator '${du.discriminatorKey}=${JSON.stringify(discValue)}' which isn't a known variant. Form mounts in a stub holding only the discriminator key. Validation will surface the mismatch.`
-          );
-        }
-      }
-      return { [du.discriminatorKey]: discValue };
-    }
-  }
-  const out = {};
-  for (const k of Object.keys(rec)) {
-    out[k] = walkDuStubs(schema, rec[k], [...path, k], warned);
-  }
-  return out;
-}
 function isPathKeyUnder(existingKey, parentPath) {
   const parsed = segmentsForPathKey(existingKey);
   if (parsed === null) return false;
@@ -3207,31 +3674,6 @@ function stripSymbolsDeep(value) {
   }
   return mutated ? out : value;
 }
-function cloneVariantSnapshot(value) {
-  if (value === null || typeof value !== "object") return value;
-  const raw = toRaw(value);
-  if (raw instanceof Date) return new Date(raw.getTime());
-  if (raw instanceof Map) {
-    const out2 = /* @__PURE__ */ new Map();
-    for (const [k, v] of raw.entries()) out2.set(cloneVariantSnapshot(k), cloneVariantSnapshot(v));
-    return out2;
-  }
-  if (raw instanceof Set) {
-    const out2 = /* @__PURE__ */ new Set();
-    for (const v of raw) out2.add(cloneVariantSnapshot(v));
-    return out2;
-  }
-  if (raw instanceof RegExp) return new RegExp(raw.source, raw.flags);
-  if (Array.isArray(raw)) {
-    const out2 = new Array(raw.length);
-    for (let i = 0; i < raw.length; i++) out2[i] = cloneVariantSnapshot(raw[i]);
-    return out2;
-  }
-  const src = raw;
-  const out = {};
-  for (const k of Object.keys(src)) out[k] = cloneVariantSnapshot(src[k]);
-  return out;
-}
 function walkAuthoredFromConstraints(value, prefix, out) {
   if (prefix.length > 0) out.add(canonicalizePath(prefix).key);
   if (isPlainRecord(value)) {
@@ -3304,7 +3746,6 @@ function createFormStore(options) {
   const coerceIndex = resolveCoercionIndex(options.coerce);
   const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
   const resolvedIsSensitivePath = options.isSensitivePath ?? isSensitivePath;
-  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -3367,117 +3808,17 @@ function createFormStore(options) {
     blankPaths.add(key);
     originalBlankPaths.add(key);
   }
-  const variantMemory = /* @__PURE__ */ new Map();
-  function clearVariantMemoryUnderPath(arrayPath) {
-    for (const memKey of [...variantMemory.keys()]) {
-      const segs = segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (isPathPrefix(arrayPath, segs)) variantMemory.delete(memKey);
-    }
-  }
-  function clearVariantMemoryAtArrayIndices(arrayPath, indexFilter) {
-    for (const memKey of [...variantMemory.keys()]) {
-      const segs = segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (!isPathPrefix(arrayPath, segs)) continue;
-      if (segs.length <= arrayPath.length) continue;
-      const idxSeg = segs[arrayPath.length];
-      if (typeof idxSeg !== "number") continue;
-      if (indexFilter(idxSeg)) variantMemory.delete(memKey);
+  const variantMemory = createVariantMemory();
+  const pathOrdinals = /* @__PURE__ */ new Map();
+  let nextOrdinal = 0;
+  function ensurePathOrdinal(key) {
+    let ordinal = pathOrdinals.get(key);
+    if (ordinal === void 0) {
+      ordinal = nextOrdinal;
+      pathOrdinals.set(key, ordinal);
+      nextOrdinal += 1;
     }
-  }
-  function applyArrayOpToMemory(arrayPath, op) {
-    switch (op.kind) {
-      case "insert":
-      case "remove":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.index);
-        return;
-      case "move": {
-        const lo = Math.min(op.from, op.to);
-        const hi = Math.max(op.from, op.to);
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= lo && i <= hi);
-        return;
-      }
-      case "swap":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
-        return;
-      case "replace-at":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.index);
-        return;
-    }
-  }
-  function migrateArrayElementState(arrayPath, remap) {
-    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
-    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
-      ...record,
-      path: segments
-    }));
-    migrateMapSubtree(
-      userErrors,
-      arrayPath,
-      remap,
-      (errors, segments) => errors.map((error) => ({ ...error, path: [...segments] }))
-    );
-    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
-      segments,
-      value: record.value
-    }));
-    migrateSetSubtree(blankPaths, arrayPath, remap);
-    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
-  }
-  function seedFreshElement(arrayPath, freshIndex) {
-    const elementPath = [...arrayPath, freshIndex];
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
-      if (patch.kind !== "added") return;
-      const { key } = canonicalizePath(patch.path);
-      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
-      touchFieldRecord(key, patch.path, { updatedAt: now });
-    });
-  }
-  function dropSchemaErrorsAtChangedIndices(arrayPath, remap) {
-    const changed = changedIndices(remap);
-    if (changed.size === 0) return;
-    const idxPos = arrayPath.length;
-    for (const key of [...schemaErrors.keys()]) {
-      const segs = segmentsForPathKey(key);
-      if (segs === null) continue;
-      if (!isPathPrefix(arrayPath, segs)) continue;
-      if (segs.length <= idxPos) continue;
-      const idx = segs[idxPos];
-      if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
-    }
-  }
-  function abortValidationAtVacatedIndices(arrayPath, remap) {
-    if (remap.vacated.size === 0) return;
-    const idxPos = arrayPath.length;
-    for (const [key, entry] of [...fieldValidationState]) {
-      const segs = segmentsForPathKey(key);
-      if (segs === null) continue;
-      if (!isPathPrefix(arrayPath, segs)) continue;
-      if (segs.length <= idxPos) continue;
-      const idx = segs[idxPos];
-      if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
-      if (entry.timer !== null) {
-        clearTimeout(entry.timer);
-      } else if (!entry.settled) {
-        activeValidations.value = Math.max(0, activeValidations.value - 1);
-        decFieldValidation(key);
-      }
-      entry.controller.abort();
-      fieldValidationState.delete(key);
-    }
-  }
-  const pathOrdinals = /* @__PURE__ */ new Map();
-  let nextOrdinal = 0;
-  function ensurePathOrdinal(key) {
-    let ordinal = pathOrdinals.get(key);
-    if (ordinal === void 0) {
-      ordinal = nextOrdinal;
-      pathOrdinals.set(key, ordinal);
-      nextOrdinal += 1;
-    }
-    return ordinal;
+    return ordinal;
   }
   const derivedBlankErrors = computed(() => {
     const result = /* @__PURE__ */ new Map();
@@ -3505,7 +3846,9 @@ function createFormStore(options) {
   const departAttempts = ref(0);
   const submissionGeneration = ref(0);
   const activeValidations = ref(0);
-  let lastValidatedSnapshot = null;
+  const pathSnapshots = /* @__PURE__ */ new Map();
+  let scheduleEpoch = 0;
+  let lastCommittedEpoch = 0;
   const hydrating = ref(false);
   const hydrateError = ref(null);
   const defaultValuesFactory = ref(void 0);
@@ -3521,9 +3864,12 @@ function createFormStore(options) {
   const pathAsyncCache = /* @__PURE__ */ new Map();
   function pathHasAsyncValidation(path) {
     const { key } = canonicalizePath(path);
+    return pathHasAsyncValidationByKey(key, path);
+  }
+  function pathHasAsyncValidationByKey(key, segments) {
     const cached = pathAsyncCache.get(key);
     if (cached !== void 0) return cached;
-    const candidates = schema.getSchemasAtPath(path);
+    const candidates = schema.getSchemasAtPath(segments);
     const hasAsync = candidates.some((sub) => sub.needsAsyncValidation?.() === true);
     pathAsyncCache.set(key, hasAsync);
     return hasAsync;
@@ -3615,6 +3961,21 @@ function createFormStore(options) {
       blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
     });
   }
+  const arrayBookkeeping = createArrayBookkeeping({
+    form,
+    fields,
+    userErrors,
+    originals,
+    blankPaths,
+    originalBlankPaths,
+    fieldValidationCounts,
+    fieldValidationState,
+    schemaErrors,
+    activeValidations,
+    arrayIdentity,
+    touchFieldRecord,
+    decFieldValidation
+  });
   function applyFormReplacement(next, meta) {
     const prev = form.value;
     if (Object.is(prev, next)) return;
@@ -3738,8 +4099,13 @@ function createFormStore(options) {
     const pathKey = canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
-    } else if (blankPaths.has(pathKey)) {
-      blankPaths.delete(pathKey);
+    } else {
+      if (blankPaths.has(pathKey)) blankPaths.delete(pathKey);
+      if (meta?.arrayOp === void 0) {
+        for (const existingKey of [...blankPaths]) {
+          if (isPathKeyUnder(existingKey, path)) blankPaths.delete(existingKey);
+        }
+      }
     }
     const wasAuthoredBefore = authoredPaths.has(pathKey);
     walkAuthoredFromConstraints(value, path, authoredPaths);
@@ -3763,14 +4129,14 @@ function createFormStore(options) {
     applyFormReplacement(nextForm, meta);
     if (meta?.arrayOp !== void 0) {
       const remap = remapForOp(meta.arrayOp, oldArrayLength);
-      migrateArrayElementState(path, remap);
-      for (const freshIndex of remap.fresh) seedFreshElement(path, freshIndex);
-      dropSchemaErrorsAtChangedIndices(path, remap);
-      abortValidationAtVacatedIndices(path, remap);
-      applyArrayOpToMemory(path, meta.arrayOp);
+      arrayBookkeeping.migrateElementState(path, remap);
+      for (const freshIndex of remap.fresh) arrayBookkeeping.seedFreshElement(path, freshIndex);
+      arrayBookkeeping.dropSchemaErrorsAtChangedIndices(path, remap);
+      arrayBookkeeping.abortValidationAtVacatedIndices(path, remap);
+      variantMemory.applyArrayOp(path, meta.arrayOp);
       arrayIdentity.applyOp(path, meta.arrayOp);
     } else if (Array.isArray(value) && Array.isArray(currentValue)) {
-      clearVariantMemoryUnderPath(path);
+      variantMemory.clearUnderPath(path);
       arrayIdentity.realign(path);
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
@@ -3795,18 +4161,12 @@ function createFormStore(options) {
         for (const k of blankPaths) {
           if (isPathKeyUnder(k, parentPath)) outgoingBlanks.push(k);
         }
-        let memoryForUnion2 = variantMemory.get(parentKey);
-        if (memoryForUnion2 === void 0) {
-          memoryForUnion2 = /* @__PURE__ */ new Map();
-          variantMemory.set(parentKey, memoryForUnion2);
-        }
-        memoryForUnion2.set(oldDiscValue, {
+        variantMemory.recordOutgoing(parentKey, oldDiscValue, {
           value: currentValue2,
           blankPaths: outgoingBlanks
         });
       }
-      const memoryForUnion = variantMemory.get(parentKey);
-      const restored = memoryForUnion?.get(newDiscValue);
+      const restored = variantMemory.lookupIncoming(parentKey, newDiscValue);
       if (restored !== void 0) {
         baseline = restored.value;
         restoredBlanks = [...restored.blankPaths];
@@ -3878,12 +4238,10 @@ function createFormStore(options) {
     const controller = new AbortController();
     const fresh = { controller, timer: null, settled: false };
     fieldValidationState.set(key, fresh);
+    const myEpoch = ++scheduleEpoch;
     const run = () => {
       fresh.timer = null;
       if (controller.signal.aborted) return;
-      if (effectiveMode === "blur") {
-        lastValidatedSnapshot = { value: structuralSnapshot(form.value) };
-      }
       let activeIncremented = false;
       try {
         activeValidations.value += 1;
@@ -3895,11 +4253,25 @@ function createFormStore(options) {
         }
         throw err;
       }
-      void Promise.resolve().then(() => schema.validateAtPath(form.value, void 0)).then((response) => {
+      const subtreeScope = path.length > 0 && schema.hasContainerOrRootRefine?.() === false;
+      const scopePath = subtreeScope ? path : void 0;
+      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 (myEpoch <= lastCommittedEpoch) return;
+        lastCommittedEpoch = myEpoch;
+        if (effectiveMode === "blur") {
+          const snapshotSource = scopePath !== void 0 ? getAtPath(form.value, scopePath) : form.value;
+          pathSnapshots.set(scopeKey, structuralSnapshot(snapshotSource));
+        }
         const errors = response.success ? [] : response.errors;
         const filtered = filterAuthoredErrors(errors);
-        applySchemaErrorsForSubtree([], filtered);
+        const restamped = subtreeScope ? filtered.map((err) => ({
+          ...err,
+          path: [...path, ...err.path]
+        })) : filtered;
+        applySchemaErrorsForSubtree(scopePath ?? [], restamped);
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
@@ -4142,11 +4514,24 @@ function createFormStore(options) {
     const focusMode = meta?.instance?.validateOn ?? fieldValidationMode;
     if (!focused && focusMode === "blur") {
       const firstInteractiveBlur = current?.interacted === true && current.blurredAfterInteraction !== true;
-      const snapshot = lastValidatedSnapshot;
+      let snapshot = void 0;
+      let snapshotScopeLength = 0;
+      for (let i = path.length; i >= 0; i--) {
+        const ancestorKey = canonicalizePath(path.slice(0, i)).key;
+        const entry = pathSnapshots.get(ancestorKey);
+        if (entry !== void 0) {
+          snapshot = entry;
+          snapshotScopeLength = i;
+          break;
+        }
+      }
       let changed = true;
-      if (!firstInteractiveBlur && snapshot !== null) {
+      if (!firstInteractiveBlur && snapshot !== void 0) {
+        const relPath = path.slice(snapshotScopeLength);
+        const snapshotSubtree = getAtPath(snapshot, relPath);
+        const liveSubtree = getAtPath(form.value, path);
         changed = false;
-        diffAndApply(snapshot.value, form.value, [], () => {
+        diffAndApply(snapshotSubtree, liveSubtree, path, () => {
           changed = true;
         });
       }
@@ -4158,10 +4543,6 @@ function createFormStore(options) {
       }
     }
   }
-  function markTouched(path) {
-    const { key } = canonicalizePath(path);
-    touchFieldRecord(key, path, { touched: true });
-  }
   function markInteracted(path) {
     const { key } = canonicalizePath(path);
     if (fields.get(key)?.interacted === true) return;
@@ -4185,9 +4566,6 @@ function createFormStore(options) {
       );
     }
   }
-  function clear(path) {
-    return setValueAtPath(path, schema.getEmptyValueAtPath(path));
-  }
   function rehydrate() {
     const factory = defaultValuesFactory.value;
     if (factory === void 0) {
@@ -4334,6 +4712,9 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    pathSnapshots.clear();
+    scheduleEpoch = 0;
+    lastCommittedEpoch = 0;
     variantMemory.clear();
     for (const listener of resetListeners) {
       try {
@@ -4345,13 +4726,7 @@ function createFormStore(options) {
   }
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
-    for (const memKey of [...variantMemory.keys()]) {
-      const memSegments = segmentsForPathKey(memKey);
-      if (memSegments === null) continue;
-      if (isPathPrefix(targetSegments, memSegments)) {
-        variantMemory.delete(memKey);
-      }
-    }
+    variantMemory.clearUnderPath(targetSegments);
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
       const wrote = setValueAtPath(targetSegments, leafEntry.value);
@@ -4412,15 +4787,11 @@ function createFormStore(options) {
       blurredAfterInteraction: false
     });
   }
-  function isPathPrefix(prefix, candidate) {
-    if (prefix.length > candidate.length) return false;
-    for (let i = 0; i < prefix.length; i++) {
-      if (prefix[i] !== candidate[i]) return false;
-    }
-    return true;
-  }
   function isPristineAtPath(path) {
     const { key, segments } = canonicalizePath(path);
+    return isPristineAtPathByKey(key, segments);
+  }
+  function isPristineAtPathByKey(key, segments) {
     if (blankPaths.has(key) !== originalBlankPaths.has(key)) return false;
     const entry = originals.get(key);
     if (entry === void 0) return true;
@@ -4482,6 +4853,7 @@ function createFormStore(options) {
     hydrating,
     hydrateError,
     defaultValuesFactory,
+    hasSsrPrefetch: ssrPrefetch !== void 0,
     defaultsResolved,
     activated,
     activationPromise,
@@ -4491,6 +4863,7 @@ function createFormStore(options) {
     activeValidations,
     firstValidationDone,
     pathHasAsyncValidation,
+    pathHasAsyncValidationByKey,
     fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
@@ -4498,7 +4871,6 @@ function createFormStore(options) {
     arrayElementKey,
     reset,
     resetField,
-    clear,
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
@@ -4511,11 +4883,11 @@ function createFormStore(options) {
     registerElement,
     deregisterElement,
     markFocused,
-    markTouched,
     markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    isPristineAtPathByKey,
     hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
@@ -4532,7 +4904,6 @@ function createFormStore(options) {
     modules,
     persistOptIns,
     isSensitivePath: resolvedIsSensitivePath,
-    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
     noSyncPaths,
     incrementNoSyncOptOut,
     decrementNoSyncOptOut,
@@ -4733,931 +5104,987 @@ function createHistoryModule(state, config) {
   };
 }
 
-const PROTOCOL_VERSION = 1;
-const JOIN_COLLECTION_WINDOW_MS = 50;
-const SNAPSHOT_TIMEOUT_MS = 200;
-const MAX_LEADER_ATTEMPTS = 3;
-function isFileLikeValue(value) {
-  if (typeof File !== "undefined" && value instanceof File) return true;
-  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
-  return false;
-}
-function isDangerousSegment(s) {
-  return s === "__proto__" || s === "constructor" || s === "prototype";
-}
-function pathContainsDangerousSegment(path) {
-  for (let i = 0; i < path.length; i++) {
-    if (isDangerousSegment(path[i])) return true;
-  }
-  return false;
-}
-function isInboundShapeAcceptable(schema, path, value) {
-  if (isFileLikeValue(value)) return false;
-  let kind;
-  if (Array.isArray(value)) {
-    kind = "array";
-  } else if (value !== null && typeof value === "object" && isPlainRecord(value)) {
-    kind = "object";
-  } else {
-    kind = slimKindOf(value);
-  }
-  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
-  if (!accepted.has(kind)) return false;
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      if (!isInboundShapeAcceptable(schema, [...path, i], value[i])) return false;
+function wirePersistence(state, config) {
+  let fingerprint;
+  try {
+    fingerprint = hashStableString(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 true;
+    fingerprint = "unfingerprinted";
   }
-  if (isPlainRecord(value)) {
-    for (const key of Object.keys(value)) {
-      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
+  const base = resolveStorageKeyBase(config, state.formKey);
+  const key = `${base}:${fingerprint}`;
+  const debounceMs = normalizeNumericOption({
+    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,
+    source: "useForm.persist.debounceMs",
+    allowInfinity: false,
+    min: 0,
+    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS
+  });
+  const include = config.include ?? "form";
+  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
+  const adapterPromise = getStorageAdapter(config.storage);
+  let disposed = false;
+  const isDisposed = () => disposed;
+  let inFlightFinalFlush = null;
+  let pendingOptedInPaths = null;
+  const writer = createDebouncedWriter(async () => {
+    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
+    pendingOptedInPaths = null;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    if (optedInPaths.size === 0) {
+      await adapter.removeItem(key);
+      return;
     }
-    return true;
-  }
-  return true;
-}
-function diffBlankPaths(prev, curr) {
-  const added = [];
-  const removed = [];
-  const prevSet = new Set(prev);
-  for (const k of curr) if (!prevSet.has(k)) added.push(k);
-  for (const k of prev) if (!curr.has(k)) removed.push(k);
-  return { added, removed };
-}
-function snapshotForm(form) {
-  return structuralSnapshot(form);
-}
-function stripSensitivePathsDeep(value, pathSoFar, isSensitivePath) {
-  if (isFileLikeValue(value)) return void 0;
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) {
-    return value.map((item, i) => stripSensitivePathsDeep(item, [...pathSoFar, i], isSensitivePath));
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== Object.prototype && proto !== null) return value;
-  const out = {};
-  const src = value;
-  for (const key of Object.keys(src)) {
-    const childPath = [...pathSoFar, key];
-    if (isSensitivePath(childPath)) {
-      out[key] = void 0;
-      continue;
+    const rawForm = toRaw(state.form.value);
+    const filteredForm = stripUnacknowledgedSensitiveLeaves(
+      pluckPaths(rawForm, optedInPaths),
+      optedInPaths,
+      state.isSensitivePath
+    );
+    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
+    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
+    const filteredTransientEmpty = /* @__PURE__ */ new Set();
+    for (const tk of state.blankPaths) {
+      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
     }
-    out[key] = stripSensitivePathsDeep(src[key], childPath, isSensitivePath);
-  }
-  return out;
-}
-function isValidSyncMessage(data) {
-  if (data === null || typeof data !== "object") return false;
-  const m = data;
-  if (m["v"] !== PROTOCOL_VERSION) return false;
-  if (typeof m["senderId"] !== "string") return false;
-  if (typeof m["kind"] !== "string") return false;
-  switch (m["kind"]) {
-    case "hello":
-    case "announce":
-      return true;
-    case "requestSnapshot":
-      return typeof m["targetId"] === "string";
-    case "snapshot":
-      return Array.isArray(m["blankPaths"]) && "form" in m;
-    case "patches":
-      return Array.isArray(m["formPatches"]) && Array.isArray(m["blankPathsAdded"]) && Array.isArray(m["blankPathsRemoved"]);
-    default:
-      return false;
-  }
-}
-function generateSenderId() {
-  try {
-    return globalThis.crypto.randomUUID();
-  } catch {
-    return `atta-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
+    const payload = buildPersistedPayload(
+      filteredForm,
+      include,
+      filteredSchemaErrors,
+      filteredUserErrors,
+      filteredTransientEmpty
+    );
+    await adapter.setItem(key, payload);
+  }, debounceMs);
+  const unsubscribeChange = state.onFormChange((_next, meta) => {
+    if (isDisposed() || inFlightFinalFlush !== null) return;
+    if (meta?.crossTab === true) return;
+    if (meta?.persist !== true) return;
+    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
+    writer.schedule();
+  });
+  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
+    if (isDisposed()) return;
+    void (async () => {
+      await writer.flush();
+      if (isDisposed()) return;
+      const adapter = await adapterPromise;
+      if (isDisposed()) return;
+      await adapter.removeItem(key);
+    })();
+  }) : () => void 0;
+  const handlePageHide = () => {
+    if (isDisposed()) return;
+    void writer.flush();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("pagehide", handlePageHide);
   }
-}
-function createMultiTabSyncModule(state, channelName, options) {
-  if (typeof BroadcastChannel === "undefined") {
-    return {
-      dispose: () => void 0,
-      lifecycle: () => "established",
-      senderId: "",
-      channelName
-    };
-  }
-  let channel;
-  try {
-    channel = new BroadcastChannel(channelName);
-  } catch {
-    return {
-      dispose: () => void 0,
-      lifecycle: () => "established",
-      senderId: "",
-      channelName
-    };
-  }
-  const senderId = generateSenderId();
-  let lifecycle = "joining";
-  let disposed = false;
-  const peerIds = /* @__PURE__ */ new Set();
-  let joinCollectionTimer = null;
-  let snapshotTimeoutTimer = null;
-  let leaderAttempts = 0;
-  let prior = {
-    form: snapshotForm(state.form.value),
-    blankPathsSnapshot: [...state.blankPaths]
-  };
-  function safePost(msg) {
-    if (disposed) return;
+  void (async () => {
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    void cleanupOrphanKeys(adapter, base, key);
     try {
-      channel.postMessage(msg);
+      const raw = await adapter.getItem(key);
+      const payload = readPersistedPayload(raw);
+      if (payload === null) {
+        if (raw !== null && raw !== void 0) {
+          await adapter.removeItem(key);
+        }
+        return;
+      }
+      if (isDisposed()) return;
+      const merged = mergeSparseHydration(
+        toRaw(state.form.value),
+        payload.data.form,
+        state.schema
+      );
+      state.applyFormReplacement(merged, { hydration: true });
+      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
+      for (const k of persistedLeafPaths) {
+        state.blankPaths.delete(k);
+        state.originalBlankPaths.delete(k);
+      }
+      for (const k of payload.data.blankPaths ?? []) {
+        state.blankPaths.add(k);
+        state.originalBlankPaths.add(k);
+      }
+      if (include === "form+errors") {
+        if (payload.data.schemaErrors !== void 0) {
+          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
+          state.setAllSchemaErrors(flat);
+        }
+        if (payload.data.userErrors !== void 0) {
+          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
+          state.setAllUserErrors(flat);
+        }
+      }
+      state.scheduleFieldValidation(
+        [],
+        true
+        /* immediate */
+      );
     } catch {
     }
-  }
-  function refreshPrior() {
-    prior = {
-      form: snapshotForm(state.form.value),
-      blankPathsSnapshot: [...state.blankPaths]
-    };
-  }
-  function isPathLocallySuppressed(path) {
-    if (pathContainsDangerousSegment(path)) return true;
-    if (options.isSensitivePath(path)) return true;
-    const { key } = canonicalizePath([...path]);
-    if (options.noSyncPaths.has(key)) return true;
-    return false;
-  }
-  function postPatches() {
-    if (lifecycle !== "established") return;
-    const next = snapshotForm(state.form.value);
-    const rawPatches = [];
-    diffAndApply(prior.form, next, [], (p) => rawPatches.push(p));
-    const safePatches = [];
-    for (const p of rawPatches) {
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && isFileLikeValue(p.value)) continue;
-      safePatches.push(p);
-    }
-    const { added, removed } = diffBlankPaths(prior.blankPathsSnapshot, state.blankPaths);
-    if (safePatches.length === 0 && added.length === 0 && removed.length === 0) {
-      prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
-      return;
+  })();
+  async function writePathImmediately(path) {
+    if (isDisposed()) return;
+    await writer.flush();
+    if (isDisposed()) return;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    const value = getAtPath(toRaw(state.form.value), path);
+    const nextForm = setAtPath(existing?.data.form ?? {}, path, value);
+    const { key: pathKey } = canonicalizePath(path);
+    const transientSet = new Set(
+      (existing?.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    for (const liveKey of state.blankPaths) {
+      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
+        transientSet.add(liveKey);
+      }
     }
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "patches",
-      senderId,
-      formPatches: safePatches,
-      blankPathsAdded: added,
-      blankPathsRemoved: removed
-    });
-    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
-  }
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (disposed) return;
-    if (lifecycle !== "established") return;
-    if (meta?.crossTab === true) return;
-    if (meta?.hydration === true) {
-      refreshPrior();
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
       return;
     }
-    postPatches();
-  });
-  function applyIncomingForm(form, blankPaths) {
-    state.blankPaths.clear();
-    for (const k of blankPaths) state.blankPaths.add(k);
-    state.applyFormReplacement(form, { crossTab: true, persist: false });
-    refreshPrior();
-  }
-  function handlePatches(msg) {
-    if (lifecycle !== "established") return;
-    const safePatches = [];
-    for (const p of msg.formPatches) {
-      if (!Array.isArray(p.path)) continue;
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && !isInboundShapeAcceptable(state.schema, p.path, p.value)) {
-        continue;
-      }
-      safePatches.push(p);
+    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
+    const userMap = new Map(existing?.data.userErrors ?? []);
+    const currentSchema = state.schemaErrors.get(pathKey);
+    const currentUser = state.userErrors.get(pathKey);
+    if (currentSchema !== void 0 && currentSchema.length > 0) {
+      schemaMap.set(pathKey, [...currentSchema]);
+    } else {
+      schemaMap.delete(pathKey);
     }
-    const safeBlankAdded = [];
-    for (const k of msg.blankPathsAdded) {
-      const segs = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
+    if (currentUser !== void 0 && currentUser.length > 0) {
+      userMap.set(pathKey, [...currentUser]);
+    } else {
+      userMap.delete(pathKey);
     }
-    const safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
+  }
+  async function clearPersistedDraft(path) {
+    if (isDisposed()) return;
+    await writer.flush();
+    if (isDisposed()) return;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    if (path === void 0) {
+      await adapter.removeItem(key);
+      return;
     }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    if (existing === null) return;
+    const nextForm = deleteAtPath(existing.data.form, path);
+    if (isEmptyContainer(nextForm)) {
+      await adapter.removeItem(key);
       return;
     }
-    const candidate = applyPatchesForward(state.form.value, safePatches);
-    try {
-      options.validateForm(state.form.value);
-      try {
-        options.validateForm(candidate);
-      } catch {
-        return;
-      }
-    } catch {
+    const { key: pathKey } = canonicalizePath(path);
+    const transientSet = new Set(
+      (existing.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
+      return;
     }
-    const nextBlankPaths = new Set(state.blankPaths);
-    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
-    for (const k of safeBlankAdded) nextBlankPaths.add(k);
-    applyIncomingForm(candidate, [...nextBlankPaths]);
+    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
+    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
+    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
+    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
   }
-  function handleSnapshot(msg) {
-    if (lifecycle !== "joining") return;
-    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
-    if (snapshotTimeoutTimer !== null) {
-      clearTimeout(snapshotTimeoutTimer);
-      snapshotTimeoutTimer = null;
-    }
-    if (joinCollectionTimer !== null) {
-      clearTimeout(joinCollectionTimer);
-      joinCollectionTimer = null;
-    }
-    applyIncomingForm(msg.form, msg.blankPaths);
-    lifecycle = "established";
-    peerIds.clear();
+  function awaitPendingWrites() {
+    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
+    if (isDisposed()) return Promise.resolve();
+    return writer.flush().catch(() => void 0);
   }
-  function respondToHello() {
-    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
+  function dispose() {
+    if (isDisposed() || inFlightFinalFlush !== null) return;
+    unsubscribeChange();
+    unsubscribeSuccess();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", handlePageHide);
+    }
+    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
+      disposed = true;
+      inFlightFinalFlush = null;
+    });
   }
-  function respondToSnapshotRequest() {
-    const scrubbedForm = stripSensitivePathsDeep(state.form.value, [], options.isSensitivePath);
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "snapshot",
-      senderId,
-      form: scrubbedForm,
-      blankPaths: [...state.blankPaths]
-    });
-  }
-  channel.onmessage = (event) => {
-    if (disposed) return;
-    const data = event.data;
-    if (!isValidSyncMessage(data)) return;
-    const msg = data;
-    if (msg.senderId === senderId) return;
-    switch (msg.kind) {
-      case "hello":
-        if (lifecycle !== "established") return;
-        respondToHello();
-        break;
-      case "announce":
-        if (lifecycle === "joining") peerIds.add(msg.senderId);
-        break;
-      case "requestSnapshot":
-        if (lifecycle !== "established") return;
-        if (msg.targetId !== senderId) return;
-        respondToSnapshotRequest();
-        break;
-      case "snapshot":
-        handleSnapshot(msg);
-        break;
-      case "patches":
-        handlePatches(msg);
-        break;
-    }
-  };
-  function electLeaderAndRequest() {
-    if (disposed) return;
-    if (peerIds.size === 0) {
-      lifecycle = "established";
-      refreshPrior();
-      return;
-    }
-    const sorted = [...peerIds].sort();
-    const leaderId = sorted[0];
-    peerIds.delete(leaderId);
-    leaderAttempts++;
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "requestSnapshot",
-      senderId,
-      targetId: leaderId
-    });
-    snapshotTimeoutTimer = setTimeout(() => {
-      snapshotTimeoutTimer = null;
-      if (disposed) return;
-      if (lifecycle === "established") return;
-      if (leaderAttempts >= MAX_LEADER_ATTEMPTS || peerIds.size === 0) {
-        lifecycle = "established";
-        refreshPrior();
-        return;
-      }
-      electLeaderAndRequest();
-    }, SNAPSHOT_TIMEOUT_MS);
-  }
-  function joinFlow() {
-    safePost({ v: PROTOCOL_VERSION, kind: "hello", senderId });
-    joinCollectionTimer = setTimeout(() => {
-      joinCollectionTimer = null;
-      if (disposed) return;
-      if (lifecycle === "established") return;
-      electLeaderAndRequest();
-    }, JOIN_COLLECTION_WINDOW_MS);
-  }
-  joinFlow();
   return {
-    dispose: () => {
-      if (disposed) return;
-      disposed = true;
-      if (joinCollectionTimer !== null) {
-        clearTimeout(joinCollectionTimer);
-        joinCollectionTimer = null;
-      }
-      if (snapshotTimeoutTimer !== null) {
-        clearTimeout(snapshotTimeoutTimer);
-        snapshotTimeoutTimer = null;
-      }
-      unsubscribeChange();
-      try {
-        channel.close();
-      } catch {
-      }
-    },
-    lifecycle: () => lifecycle,
-    senderId,
-    channelName
+    wiredConfig: config,
+    writePathImmediately,
+    clearPersistedDraft,
+    awaitPendingWrites,
+    dispose
   };
 }
-const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
-
-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 isEmptyContainer(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainRecord(value)) return Object.keys(value).length === 0;
+  return false;
 }
-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 collectPersistedLeafPaths(form) {
+  const out = [];
+  walk(form, []);
+  return out;
+  function walk(node, prefix) {
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        walk(node[i], [...prefix, i]);
+      }
+      return;
+    }
+    if (isPlainRecord(node)) {
+      for (const key of Object.keys(node)) {
+        walk(node[key], [...prefix, key]);
+      }
+      return;
+    }
+    if (prefix.length === 0) return;
+    out.push(canonicalizePath(prefix).key);
   }
 }
-function isSecureContext() {
-  return typeof window !== "undefined" && window.isSecureContext === true;
+function isDescendantPathKey(candidate, ancestor) {
+  if (candidate.length <= ancestor.length) return false;
+  if (!ancestor.endsWith("]")) return false;
+  const childPrefix = `${ancestor.slice(0, -1)},`;
+  return candidate.startsWith(childPrefix);
 }
 
-function resolveTrichotomy(input) {
-  if (typeof input === "function") {
-    return { kind: "async", factory: input };
-  }
-  return { kind: "sync", value: input };
+const PROTOCOL_VERSION = 1;
+const JOIN_COLLECTION_WINDOW_MS = 50;
+const SNAPSHOT_TIMEOUT_MS = 200;
+const MAX_LEADER_ATTEMPTS = 3;
+const SNAPSHOT_RESPONSE_MIN_INTERVAL_MS = 500;
+function isFileLikeValue(value) {
+  if (typeof File !== "undefined" && value instanceof File) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return false;
 }
-
-function useAbstractForm(configuration, options) {
-  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new InvalidUseFormConfigError();
-  }
-  const key = resolveFormKey(configuration.key);
-  const instance = getCurrentInstance();
-  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
-  const registry = options?.registry ?? useRegistry();
-  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
-  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
-  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
-  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
-  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
-  const maxRecursionDepth = normalizeNumericOption({
-    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
-    source: "useForm.maxRecursionDepth",
-    allowInfinity: true,
-    min: 0,
-    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) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
+function isInboundShapeAcceptable(schema, path, value) {
+  if (isFileLikeValue(value)) return false;
+  let kind;
+  if (Array.isArray(value)) {
+    kind = "array";
+  } else if (value !== null && typeof value === "object" && isPlainRecord(value)) {
+    kind = "object";
+  } else {
+    kind = slimKindOf(value);
   }
-  const hadPendingHydration = registry.pendingHydration.has(key);
-  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
-  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
-    state.defaultsResolved.value = true;
+  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
+  if (!accepted.has(kind)) return false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if (!isInboundShapeAcceptable(schema, [...path, i], value[i])) return false;
+    }
+    return true;
   }
-  if (existing === void 0 && resolvedDefaults.kind === "async") {
-    const factory = resolvedDefaults.factory;
-    state.defaultValuesFactory.value = factory;
-    if (hadPendingHydration) {
-      state.hydrating.value = false;
-      state.defaultsResolved.value = true;
-    } else if (registry.ssr) {
-      if (configuration.__ssrAccessed === true) {
-        registry.enqueuePrefetch(key);
-      }
-      onServerPrefetch(() => {
-        if (!registry.shouldPrefetch(key)) return;
-        return state.activate();
-      });
+  if (isPlainRecord(value)) {
+    for (const key of Object.keys(value)) {
+      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
     }
+    return true;
   }
-  if (getCurrentScope() !== void 0) {
-    const releaseConsumer = registry.trackConsumer(key);
-    onScopeDispose(releaseConsumer);
+  return true;
+}
+function diffBlankPaths(prev, curr) {
+  const added = [];
+  const removed = [];
+  const prevSet = new Set(prev);
+  for (const k of curr) if (!prevSet.has(k)) added.push(k);
+  for (const k of prev) if (!curr.has(k)) removed.push(k);
+  return { added, removed };
+}
+function snapshotForm(form) {
+  return structuralSnapshot(form);
+}
+function stripSensitivePathsDeep(value, pathSoFar, isSensitivePath) {
+  if (isFileLikeValue(value)) return void 0;
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map((item, i) => stripSensitivePathsDeep(item, [...pathSoFar, i], isSensitivePath));
   }
-  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 persistenceModule = wirePersistence(state, resolvedPersist);
-        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
-        state.registerDrain(() => persistenceModule.awaitPendingWrites());
-        state.registerCleanup(() => persistenceModule.dispose());
-      }
-    } else {
-      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  const out = {};
+  const src = value;
+  for (const key of Object.keys(src)) {
+    const childPath = [...pathSoFar, key];
+    if (isSensitivePath(childPath)) {
+      safeAssign(out, key, void 0);
+      continue;
     }
+    safeAssign(out, key, stripSensitivePathsDeep(src[key], childPath, isSensitivePath));
   }
-  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 channelName;
-      try {
-        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
-      } catch {
-        channelName = null;
-      }
-      if (channelName !== null) {
-        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());
-      }
-    } else if (hasBroadcastChannel && !secureContext) {
-      warnOnceInsecureContext("multiTab");
-    }
+  return out;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isPatchArray(value) {
+  return Array.isArray(value) && value.every(
+    (p) => p !== null && typeof p === "object" && Array.isArray(p.path)
+  );
+}
+function isValidSyncMessage(data) {
+  if (data === null || typeof data !== "object") return false;
+  const m = data;
+  if (m["v"] !== PROTOCOL_VERSION) return false;
+  if (typeof m["senderId"] !== "string") return false;
+  if (typeof m["kind"] !== "string") return false;
+  switch (m["kind"]) {
+    case "hello":
+    case "announce":
+      return true;
+    case "requestSnapshot":
+      return typeof m["targetId"] === "string";
+    case "snapshot":
+      return isStringArray(m["blankPaths"]) && "form" in m;
+    case "patches":
+      return isPatchArray(m["formPatches"]) && isStringArray(m["blankPathsAdded"]) && isStringArray(m["blankPathsRemoved"]);
+    default:
+      return false;
   }
-  if (existing === void 0 && merged.history !== void 0) {
-    const historyModule = createHistoryModule(state, merged.history);
-    state.modules.set(HISTORY_MODULE_KEY, historyModule);
-    state.registerCleanup(() => historyModule.dispose());
+}
+function generateSenderId() {
+  try {
+    return globalThis.crypto.randomUUID();
+  } catch {
+    return `atta-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
   }
-  if (configuration.key === void 0) {
-    recordAmbientProvide(registry.ssr);
-    provide(kFormContext, state);
+}
+function createMultiTabSyncModule(state, channelName, options) {
+  if (typeof BroadcastChannel === "undefined") {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  const formInstanceId = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
-  if (getCurrentInstance() !== null) {
-    provide(kFormInstanceId, formInstanceId);
+  let channel;
+  try {
+    channel = new BroadcastChannel(channelName);
+  } catch {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  const apiOptions = {};
-  if (merged.onInvalidSubmit !== void 0) {
-    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  const senderId = generateSenderId();
+  let lifecycle = "joining";
+  let disposed = false;
+  const peerIds = /* @__PURE__ */ new Set();
+  const lastSnapshotResponseAt = /* @__PURE__ */ new Map();
+  let joinCollectionTimer = null;
+  let snapshotTimeoutTimer = null;
+  let leaderAttempts = 0;
+  let prior = {
+    form: snapshotForm(state.form.value),
+    blankPathsSnapshot: [...state.blankPaths]
+  };
+  function safePost(msg) {
+    if (disposed) return;
+    try {
+      channel.postMessage(msg);
+    } catch {
+    }
   }
-  const history = state.modules.get(HISTORY_MODULE_KEY);
-  if (history !== void 0) {
-    apiOptions.history = history;
+  function refreshPrior() {
+    prior = {
+      form: snapshotForm(state.form.value),
+      blankPathsSnapshot: [...state.blankPaths]
+    };
   }
-  if (merged.validateOn !== void 0) {
-    apiOptions.validateOn = merged.validateOn;
+  function isPathLocallySuppressed(path) {
+    if (options.isSensitivePath(path)) return true;
+    const { key } = canonicalizePath([...path]);
+    if (options.noSyncPaths.has(key)) return true;
+    return false;
   }
-  const mergedDebounceMs = merged.debounceMs;
-  if (mergedDebounceMs !== void 0) {
-    apiOptions.debounceMs = mergedDebounceMs;
+  function postPatches() {
+    if (lifecycle !== "established") return;
+    const next = snapshotForm(state.form.value);
+    const rawPatches = [];
+    diffAndApply(prior.form, next, [], (p) => rawPatches.push(p));
+    const safePatches = [];
+    for (const p of rawPatches) {
+      if (isPathLocallySuppressed(p.path)) continue;
+      if ("value" in p && isFileLikeValue(p.value)) continue;
+      safePatches.push(p);
+    }
+    const { added, removed } = diffBlankPaths(prior.blankPathsSnapshot, state.blankPaths);
+    if (safePatches.length === 0 && added.length === 0 && removed.length === 0) {
+      prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
+      return;
+    }
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "patches",
+      senderId,
+      formPatches: safePatches,
+      blankPathsAdded: added,
+      blankPathsRemoved: removed
+    });
+    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
   }
-  if (merged.getDisplayState !== void 0) {
-    apiOptions.getDisplayState = merged.getDisplayState;
+  const unsubscribeChange = state.onFormChange((_next, meta) => {
+    if (disposed) return;
+    if (lifecycle !== "established") return;
+    if (meta?.crossTab === true) return;
+    if (meta?.hydration === true) {
+      refreshPrior();
+      return;
+    }
+    postPatches();
+  });
+  function applyIncomingForm(form, blankPaths) {
+    state.blankPaths.clear();
+    for (const k of blankPaths) state.blankPaths.add(k);
+    state.applyFormReplacement(form, { crossTab: true, persist: false });
+    refreshPrior();
   }
-  if (merged.coerce !== void 0) {
-    apiOptions.coerce = merged.coerce;
+  function handlePatches(msg) {
+    if (lifecycle !== "established") return;
+    const safePatches = [];
+    for (const p of msg.formPatches) {
+      if (!Array.isArray(p.path)) continue;
+      if (isPathLocallySuppressed(p.path)) continue;
+      if ("value" in p && !isInboundShapeAcceptable(state.schema, p.path, p.value)) {
+        continue;
+      }
+      safePatches.push(p);
+    }
+    const safeBlankAdded = [];
+    for (const k of msg.blankPathsAdded) {
+      const segs = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankAdded.push(k);
+    }
+    const safeBlankRemoved = [];
+    for (const k of msg.blankPathsRemoved) {
+      const segs = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankRemoved.push(k);
+    }
+    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+      return;
+    }
+    const candidate = applyPatchesForward(state.form.value, safePatches);
+    try {
+      options.validateForm(state.form.value);
+      try {
+        options.validateForm(candidate);
+      } catch {
+        return;
+      }
+    } catch {
+    }
+    const nextBlankPaths = new Set(state.blankPaths);
+    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
+    for (const k of safeBlankAdded) nextBlankPaths.add(k);
+    applyIncomingForm(candidate, [...nextBlankPaths]);
   }
-  if (merged.rememberVariants !== void 0) {
-    apiOptions.rememberVariants = merged.rememberVariants;
+  function handleSnapshot(msg) {
+    if (lifecycle !== "joining") return;
+    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
+    if (snapshotTimeoutTimer !== null) {
+      clearTimeout(snapshotTimeoutTimer);
+      snapshotTimeoutTimer = null;
+    }
+    if (joinCollectionTimer !== null) {
+      clearTimeout(joinCollectionTimer);
+      joinCollectionTimer = null;
+    }
+    applyIncomingForm(msg.form, msg.blankPaths);
+    lifecycle = "established";
+    peerIds.clear();
   }
-  if (merged.autoAria !== void 0) {
-    apiOptions.autoAria = merged.autoAria;
+  function respondToHello() {
+    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
   }
-  return buildFormApi(
-    state,
-    formInstanceId,
-    apiOptions
-  );
-}
-function mergeWithDefaults(defaults, configuration) {
-  const strict = configuration.strict ?? defaults.strict;
-  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
-  const history = configuration.history ?? defaults.history;
-  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
-  const coerce = configuration.coerce ?? defaults.coerce;
-  const validateOn = configuration.validateOn ?? defaults.validateOn;
-  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,
-    ...strict === void 0 ? {} : { strict },
-    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
-    ...history === void 0 ? {} : { history },
-    ...rememberVariants === void 0 ? {} : { rememberVariants },
-    ...coerce === void 0 ? {} : { coerce },
-    ...validateOn === void 0 ? {} : { validateOn },
-    ...debounceMs === void 0 ? {} : { debounceMs },
-    ...getDisplayState === void 0 ? {} : { getDisplayState },
-    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
-    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
-    ...multiTab === void 0 ? {} : { multiTab },
-    ...autoAria === void 0 ? {} : { autoAria }
-  };
-}
-const HISTORY_MODULE_KEY = "history";
-function buildFreshState(key, schema, configuration, registry) {
-  const pending = registry.pendingHydration.get(key);
-  if (pending !== void 0) registry.pendingHydration.delete(key);
-  const walked = walkUnsetSentinels(
-    configuration.defaultValues,
-    schema
-  );
-  let initialBlankPaths;
-  if (pending === void 0) {
-    initialBlankPaths = walked.paths;
+  function respondToSnapshotRequest(requesterId) {
+    const now = Date.now();
+    const last = lastSnapshotResponseAt.get(requesterId);
+    if (last !== void 0 && now - last < SNAPSHOT_RESPONSE_MIN_INTERVAL_MS) return;
+    lastSnapshotResponseAt.set(requesterId, now);
+    const scrubbedForm = stripSensitivePathsDeep(state.form.value, [], options.isSensitivePath);
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "snapshot",
+      senderId,
+      form: scrubbedForm,
+      blankPaths: [...state.blankPaths]
+    });
   }
-  const resolvedSensitiveNames = configuration.sensitiveNames;
-  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : createIsSensitivePath(resolvedSensitiveNames);
-  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : createSegmentMatchesSensitive(resolvedSensitiveNames);
-  const createOptions = {
-    formKey: key,
-    schema,
-    defaultValues: walked.cleanedValues,
-    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
-    hydration: pending,
-    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
-    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
-    ssr: registry.ssr,
-    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
-    // records intent on every `state.activate()` so a wizard skip-list
-    // override or a future transform mark has a consistent set to diff
-    // against; `shouldFire` lets the activate path bail when the
-    // wizard explicitly skipped this key — even an explicit
-    // `form.activate()` defers to the wizard's render-efficiency
-    // skip-list on the server.
-    ...registry.ssr ? {
-      ssrPrefetch: {
-        enqueue: () => {
-          registry.enqueuePrefetch(key);
-        },
-        shouldFire: () => registry.shouldPrefetch(key)
+  channel.onmessage = (event) => {
+    if (disposed) return;
+    try {
+      const data = event.data;
+      if (!isValidSyncMessage(data)) return;
+      const msg = data;
+      if (msg.senderId === senderId) return;
+      switch (msg.kind) {
+        case "hello":
+          if (lifecycle !== "established") return;
+          respondToHello();
+          break;
+        case "announce":
+          if (lifecycle === "joining") peerIds.add(msg.senderId);
+          break;
+        case "requestSnapshot":
+          if (lifecycle !== "established") return;
+          if (msg.targetId !== senderId) return;
+          respondToSnapshotRequest(msg.senderId);
+          break;
+        case "snapshot":
+          handleSnapshot(msg);
+          break;
+        case "patches":
+          handlePatches(msg);
+          break;
       }
-    } : {},
-    ...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 } : {},
-    ...resolvedSegmentMatchesSensitive !== void 0 ? { segmentMatchesSensitive: resolvedSegmentMatchesSensitive } : {}
-  };
-  const state = createFormStore(createOptions);
-  registry.forms.set(
-    key,
-    state
-  );
-  return state;
-}
-let anonCounter = 0;
-let formInstanceCounter = 0;
-const ambientProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(ssr) {
-  if (!__DEV__ || ssr || ambientProvideHistory === null) return;
-  const instance = getCurrentInstance();
-  if (instance === null) return;
-  const instanceKey = instance;
-  const entry = {
-    source: captureUserCallSite()
+    } catch {
+    }
   };
-  const existing = ambientProvideHistory.get(instanceKey);
-  if (existing === void 0) {
-    ambientProvideHistory.set(instanceKey, [entry]);
-    return;
-  }
-  existing.push(entry);
-}
-function resolveFormKey(key) {
-  if (key !== void 0 && key !== null && key !== "") {
-    if (key.startsWith(RESERVED_KEY_PREFIX)) {
-      throw new ReservedFormKeyError(key);
+  function electLeaderAndRequest() {
+    if (disposed) return;
+    if (peerIds.size === 0) {
+      lifecycle = "established";
+      refreshPrior();
+      return;
     }
-    return key;
+    const sorted = [...peerIds].sort();
+    const leaderId = sorted[0];
+    peerIds.delete(leaderId);
+    leaderAttempts++;
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "requestSnapshot",
+      senderId,
+      targetId: leaderId
+    });
+    snapshotTimeoutTimer = setTimeout(() => {
+      snapshotTimeoutTimer = null;
+      if (disposed) return;
+      if (lifecycle === "established") return;
+      if (leaderAttempts >= MAX_LEADER_ATTEMPTS || peerIds.size === 0) {
+        lifecycle = "established";
+        refreshPrior();
+        return;
+      }
+      electLeaderAndRequest();
+    }, SNAPSHOT_TIMEOUT_MS);
   }
-  if (getCurrentInstance() !== null) {
-    return `${ANONYMOUS_FORM_KEY_PREFIX}${useId()}`;
+  function joinFlow() {
+    safePost({ v: PROTOCOL_VERSION, kind: "hello", senderId });
+    joinCollectionTimer = setTimeout(() => {
+      joinCollectionTimer = null;
+      if (disposed) return;
+      if (lifecycle === "established") return;
+      electLeaderAndRequest();
+    }, JOIN_COLLECTION_WINDOW_MS);
   }
-  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
+  joinFlow();
+  return {
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      if (joinCollectionTimer !== null) {
+        clearTimeout(joinCollectionTimer);
+        joinCollectionTimer = null;
+      }
+      if (snapshotTimeoutTimer !== null) {
+        clearTimeout(snapshotTimeoutTimer);
+        snapshotTimeoutTimer = null;
+      }
+      unsubscribeChange();
+      try {
+        channel.close();
+      } catch {
+      }
+    },
+    lifecycle: () => lifecycle,
+    senderId,
+    channelName
+  };
 }
-function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
-  let existingFp;
-  let incomingFp;
-  try {
-    existingFp = existing.fingerprint();
-    incomingFp = incoming.fingerprint();
-  } catch (error) {
-    console.error(
-      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
-      error
-    );
-    return;
-  }
-  if (existingFp === incomingFp) return;
-  console.warn(
-    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
-  existing: ${existingFp}
-  incoming: ${incomingFp}`
-  );
+const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+
+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 warnOnPersistDivergence(key, existing, incomingPersist) {
-  if (incomingPersist === void 0) return;
-  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
-  const incomingNormalized = normalizePersistConfig(incomingPersist);
-  if (wired === void 0) {
-    console.warn(
-      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
-    );
-    return;
+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.";
   }
-  if (persistConfigsEquivalent(wired.wiredConfig, incomingNormalized)) return;
-  console.warn(
-    `[attaform] useForm({ key: "${key}" }) passed a persist config that differs from the first useForm({ key }) call's; first wins, this one is ignored.
-  wired:    ${describePersist(wired.wiredConfig)}
-  incoming: ${describePersist(incomingNormalized)}`
-  );
 }
-function persistConfigsEquivalent(a, b) {
-  if (a.storage !== b.storage) return false;
-  if ((a.key ?? void 0) !== (b.key ?? void 0)) return false;
-  if ((a.debounceMs ?? void 0) !== (b.debounceMs ?? void 0)) return false;
-  return true;
+function isSecureContext() {
+  return typeof window !== "undefined" && window.isSecureContext === true;
 }
-function describePersist(config) {
-  const storage = typeof config.storage === "string" ? config.storage : "custom-adapter";
-  const parts = [`storage=${storage}`];
-  if (config.key !== void 0) parts.push(`key=${config.key}`);
-  if (config.debounceMs !== void 0) parts.push(`debounceMs=${config.debounceMs}`);
-  return `{ ${parts.join(", ")} }`;
+
+function resolveTrichotomy(input) {
+  if (typeof input === "function") {
+    return { kind: "async", factory: input };
+  }
+  return { kind: "sync", value: input };
 }
-function wirePersistence(state, config) {
-  const fingerprint = hashStableString(state.schema.fingerprint());
-  const base = resolveStorageKeyBase(config, state.formKey);
-  const key = `${base}:${fingerprint}`;
-  const debounceMs = normalizeNumericOption({
-    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,
-    source: "useForm.persist.debounceMs",
-    allowInfinity: false,
+
+function useAbstractForm(configuration, options) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new InvalidUseFormConfigError();
+  }
+  const key = resolveFormKey(configuration.key);
+  const instance = getCurrentInstance();
+  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? useRegistry();
+  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
+  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
+  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
+  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
+  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
+  const maxRecursionDepth = normalizeNumericOption({
+    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
+    source: "useForm.maxRecursionDepth",
+    allowInfinity: true,
     min: 0,
-    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS
+    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
   });
-  const include = config.include ?? "form";
-  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
-  const adapterPromise = getStorageAdapter(config.storage);
-  let disposed = false;
-  let inFlightFinalFlush = null;
-  let pendingOptedInPaths = null;
-  const writer = createDebouncedWriter(async () => {
-    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
-    pendingOptedInPaths = null;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    if (optedInPaths.size === 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const rawForm = toRaw(state.form.value);
-    const filteredForm = pluckPaths(rawForm, optedInPaths);
-    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
-    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
-    const filteredTransientEmpty = /* @__PURE__ */ new Set();
-    for (const tk of state.blankPaths) {
-      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
-    }
-    const payload = buildPersistedPayload(
-      filteredForm,
-      include,
-      filteredSchemaErrors,
-      filteredUserErrors,
-      filteredTransientEmpty
-    );
-    await adapter.setItem(key, payload);
-  }, debounceMs);
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (disposed || inFlightFinalFlush !== null) return;
-    if (meta?.crossTab === true) return;
-    if (meta?.persist !== true) return;
-    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
-    writer.schedule();
-  });
-  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
-    if (disposed) return;
-    void (async () => {
-      await writer.flush();
-      if (disposed) return;
-      const adapter = await adapterPromise;
-      if (disposed) return;
-      await adapter.removeItem(key);
-    })();
-  }) : () => void 0;
-  void (async () => {
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    void cleanupOrphanKeys(adapter, base, key);
-    try {
-      const raw = await adapter.getItem(key);
-      const payload = readPersistedPayload(raw);
-      if (payload === null) {
-        if (raw !== null && raw !== void 0) {
-          await adapter.removeItem(key);
-        }
-        return;
-      }
-      if (disposed) return;
-      const merged = mergeSparseHydration(
-        toRaw(state.form.value),
-        payload.data.form,
-        state.schema
-      );
-      state.applyFormReplacement(merged, { hydration: true });
-      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
-      for (const k of persistedLeafPaths) {
-        state.blankPaths.delete(k);
-        state.originalBlankPaths.delete(k);
-      }
-      for (const k of payload.data.blankPaths ?? []) {
-        const key2 = coerceToPathKey(k);
-        state.blankPaths.add(key2);
-        state.originalBlankPaths.add(key2);
-      }
-      if (include === "form+errors") {
-        if (payload.data.schemaErrors !== void 0) {
-          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
-          state.setAllSchemaErrors(flat);
-        }
-        if (payload.data.userErrors !== void 0) {
-          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
-          state.setAllUserErrors(flat);
-        }
+  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) {
+    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+    warnOnPersistDivergence(key, existing, configuration.persist);
+  }
+  const hadPendingHydration = registry.pendingHydration.has(key);
+  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
+    state.defaultsResolved.value = true;
+  }
+  if (existing === void 0 && resolvedDefaults.kind === "async") {
+    const factory = resolvedDefaults.factory;
+    state.defaultValuesFactory.value = factory;
+    if (hadPendingHydration) {
+      state.hydrating.value = false;
+      state.defaultsResolved.value = true;
+    } else if (registry.ssr) {
+      if (configuration.__ssrAccessed === true) {
+        registry.enqueuePrefetch(key);
       }
-      state.scheduleFieldValidation(
-        [],
-        true
-        /* immediate */
-      );
-    } catch {
+      onServerPrefetch(() => {
+        if (!registry.shouldPrefetch(key)) return;
+        return state.activate();
+      });
     }
-  })();
-  async function writePathImmediately(path) {
-    if (disposed) return;
-    await writer.flush();
-    if (disposed) return;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    const baseForm = existing?.data.form ?? {};
-    const value = getAtPath(toRaw(state.form.value), path);
-    const nextForm = setAtPath(baseForm, path, value);
-    const { key: pathKey } = canonicalizePath(path);
-    const transientSet = new Set(
-      (existing?.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    for (const liveKey of state.blankPaths) {
-      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
-        transientSet.add(liveKey);
+  }
+  if (getCurrentScope() !== void 0) {
+    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 persistenceModule = wirePersistence(state, resolvedPersist);
+        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
+        state.registerDrain(() => persistenceModule.awaitPendingWrites());
+        state.registerCleanup(() => persistenceModule.dispose());
       }
-    }
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
-    const userMap = new Map(existing?.data.userErrors ?? []);
-    const currentSchema = state.schemaErrors.get(pathKey);
-    const currentUser = state.userErrors.get(pathKey);
-    if (currentSchema !== void 0 && currentSchema.length > 0) {
-      schemaMap.set(pathKey, [...currentSchema]);
-    } else {
-      schemaMap.delete(pathKey);
-    }
-    if (currentUser !== void 0 && currentUser.length > 0) {
-      userMap.set(pathKey, [...currentUser]);
     } else {
-      userMap.delete(pathKey);
+      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
     }
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
   }
-  async function clearPersistedDraft(path) {
-    if (disposed) return;
-    await writer.flush();
-    if (disposed) return;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    if (path === void 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    if (existing === null) return;
-    const nextForm = deleteAtPath(existing.data.form, path);
-    if (isEmptyContainer(nextForm)) {
-      await adapter.removeItem(key);
-      return;
+  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 channelName;
+      try {
+        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
+      } catch {
+        channelName = null;
+      }
+      if (channelName !== null) {
+        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());
+      }
+    } else if (hasBroadcastChannel && !secureContext) {
+      warnOnceInsecureContext("multiTab");
     }
-    const { key: pathKey } = canonicalizePath(path);
-    const transientSet = new Set(
-      (existing.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
+  }
+  if (existing === void 0 && merged.history !== void 0) {
+    const historyModule = createHistoryModule(state, merged.history);
+    state.modules.set(HISTORY_MODULE_KEY, historyModule);
+    state.registerCleanup(() => historyModule.dispose());
+  }
+  if (configuration.key === void 0) {
+    recordAmbientProvide(registry.ssr);
+    provide(kFormContext, state);
+  }
+  const formInstanceId = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
+  if (getCurrentInstance() !== null) {
+    provide(kFormInstanceId, formInstanceId);
+  }
+  const apiOptions = {};
+  if (merged.onInvalidSubmit !== void 0) {
+    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  }
+  const history = state.modules.get(HISTORY_MODULE_KEY);
+  if (history !== void 0) {
+    apiOptions.history = history;
+  }
+  if (merged.validateOn !== void 0) {
+    apiOptions.validateOn = merged.validateOn;
+  }
+  const mergedDebounceMs = merged.debounceMs;
+  if (mergedDebounceMs !== void 0) {
+    apiOptions.debounceMs = mergedDebounceMs;
+  }
+  if (merged.getDisplayState !== void 0) {
+    apiOptions.getDisplayState = merged.getDisplayState;
+  }
+  if (merged.coerce !== void 0) {
+    apiOptions.coerce = merged.coerce;
+  }
+  if (merged.rememberVariants !== void 0) {
+    apiOptions.rememberVariants = merged.rememberVariants;
+  }
+  if (merged.autoAria !== void 0) {
+    apiOptions.autoAria = merged.autoAria;
+  }
+  return buildFormApi(
+    state,
+    formInstanceId,
+    apiOptions
+  );
+}
+function mergeWithDefaults(defaults, configuration) {
+  const strict = configuration.strict ?? defaults.strict;
+  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
+  const history = configuration.history ?? defaults.history;
+  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
+  const coerce = configuration.coerce ?? defaults.coerce;
+  const validateOn = configuration.validateOn ?? defaults.validateOn;
+  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,
+    ...strict === void 0 ? {} : { strict },
+    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
+    ...history === void 0 ? {} : { history },
+    ...rememberVariants === void 0 ? {} : { rememberVariants },
+    ...coerce === void 0 ? {} : { coerce },
+    ...validateOn === void 0 ? {} : { validateOn },
+    ...debounceMs === void 0 ? {} : { debounceMs },
+    ...getDisplayState === void 0 ? {} : { getDisplayState },
+    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
+    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
+    ...multiTab === void 0 ? {} : { multiTab },
+    ...autoAria === void 0 ? {} : { autoAria }
+  };
+}
+const HISTORY_MODULE_KEY = "history";
+function buildFreshState(key, schema, configuration, registry) {
+  const pending = registry.pendingHydration.get(key);
+  if (pending !== void 0) registry.pendingHydration.delete(key);
+  const walked = walkUnsetSentinels(
+    configuration.defaultValues,
+    schema
+  );
+  let initialBlankPaths;
+  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,
+    defaultValues: walked.cleanedValues,
+    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
+    hydration: pending,
+    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
+    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
+    ssr: registry.ssr,
+    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
+    // records intent on every `state.activate()` so a wizard skip-list
+    // override or a future transform mark has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail when the
+    // wizard explicitly skipped this key — even an explicit
+    // `form.activate()` defers to the wizard's render-efficiency
+    // skip-list on the server.
+    ...registry.ssr ? {
+      ssrPrefetch: {
+        enqueue: () => {
+          registry.enqueuePrefetch(key);
+        },
+        shouldFire: () => registry.shouldPrefetch(key)
+      }
+    } : {},
+    ...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 } : {}
+  };
+  const state = createFormStore(createOptions);
+  registry.forms.set(
+    key,
+    state
+  );
+  return state;
+}
+let anonCounter = 0;
+let formInstanceCounter = 0;
+const ambientProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientProvide(ssr) {
+  if (!__DEV__ || ssr || ambientProvideHistory === null) return;
+  const instance = getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: captureUserCallSite()
+  };
+  const existing = ambientProvideHistory.get(instanceKey);
+  if (existing === void 0) {
+    ambientProvideHistory.set(instanceKey, [entry]);
+    return;
+  }
+  existing.push(entry);
+}
+function resolveFormKey(key) {
+  if (key !== void 0 && key !== null && key !== "") {
+    if (key.startsWith(RESERVED_KEY_PREFIX)) {
+      throw new ReservedFormKeyError(key);
     }
-    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
-    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
-    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
-    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
+    return key;
   }
-  function awaitPendingWrites() {
-    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
-    if (disposed) return Promise.resolve();
-    return writer.flush().catch(() => void 0);
+  if (getCurrentInstance() !== null) {
+    return `${ANONYMOUS_FORM_KEY_PREFIX}${useId()}`;
   }
-  function dispose() {
-    if (disposed || inFlightFinalFlush !== null) return;
-    unsubscribeChange();
-    unsubscribeSuccess();
-    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
-      disposed = true;
-      inFlightFinalFlush = null;
-    });
+  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
+}
+function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
+  let existingFp;
+  let incomingFp;
+  try {
+    existingFp = existing.fingerprint();
+    incomingFp = incoming.fingerprint();
+  } catch (error) {
+    console.error(
+      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
+      error
+    );
+    return;
   }
-  return {
-    wiredConfig: config,
-    writePathImmediately,
-    clearPersistedDraft,
-    awaitPendingWrites,
-    dispose
-  };
+  if (existingFp === incomingFp) return;
+  console.warn(
+    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
+  existing: ${existingFp}
+  incoming: ${incomingFp}`
+  );
 }
-function isEmptyContainer(value) {
-  if (value === void 0 || value === null) return true;
-  if (Array.isArray(value)) return value.length === 0;
-  if (isPlainRecord(value)) return Object.keys(value).length === 0;
-  return false;
+function warnOnPersistDivergence(key, existing, incomingPersist) {
+  if (incomingPersist === void 0) return;
+  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
+  const incomingNormalized = normalizePersistConfig(incomingPersist);
+  if (wired === void 0) {
+    console.warn(
+      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
+    );
+    return;
+  }
+  if (persistConfigsEquivalent(wired.wiredConfig, incomingNormalized)) return;
+  console.warn(
+    `[attaform] useForm({ key: "${key}" }) passed a persist config that differs from the first useForm({ key }) call's; first wins, this one is ignored.
+  wired:    ${describePersist(wired.wiredConfig)}
+  incoming: ${describePersist(incomingNormalized)}`
+  );
+}
+function persistConfigsEquivalent(a, b) {
+  if (a.storage !== b.storage) return false;
+  if ((a.key ?? void 0) !== (b.key ?? void 0)) return false;
+  if ((a.debounceMs ?? void 0) !== (b.debounceMs ?? void 0)) return false;
+  return true;
+}
+function describePersist(config) {
+  const storage = typeof config.storage === "string" ? config.storage : "custom-adapter";
+  const parts = [`storage=${storage}`];
+  if (config.key !== void 0) parts.push(`key=${config.key}`);
+  if (config.debounceMs !== void 0) parts.push(`debounceMs=${config.debounceMs}`);
+  return `{ ${parts.join(", ")} }`;
 }
 const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
 function enforceAnonPersistRule(formKey, ssr) {
@@ -5675,33 +6102,6 @@ function enforceAnonPersistRule(formKey, ssr) {
   }
   return true;
 }
-function collectPersistedLeafPaths(form) {
-  const out = [];
-  walk(form, []);
-  return out;
-  function walk(node, prefix) {
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) {
-        walk(node[i], [...prefix, i]);
-      }
-      return;
-    }
-    if (isPlainRecord(node)) {
-      for (const key of Object.keys(node)) {
-        walk(node[key], [...prefix, key]);
-      }
-      return;
-    }
-    if (prefix.length === 0) return;
-    out.push(canonicalizePath(prefix).key);
-  }
-}
-function isDescendantPathKey(candidate, ancestor) {
-  if (candidate.length <= ancestor.length) return false;
-  if (!ancestor.endsWith("]")) return false;
-  const childPrefix = `${ancestor.slice(0, -1)},`;
-  return candidate.startsWith(childPrefix);
-}
 
 let injectedInstanceCounter = 0;
 function injectForm(input) {
@@ -5781,8 +6181,6 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
-  push() {
-  },
   replace() {
   },
   read() {
@@ -5809,21 +6207,16 @@ function createWizardHistory(param) {
     for (const subscriber of subscribers) subscriber(value);
   }
   window.addEventListener("popstate", handlePopstate);
-  function safeWriteState(key, op) {
+  function safeReplaceState(key) {
     try {
-      const fn = op === "push" ? window.history.pushState : window.history.replaceState;
-      fn.call(window.history, {}, "", buildUrl(key));
+      window.history.replaceState({}, "", buildUrl(key));
     } catch {
     }
   }
   return {
-    push(key) {
-      if (disposed) return;
-      safeWriteState(key, "push");
-    },
     replace(key) {
       if (disposed) return;
-      safeWriteState(key, "replace");
+      safeReplaceState(key);
     },
     read() {
       const url = new URL(window.location.href);
@@ -5882,68 +6275,16 @@ function buildWizardStatusesProxy(statuses) {
     }
     return result;
   });
-  const target = (() => {
-  });
-  const proxyToString = () => JSON.stringify(snapshot.value);
-  const proxyToPrimitive = (hint) => hint === "number" ? NaN : proxyToString();
-  return new Proxy(target, {
-    apply(_, __, args) {
-      const key = args[0];
-      if (key === void 0) return snapshot.value;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    get(_, key) {
-      if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return proxyToPrimitive;
-        return Reflect.get(target, key);
-      }
-      if (key === "toJSON") return () => snapshot.value;
-      if (key === "toString") return proxyToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    has(_, key) {
-      if (typeof key === "symbol") return Reflect.has(target, key);
-      return Object.hasOwn(statuses, key);
-    },
-    ownKeys() {
-      return Object.keys(statuses);
-    },
-    getOwnPropertyDescriptor(_, key) {
-      if (typeof key === "symbol") return void 0;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return {
-        configurable: true,
-        enumerable: true,
-        writable: false,
-        value: computedEntry.value
-      };
-    },
-    set(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 write to "${String(key)}" was ignored. Statuses derive from each form's meta; mutate the underlying form instead.`
-        );
-      }
-      return true;
-    },
-    deleteProperty(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
-      return true;
-    },
-    defineProperty: () => true
+  return buildCallableReadonlySnapshotProxy({
+    surface: "wizard.statuses",
+    snapshot: () => snapshot.value,
+    resolveKey: (key) => statuses[key]?.value,
+    // Single-key callable form. Strings stringify naturally; non-
+    // string args coerce via `String(arg)` and miss the lookup, which
+    // resolves to `undefined` (consistent with property-access).
+    resolveCall: (arg) => statuses[String(arg)]?.value,
+    ownKeys: () => Object.keys(statuses),
+    hasKey: (key) => Object.hasOwn(statuses, key)
   });
 }
 
@@ -5960,6 +6301,12 @@ const NOOP_VALID_STATUS = {
   submitted: false,
   errorCount: 0
 };
+function asStatusSource(form) {
+  return form;
+}
+function asSubmissionSource(form) {
+  return form;
+}
 function useWizard(options) {
   const rawSteps = Array.isArray(options.steps) ? options.steps : [];
   if (rawSteps.length === 0 && __DEV__) {
@@ -6047,10 +6394,12 @@ function useWizard(options) {
       return { configurable: true, enumerable: true, writable: false, value: form };
     }
   });
-  const slotCtx = computed(() => ({
+  const slotCtx = {
     forms: slotForms,
-    currentKey: activeKey.value === "" ? void 0 : activeKey.value
-  }));
+    get currentKey() {
+      return activeKey.value === "" ? void 0 : activeKey.value;
+    }
+  };
   function resolveSlot(slot, index, ctx) {
     if (typeof slot === "string") {
       return getOrBuildNoop(slot);
@@ -6073,12 +6422,6 @@ function useWizard(options) {
     }
     return result;
   }
-  const lazyCtx = {
-    forms: slotForms,
-    get currentKey() {
-      return activeKey.value === "" ? void 0 : activeKey.value;
-    }
-  };
   for (let i = 0; i < rawSteps.length; i++) {
     const slot = rawSteps[i];
     if (isLazyMarker(slot)) {
@@ -6088,18 +6431,17 @@ function useWizard(options) {
         idx,
         computed(() => {
           void lazyEpoch.value;
-          return marker.resolve(lazyCtx);
+          return marker.resolve(slotCtx);
         })
       );
     }
   }
   const compiledSteps = computed(() => {
-    const ctx = slotCtx.value;
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < rawSteps.length; i++) {
       const slot = rawSteps[i];
-      const form = resolveSlot(slot, i, ctx);
+      const form = resolveSlot(slot, i, slotCtx);
       if (form === void 0) continue;
       if (seen.has(form.key)) {
         if (__DEV__) {
@@ -6125,9 +6467,12 @@ function useWizard(options) {
     return -1;
   });
   const currentStep = computed(() => {
-    const key = activeKey.value;
-    if (key !== "") return key;
-    const first = compiledSteps.value[0];
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    if (idx >= 0 && idx < list.length) {
+      return list[idx].key;
+    }
+    const first = list[0];
     return first === void 0 ? void 0 : first.key;
   });
   const activeForm = computed(() => {
@@ -6150,36 +6495,94 @@ function useWizard(options) {
     for (const step of compiledSteps.value) out[step.key] = step.form;
     return out;
   });
-  const allValues = computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      out[step.key] = source.values;
+  function isFormReady(key) {
+    const store = registry.forms.get(key);
+    return store?.defaultsResolved.value === true;
+  }
+  function toWizardAggregateError(err, fallbackKey) {
+    const entry = {
+      formKey: err.formKey ?? fallbackKey,
+      path: err.path,
+      message: err.message
+    };
+    if (err.code !== void 0) entry.code = err.code;
+    return entry;
+  }
+  const valuesCache = /* @__PURE__ */ new Map();
+  function valuesFor(form) {
+    const cached = valuesCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedValues = computed(() => source.values);
+    valuesCache.set(form.key, computedValues);
+    return computedValues;
+  }
+  const errorsCache = /* @__PURE__ */ new Map();
+  function errorsFor(form) {
+    const cached = errorsCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedErrors = computed(() => {
+      if (!isFormReady(form.key)) return [];
+      const errors = source.meta?.errors ?? [];
+      const list = [];
+      for (const err of errors) list.push(toWizardAggregateError(err, form.key));
+      return list;
+    });
+    errorsCache.set(form.key, computedErrors);
+    return computedErrors;
+  }
+  const allValues = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return valuesFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: valuesFor(form).value
+      };
     }
-    return out;
   });
-  const allErrors = computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      const list = [];
-      const store = registry.forms.get(step.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
-        const errors = source.meta?.errors ?? [];
-        for (const err of errors) {
-          const entry = {
-            formKey: step.key,
-            path: err.path,
-            message: err.message
-          };
-          if (err.code !== void 0) entry.code = err.code;
-          list.push(entry);
-        }
-      }
-      out[step.key] = list;
+  const allErrors = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return errorsFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: errorsFor(form).value
+      };
     }
-    return out;
   });
   const seedRef = ref(void 0);
   const seedInput = options.defaultStatuses;
@@ -6202,11 +6605,9 @@ function useWizard(options) {
   function statusFor(form) {
     const cached = statusCache.get(form.key);
     if (cached !== void 0) return cached;
-    const source = form;
+    const source = asStatusSource(form);
     const computedStatus = computed(() => {
-      const store = registry.forms.get(form.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
+      if (isFormReady(form.key)) {
         const meta = source.meta;
         if (meta !== void 0 && meta !== null) {
           return {
@@ -6349,7 +6750,7 @@ function useWizard(options) {
   }
   if (!registry.ssr) {
     for (const step of compiledSteps.value) {
-      const source = step.form;
+      const source = asSubmissionSource(step.form);
       if (typeof source.activate === "function") void source.activate();
     }
   }
@@ -6393,7 +6794,7 @@ function useWizard(options) {
   const submissionAttempts = ref(0);
   const done = ref(false);
   function activateForm(form) {
-    const source = form;
+    const source = asSubmissionSource(form);
     if (typeof source.activate === "function") {
       void source.activate();
     }
@@ -6493,7 +6894,7 @@ function useWizard(options) {
     };
   }
   async function processOne(form) {
-    const full = form;
+    const full = asSubmissionSource(form);
     let activationFailure;
     try {
       if (typeof full.activate === "function") await full.activate();
@@ -6525,15 +6926,7 @@ function useWizard(options) {
     for (const step of compiledSteps.value) {
       const processed = results.get(step.key);
       if (processed === void 0 || processed.success === true) continue;
-      for (const err of processed.errors) {
-        const entry = {
-          formKey: err.formKey,
-          path: err.path,
-          message: err.message
-        };
-        if (err.code !== void 0) entry.code = err.code;
-        out.push(entry);
-      }
+      for (const err of processed.errors) out.push(toWizardAggregateError(err, step.key));
     }
     return out;
   }
@@ -6587,8 +6980,7 @@ function useWizard(options) {
             if (processed !== void 0 && processed.success === true) {
               valuesMap[step.key] = processed.data;
             } else {
-              const source = step.form;
-              valuesMap[step.key] = source.values;
+              valuesMap[step.key] = asStatusSource(step.form).values;
             }
           }
           const ctx = buildSubmitContext(valuesMap, currentKey, final);
@@ -6609,8 +7001,11 @@ function useWizard(options) {
               moveTo(firstFailedKey);
               await nextTick();
               const failedForm = formsRecord.value[firstFailedKey];
-              if (failedForm !== void 0 && typeof failedForm.applyInvalidSubmitPolicy === "function") {
-                failedForm.applyInvalidSubmitPolicy();
+              if (failedForm !== void 0) {
+                const failedSource = asSubmissionSource(failedForm);
+                if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
+                  failedSource.applyInvalidSubmitPolicy();
+                }
               }
             }
           }
@@ -6625,7 +7020,7 @@ function useWizard(options) {
     done.value = false;
     lazyEpoch.value += 1;
     for (const step of compiledSteps.value) {
-      const full = step.form;
+      const full = asSubmissionSource(step.form);
       if (typeof full.reset === "function") full.reset();
     }
     const firstStep = compiledSteps.value[0];
@@ -6675,12 +7070,8 @@ function useWizard(options) {
       return count.value;
     },
     statuses,
-    get allValues() {
-      return allValues.value;
-    },
-    get allErrors() {
-      return allErrors.value;
-    },
+    allValues,
+    allErrors,
     get progress() {
       return progress.value;
     },
@@ -6811,5 +7202,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
-//# sourceMappingURL=attaform.BTi-PsHr.mjs.map
+export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, safeOwnRead as j, setAtPath as k, lazy as l, slimKindOf as m, normalizeNumericOption as n, useAbstractForm as o, useWizard as p, safeAssign as s, unset as u };
+//# sourceMappingURL=attaform.BqZuwLTK.mjs.map