attaform 0.19.0 → 0.20.1

package/dist/shared/{attaform.C1msmO2v.cjs → attaform.DLnE5bZa.cjs}

@@ -1,7 +1,30 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.BqEfHpVB.cjs');
+const paths = require('./attaform.BPy-4qRx.cjs');
+
+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) {
@@ -65,7 +88,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) {
@@ -94,9 +117,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) {
@@ -167,25 +190,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;
       }
     }
@@ -379,7 +402,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;
@@ -431,7 +455,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;
 }
@@ -490,7 +514,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) {
@@ -524,6 +548,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);
@@ -607,7 +632,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(paths.canonicalizePath(segments).key)?.value;
+  const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
   let dirty = false;
@@ -620,13 +645,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 (!paths.isPathPrefix(segments, entry.segments)) continue;
     if (segments.length === entry.segments.length) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
-    const leafKey = paths.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;
     }
@@ -638,7 +662,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;
@@ -693,7 +717,14 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState)
   let displayState;
   try {
     displayState = predicate(base, formMeta);
-  } catch {
+  } catch (err) {
+    if (paths.__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 {
@@ -730,6 +761,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 (!paths.__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;
@@ -761,12 +827,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, {
@@ -791,6 +857,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;
@@ -835,10 +904,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;
@@ -860,11 +944,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, {
@@ -882,7 +967,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);
@@ -909,9 +994,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;
@@ -975,29 +1073,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 === paths.FORM_ERRORS_PATH_KEY) {
+        if (segments.length === 0) keys.add("");
+        continue;
+      }
+      const decoded = paths.segmentsForPathKey(pathKey);
+      if (decoded === null) continue;
+      if (decoded.length <= segments.length) continue;
+      if (!paths.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);
@@ -1049,18 +1167,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) {
@@ -1090,9 +1208,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);
@@ -1214,9 +1333,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 (paths.__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 (paths.__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 delete of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      },
+      defineProperty: (_, key) => {
+        if (paths.__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;
@@ -1232,21 +1376,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);
@@ -1290,7 +1419,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;
@@ -1314,12 +1443,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 = paths.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 } };
@@ -1341,30 +1465,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) {
@@ -1377,7 +1506,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);
@@ -1385,12 +1514,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 };
@@ -1401,12 +1533,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 {
     }
   }
@@ -1417,12 +1544,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 {
     }
   }
@@ -1438,6 +1560,29 @@ function pluckPaths(form, pathKeys) {
   }
   return sparse ?? {};
 }
+function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
+  const acknowledgedSensitive = [];
+  for (const key of optedInPaths) {
+    const segs = paths.segmentsForPathKey(key);
+    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
+  }
+  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => paths.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) {
@@ -1466,8 +1611,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;
         }
@@ -1478,7 +1632,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;
 }
@@ -1579,39 +1742,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 {
@@ -2049,7 +2217,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;
@@ -2100,7 +2267,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);
@@ -2155,7 +2326,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         state.markInteracted(segments);
       },
       registerElement: (element) => {
-        if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
+        if (!paths.INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
         if (added) attachFocusListeners(state, segments, element, instanceMeta);
       },
@@ -2259,12 +2430,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;
@@ -2285,7 +2456,11 @@ function walkUnspecified(slim, segments, paths$1) {
   if (slim !== null && typeof slim === "object") {
     const out = {};
     for (const key of Object.keys(slim)) {
-      out[key] = walkUnspecified(slim[key], [...segments, key], paths$1);
+      safeAssign(
+        out,
+        key,
+        walkUnspecified(slim[key], [...segments, key], paths$1)
+      );
     }
     return out;
   }
@@ -2320,7 +2495,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;
@@ -2368,70 +2543,86 @@ function expandUnsetAt(segments, schema, paths$1) {
   return result;
 }
 
-function buildValuesProxy(form) {
-  const inner = vue.computed(() => vue.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 } = paths.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 (paths.__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 (paths.__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 = vue.computed(() => vue.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 } = paths.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;
+    }
   });
 }
 
@@ -2497,10 +2688,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 = paths.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 = paths.canonicalizePath(pathOrValue).segments;
     const writeUnsetAt = () => {
@@ -2649,23 +2848,45 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const rootFieldState = getRootFieldStateAt([]);
   const formMeta = vue.readonly(
     vue.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: vue.computed(() => rootFieldState.value.value),
-      original: vue.computed(() => rootFieldState.value.original),
-      pristine: vue.computed(() => rootFieldState.value.pristine),
-      dirty: vue.computed(() => rootFieldState.value.dirty),
-      focused: vue.computed(() => rootFieldState.value.focused),
-      blurred: vue.computed(() => rootFieldState.value.blurred),
-      touched: vue.computed(() => rootFieldState.value.touched),
-      interacted: vue.computed(() => rootFieldState.value.interacted),
-      blurredAfterInteraction: vue.computed(() => rootFieldState.value.blurredAfterInteraction),
-      connected: vue.computed(() => rootFieldState.value.connected),
-      element: vue.computed(() => rootFieldState.value.element),
-      elements: vue.computed(() => rootFieldState.value.elements),
-      updatedAt: vue.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
@@ -2688,21 +2909,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: vue.computed(() => rootFieldState.value.displayState),
-      showErrors: vue.computed(() => rootFieldState.value.showErrors),
-      showPending: vue.computed(() => rootFieldState.value.showPending),
-      showSuccess: vue.computed(() => rootFieldState.value.showSuccess),
-      showIdle: vue.computed(() => rootFieldState.value.showIdle),
-      firstError: vue.computed(() => rootFieldState.value.firstError),
-      path: vue.computed(() => rootFieldState.value.path),
-      id: vue.computed(() => rootFieldState.value.id),
-      aria: vue.computed(() => rootFieldState.value.aria),
-      key: vue.computed(() => rootFieldState.value.key),
-      blank: vue.computed(() => rootFieldState.value.blank),
-      label: vue.computed(() => rootFieldState.value.label),
-      description: vue.computed(() => rootFieldState.value.description),
-      placeholder: vue.computed(() => rootFieldState.value.placeholder),
-      meta: vue.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,
@@ -2711,7 +2962,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: vue.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
@@ -2748,12 +3001,20 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   function clear(pathInput) {
-    const segments = pathInput === void 0 ? paths.ROOT_PATH : paths.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 = paths.canonicalizePath(pathInput).segments;
-    paths.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
+    if (!paths.allowSensitivePersist(
+      segments,
+      options2?.acknowledgeSensitive === true,
+      state.isSensitivePath
+    )) {
+      return;
+    }
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2819,7 +3080,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);
@@ -2844,7 +3107,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);
   }
@@ -2938,9 +3201,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 && paths.__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 = paths.segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (!paths.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 = paths.segmentsForPathKey(memKey);
+        if (segs === null) continue;
+        if (paths.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 = vue.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) {
@@ -3000,6 +3386,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 = paths.segmentsForPathKey(key);
+          if (segments === null) continue;
+          if (!paths.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(paths.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(paths.canonicalizePath(relocated).key, snap.value);
+        }
+      };
+      relocate(tokens);
+      relocate(baselines);
+    },
     realign(arraySegs) {
       ensure(paths.canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
     },
@@ -3114,6 +3530,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 } = paths.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 = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.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 = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.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;
@@ -3137,43 +3641,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 && paths.__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 = paths.segmentsForPathKey(existingKey);
   if (parsed === null) return false;
@@ -3209,31 +3676,6 @@ function stripSymbolsDeep(value) {
   }
   return mutated ? out : value;
 }
-function cloneVariantSnapshot(value) {
-  if (value === null || typeof value !== "object") return value;
-  const raw = vue.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(paths.canonicalizePath(prefix).key);
   if (isPlainRecord(value)) {
@@ -3306,7 +3748,6 @@ function createFormStore(options) {
   const coerceIndex = resolveCoercionIndex(options.coerce);
   const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
   const resolvedIsSensitivePath = options.isSensitivePath ?? paths.isSensitivePath;
-  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? paths.segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -3369,117 +3810,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 = paths.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 = paths.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);
-    }
-  }
-  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;
+  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 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 } = paths.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 = paths.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 = paths.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 = vue.computed(() => {
     const result = /* @__PURE__ */ new Map();
@@ -3507,7 +3848,9 @@ function createFormStore(options) {
   const departAttempts = vue.ref(0);
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
-  let lastValidatedSnapshot = null;
+  const pathSnapshots = /* @__PURE__ */ new Map();
+  let scheduleEpoch = 0;
+  let lastCommittedEpoch = 0;
   const hydrating = vue.ref(false);
   const hydrateError = vue.ref(null);
   const defaultValuesFactory = vue.ref(void 0);
@@ -3523,9 +3866,12 @@ function createFormStore(options) {
   const pathAsyncCache = /* @__PURE__ */ new Map();
   function pathHasAsyncValidation(path) {
     const { key } = paths.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;
@@ -3617,6 +3963,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;
@@ -3740,8 +4101,13 @@ function createFormStore(options) {
     const pathKey = paths.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);
@@ -3765,14 +4131,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;
@@ -3797,18 +4163,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];
@@ -3880,12 +4240,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;
@@ -3897,11 +4255,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 ? paths.canonicalizePath(path).key : paths.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);
@@ -4144,11 +4516,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 = paths.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;
         });
       }
@@ -4160,10 +4545,6 @@ function createFormStore(options) {
       }
     }
   }
-  function markTouched(path) {
-    const { key } = paths.canonicalizePath(path);
-    touchFieldRecord(key, path, { touched: true });
-  }
   function markInteracted(path) {
     const { key } = paths.canonicalizePath(path);
     if (fields.get(key)?.interacted === true) return;
@@ -4173,7 +4554,7 @@ function createFormStore(options) {
     const formValue = form.value;
     let touchedAny = false;
     for (const [, entry] of originals) {
-      if (!isPathPrefix(segments, entry.segments)) continue;
+      if (!paths.isPathPrefix(segments, entry.segments)) continue;
       if (!hasAtPath(formValue, entry.segments)) continue;
       touchedAny = true;
       const leafKey = paths.canonicalizePath(entry.segments).key;
@@ -4187,9 +4568,6 @@ function createFormStore(options) {
       );
     }
   }
-  function clear(path) {
-    return setValueAtPath(path, schema.getEmptyValueAtPath(path));
-  }
   function rehydrate() {
     const factory = defaultValuesFactory.value;
     if (factory === void 0) {
@@ -4336,6 +4714,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 {
@@ -4347,13 +4728,7 @@ function createFormStore(options) {
   }
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = paths.canonicalizePath(path);
-    for (const memKey of [...variantMemory.keys()]) {
-      const memSegments = paths.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);
@@ -4367,7 +4742,7 @@ function createFormStore(options) {
       let anyMatch = false;
       for (const [, entry] of originals) {
         const leafSegments = entry.segments;
-        if (!isPathPrefix(targetSegments, leafSegments)) continue;
+        if (!paths.isPathPrefix(targetSegments, leafSegments)) continue;
         if (leafSegments.length === targetSegments.length) continue;
         anyMatch = true;
         const relative = leafSegments.slice(targetSegments.length);
@@ -4388,14 +4763,14 @@ function createFormStore(options) {
     deleteErrorsUnderPrefix(schemaErrors, targetSegments);
     deleteErrorsUnderPrefix(userErrors, targetSegments);
     for (const [fieldKey, record] of Array.from(fields.entries())) {
-      if (isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
+      if (paths.isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
     }
   }
   function deleteErrorsUnderPrefix(map, prefix) {
     for (const [errorKey, errs] of Array.from(map.entries())) {
       const first = errs[0];
       if (first === void 0) continue;
-      if (isPathPrefix(prefix, first.path)) {
+      if (paths.isPathPrefix(prefix, first.path)) {
         map.delete(errorKey);
       }
     }
@@ -4414,15 +4789,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 } = paths.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;
@@ -4484,6 +4855,7 @@ function createFormStore(options) {
     hydrating,
     hydrateError,
     defaultValuesFactory,
+    hasSsrPrefetch: ssrPrefetch !== void 0,
     defaultsResolved,
     activated,
     activationPromise,
@@ -4493,6 +4865,7 @@ function createFormStore(options) {
     activeValidations,
     firstValidationDone,
     pathHasAsyncValidation,
+    pathHasAsyncValidationByKey,
     fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
@@ -4500,7 +4873,6 @@ function createFormStore(options) {
     arrayElementKey,
     reset,
     resetField,
-    clear,
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
@@ -4513,11 +4885,11 @@ function createFormStore(options) {
     registerElement,
     deregisterElement,
     markFocused,
-    markTouched,
     markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    isPristineAtPathByKey,
     hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
@@ -4534,7 +4906,6 @@ function createFormStore(options) {
     modules,
     persistOptIns,
     isSensitivePath: resolvedIsSensitivePath,
-    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
     noSyncPaths,
     incrementNoSyncOptOut,
     decrementNoSyncOptOut,
@@ -4735,532 +5106,814 @@ 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 (paths.__DEV__) {
+      console.warn(
+        `[attaform] Could not fingerprint the schema for form '${state.formKey}': ${err instanceof Error ? err.message : String(err)}. Persistence falls back to a fingerprint-free key, so a schema change won't auto-invalidate a saved draft.`
+      );
     }
-    return 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 = vue.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)}`;
-  }
-}
-function createMultiTabSyncModule(state, channelName, options) {
-  if (typeof BroadcastChannel === "undefined") {
-    return {
-      dispose: () => void 0,
-      lifecycle: () => "established",
-      senderId: "",
-      channelName
-    };
+    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);
   }
-  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(
+        vue.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 } = paths.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(vue.toRaw(state.form.value), path);
+    const nextForm = setAtPath(existing?.data.form ?? {}, path, value);
+    const { key: pathKey } = paths.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 safeBlankAdded = [];
-    for (const k of msg.blankPathsAdded) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
+    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 safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
+    if (currentUser !== void 0 && currentUser.length > 0) {
+      userMap.set(pathKey, [...currentUser]);
+    } else {
+      userMap.delete(pathKey);
     }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+    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;
     }
-    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]);
-  }
-  function handleSnapshot(msg) {
-    if (lifecycle !== "joining") return;
-    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
-    if (snapshotTimeoutTimer !== null) {
-      clearTimeout(snapshotTimeoutTimer);
-      snapshotTimeoutTimer = null;
+    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 (joinCollectionTimer !== null) {
-      clearTimeout(joinCollectionTimer);
-      joinCollectionTimer = null;
+    const { key: pathKey } = paths.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;
     }
-    applyIncomingForm(msg.form, msg.blankPaths);
-    lifecycle = "established";
-    peerIds.clear();
+    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 respondToHello() {
-    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
+  function awaitPendingWrites() {
+    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
+    if (isDisposed()) return Promise.resolve();
+    return writer.flush().catch(() => void 0);
   }
-  function respondToSnapshotRequest() {
-    const scrubbedForm = stripSensitivePathsDeep(state.form.value, [], options.isSensitivePath);
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "snapshot",
-      senderId,
-      form: scrubbedForm,
-      blankPaths: [...state.blankPaths]
+  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;
     });
   }
-  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;
-    }
+  return {
+    wiredConfig: config,
+    writePathImmediately,
+    clearPersistedDraft,
+    awaitPendingWrites,
+    dispose
   };
-  function electLeaderAndRequest() {
-    if (disposed) return;
-    if (peerIds.size === 0) {
-      lifecycle = "established";
-      refreshPrior();
+}
+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 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;
     }
-    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;
+    if (isPlainRecord(node)) {
+      for (const key of Object.keys(node)) {
+        walk(node[key], [...prefix, key]);
       }
-      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);
+      return;
+    }
+    if (prefix.length === 0) return;
+    out.push(paths.canonicalizePath(prefix).key);
   }
-  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
-  };
 }
-const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+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);
+}
 
-const warned = /* @__PURE__ */ new Set();
-function warnOnceInsecureContext(feature) {
-  if (!paths.__DEV__) return;
-  if (warned.has(feature)) return;
-  warned.add(feature);
-  const message = featureMessage(feature);
-  console.warn(`[attaform] ${message}`);
+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 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 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;
+    }
+    return true;
+  }
+  if (isPlainRecord(value)) {
+    for (const key of Object.keys(value)) {
+      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
+    }
+    return true;
   }
+  return true;
 }
-function isSecureContext() {
-  return typeof window !== "undefined" && window.isSecureContext === 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 resolveTrichotomy(input) {
-  if (typeof input === "function") {
-    return { kind: "async", factory: input };
+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));
   }
-  return { kind: "sync", value: input };
+  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));
+  }
+  return out;
 }
-
-function useAbstractForm(configuration, options) {
-  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new paths.InvalidUseFormConfigError();
+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;
   }
-  const key = resolveFormKey(configuration.key);
-  const instance = vue.getCurrentInstance();
-  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
-  const registry = options?.registry ?? paths.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 paths.AnonPersistError({
-      cause: "no-key",
-      schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: paths.captureUserCallSite()
-    });
+}
+function generateSenderId() {
+  try {
+    return globalThis.crypto.randomUUID();
+  } catch {
+    return `atta-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
   }
-  const existing = registry.forms.get(key);
-  if (paths.__DEV__ && existing !== void 0) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
+}
+function createMultiTabSyncModule(state, channelName, options) {
+  if (typeof BroadcastChannel === "undefined") {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  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;
+  let channel;
+  try {
+    channel = new BroadcastChannel(channelName);
+  } catch {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  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);
-      }
-      vue.onServerPrefetch(() => {
-        if (!registry.shouldPrefetch(key)) return;
-        return state.activate();
-      });
+  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 {
     }
   }
-  if (vue.getCurrentScope() !== void 0) {
-    const releaseConsumer = registry.trackConsumer(key);
-    vue.onScopeDispose(releaseConsumer);
+  function refreshPrior() {
+    prior = {
+      form: snapshotForm(state.form.value),
+      blankPathsSnapshot: [...state.blankPaths]
+    };
   }
-  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}`);
+  function isPathLocallySuppressed(path) {
+    if (options.isSensitivePath(path)) return true;
+    const { key } = paths.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;
+    }
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "patches",
+      senderId,
+      formPatches: safePatches,
+      blankPathsAdded: added,
+      blankPathsRemoved: removed
+    });
+    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
   }
-  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;
+  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();
+  }
+  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 = paths.canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankAdded.push(k);
+    }
+    const safeBlankRemoved = [];
+    for (const k of msg.blankPathsRemoved) {
+      const segs = paths.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 {
-        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
+        options.validateForm(candidate);
       } 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());
+        return;
       }
-    } else if (hasBroadcastChannel && !secureContext) {
-      warnOnceInsecureContext("multiTab");
+    } 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 (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);
-    vue.provide(paths.kFormContext, state);
-  }
-  const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
-  if (vue.getCurrentInstance() !== null) {
-    vue.provide(paths.kFormInstanceId, formInstanceId);
-  }
-  const apiOptions = {};
-  if (merged.onInvalidSubmit !== void 0) {
-    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  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();
   }
-  const history = state.modules.get(HISTORY_MODULE_KEY);
-  if (history !== void 0) {
-    apiOptions.history = history;
+  function respondToHello() {
+    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
   }
-  if (merged.validateOn !== void 0) {
-    apiOptions.validateOn = merged.validateOn;
+  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 mergedDebounceMs = merged.debounceMs;
-  if (mergedDebounceMs !== void 0) {
-    apiOptions.debounceMs = mergedDebounceMs;
+  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;
+      }
+    } catch {
+    }
+  };
+  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);
   }
-  if (merged.getDisplayState !== void 0) {
-    apiOptions.getDisplayState = merged.getDisplayState;
+  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);
   }
-  if (merged.coerce !== void 0) {
+  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
+  };
+}
+const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+
+const warned = /* @__PURE__ */ new Set();
+function warnOnceInsecureContext(feature) {
+  if (!paths.__DEV__) return;
+  if (warned.has(feature)) return;
+  warned.add(feature);
+  const message = featureMessage(feature);
+  console.warn(`[attaform] ${message}`);
+}
+function featureMessage(feature) {
+  switch (feature) {
+    case "multiTab":
+      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
+    case "persist:local":
+      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+    case "persist:session":
+      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+  }
+}
+function isSecureContext() {
+  return typeof window !== "undefined" && window.isSecureContext === true;
+}
+
+function resolveTrichotomy(input) {
+  if (typeof input === "function") {
+    return { kind: "async", factory: input };
+  }
+  return { kind: "sync", value: input };
+}
+
+function useAbstractForm(configuration, options) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new paths.InvalidUseFormConfigError();
+  }
+  const key = resolveFormKey(configuration.key);
+  const instance = vue.getCurrentInstance();
+  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? paths.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 paths.AnonPersistError({
+      cause: "no-key",
+      schemaFields: extractSchemaFields(resolvedSchema),
+      callSite: paths.captureUserCallSite()
+    });
+  }
+  const existing = registry.forms.get(key);
+  if (paths.__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);
+      }
+      vue.onServerPrefetch(() => {
+        if (!registry.shouldPrefetch(key)) return;
+        return state.activate();
+      });
+    }
+  }
+  if (vue.getCurrentScope() !== void 0) {
+    const releaseConsumer = registry.trackConsumer(key);
+    vue.onScopeDispose(releaseConsumer);
+  }
+  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
+  if (existing === void 0 && !registry.ssr) {
+    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
+      const resolvedPersist = normalizePersistConfig(merged.persist);
+      const storageKind = resolvedPersist.storage;
+      const isBuiltinStorage = typeof storageKind === "string";
+      const secureContextOk = !isBuiltinStorage || isSecureContext();
+      if (!secureContextOk) {
+        const feature = storageKind === "session" ? "persist:session" : "persist:local";
+        warnOnceInsecureContext(feature);
+        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+      } else {
+        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
+        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
+        const 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}`);
+    }
+  }
+  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");
+    }
+  }
+  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);
+    vue.provide(paths.kFormContext, state);
+  }
+  const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
+  if (vue.getCurrentInstance() !== null) {
+    vue.provide(paths.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) {
@@ -5318,7 +5971,6 @@ function buildFreshState(key, schema, configuration, registry) {
   }
   const resolvedSensitiveNames = configuration.sensitiveNames;
   const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : paths.createIsSensitivePath(resolvedSensitiveNames);
-  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : paths.createSegmentMatchesSensitive(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -5347,319 +5999,94 @@ function buildFreshState(key, schema, configuration, registry) {
     ...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 } : {}
+    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {}
   };
   const state = createFormStore(createOptions);
   registry.forms.set(
     key,
     state
   );
-  return state;
-}
-let anonCounter = 0;
-let formInstanceCounter = 0;
-const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(ssr) {
-  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
-  const instance = vue.getCurrentInstance();
-  if (instance === null) return;
-  const instanceKey = instance;
-  const entry = {
-    source: paths.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 paths.ReservedFormKeyError(key);
-    }
-    return key;
-  }
-  if (vue.getCurrentInstance() !== null) {
-    return `${ANONYMOUS_FORM_KEY_PREFIX}${vue.useId()}`;
-  }
-  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;
-  }
-  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 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(", ")} }`;
-}
-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,
-    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;
-  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 = vue.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(
-        vue.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 = paths.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);
-        }
-      }
-      state.scheduleFieldValidation(
-        [],
-        true
-        /* immediate */
-      );
-    } catch {
-    }
-  })();
-  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(vue.toRaw(state.form.value), path);
-    const nextForm = setAtPath(baseForm, path, value);
-    const { key: pathKey } = paths.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 (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);
-    }
-    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;
-    }
-    const { key: pathKey } = paths.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;
+  return state;
+}
+let anonCounter = 0;
+let formInstanceCounter = 0;
+const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientProvide(ssr) {
+  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
+  const instance = vue.getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: paths.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 paths.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 (vue.getCurrentInstance() !== null) {
+    return `${ANONYMOUS_FORM_KEY_PREFIX}${vue.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) {
@@ -5677,33 +6104,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(paths.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) {
@@ -5783,8 +6183,6 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
-  push() {
-  },
   replace() {
   },
   read() {
@@ -5811,21 +6209,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);
@@ -5884,68 +6277,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 (paths.__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 (paths.__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)
   });
 }
 
@@ -5962,6 +6303,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 && paths.__DEV__) {
@@ -6049,10 +6396,12 @@ function useWizard(options) {
       return { configurable: true, enumerable: true, writable: false, value: form };
     }
   });
-  const slotCtx = vue.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);
@@ -6075,12 +6424,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)) {
@@ -6090,18 +6433,17 @@ function useWizard(options) {
         idx,
         vue.computed(() => {
           void lazyEpoch.value;
-          return marker.resolve(lazyCtx);
+          return marker.resolve(slotCtx);
         })
       );
     }
   }
   const compiledSteps = vue.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 (paths.__DEV__) {
@@ -6127,9 +6469,12 @@ function useWizard(options) {
     return -1;
   });
   const currentStep = vue.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 = vue.computed(() => {
@@ -6152,36 +6497,94 @@ function useWizard(options) {
     for (const step of compiledSteps.value) out[step.key] = step.form;
     return out;
   });
-  const allValues = vue.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 = vue.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 = vue.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 = vue.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 = vue.ref(void 0);
   const seedInput = options.defaultStatuses;
@@ -6204,11 +6607,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 = vue.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 {
@@ -6351,7 +6752,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();
     }
   }
@@ -6395,7 +6796,7 @@ function useWizard(options) {
   const submissionAttempts = vue.ref(0);
   const done = vue.ref(false);
   function activateForm(form) {
-    const source = form;
+    const source = asSubmissionSource(form);
     if (typeof source.activate === "function") {
       void source.activate();
     }
@@ -6495,7 +6896,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();
@@ -6527,15 +6928,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;
   }
@@ -6589,8 +6982,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);
@@ -6611,8 +7003,11 @@ function useWizard(options) {
               moveTo(firstFailedKey);
               await vue.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();
+                }
               }
             }
           }
@@ -6627,7 +7022,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];
@@ -6677,12 +7072,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;
     },
@@ -6825,9 +7216,11 @@ exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
 exports.lazy = lazy;
 exports.normalizeNumericOption = normalizeNumericOption;
+exports.safeAssign = safeAssign;
+exports.safeOwnRead = safeOwnRead;
 exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.C1msmO2v.cjs.map
+//# sourceMappingURL=attaform.DLnE5bZa.cjs.map