attaform 0.16.4 → 0.17.0

package/dist/shared/{attaform.fegmBJaq.cjs → attaform.BFumZXY2.cjs}

@@ -1,175 +1,8 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.CIwZtbGV.cjs');
-const plugin = require('./attaform.rIRYSUI1.cjs');
-
-function isDescendable(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (Array.isArray(value)) return true;
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
-}
-function appendSegment(prefix, segment) {
-  const next = new Array(prefix.length + 1);
-  for (let i = 0; i < prefix.length; i++) {
-    const s = prefix[i];
-    next[i] = s;
-  }
-  next[prefix.length] = segment;
-  return next;
-}
-function diffAndApply(oldValue, newValue, prefix, visit) {
-  if (Object.is(oldValue, newValue)) return;
-  const oldIsDescendable = isDescendable(oldValue);
-  const newIsDescendable = isDescendable(newValue);
-  if (oldValue === void 0 && newIsDescendable) {
-    if (Array.isArray(newValue)) {
-      for (let i = 0; i < newValue.length; i++) {
-        diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = newValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
-      }
-    }
-    return;
-  }
-  if (oldIsDescendable && newValue === void 0) {
-    if (Array.isArray(oldValue)) {
-      for (let i = 0; i < oldValue.length; i++) {
-        diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = oldValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
-      }
-    }
-    return;
-  }
-  if (oldIsDescendable && newIsDescendable) {
-    const oldIsArray = Array.isArray(oldValue);
-    const newIsArray = Array.isArray(newValue);
-    if (oldIsArray && newIsArray) {
-      const oldArr = oldValue;
-      const newArr = newValue;
-      const max = Math.max(oldArr.length, newArr.length);
-      for (let i = 0; i < max; i++) {
-        diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
-      }
-      return;
-    }
-    if (!oldIsArray && !newIsArray) {
-      const oldRec = oldValue;
-      const newRec = newValue;
-      const seen = /* @__PURE__ */ new Set();
-      for (const k of Object.keys(oldRec)) {
-        seen.add(k);
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
-      for (const k of Object.keys(newRec)) {
-        if (seen.has(k)) continue;
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
-      return;
-    }
-    visit({ kind: "changed", path: prefix, oldValue, newValue });
-    return;
-  }
-  if (oldIsDescendable && !newIsDescendable) {
-    visit({ kind: "changed", path: prefix, oldValue, newValue });
-    return;
-  }
-  if (!oldIsDescendable && newIsDescendable) {
-    visit({ kind: "changed", path: prefix, oldValue, newValue });
-    return;
-  }
-  if (oldValue === void 0) {
-    visit({ kind: "added", path: prefix, newValue });
-    return;
-  }
-  if (newValue === void 0) {
-    visit({ kind: "removed", path: prefix, oldValue });
-    return;
-  }
-  visit({ kind: "changed", path: prefix, oldValue, newValue });
-}
-function applyChangedKeys(target, source) {
-  if (!isDescendable(target) || !isDescendable(source)) return false;
-  const targetIsArray = Array.isArray(target);
-  const sourceIsArray = Array.isArray(source);
-  if (targetIsArray !== sourceIsArray) return false;
-  const ROOT_SENTINEL = Symbol.for("attaform.applyChangedKeys.rootMismatch");
-  const changedFirstSegments = /* @__PURE__ */ new Set();
-  diffAndApply(target, source, [], (patch) => {
-    if (patch.path.length === 0) {
-      changedFirstSegments.add(ROOT_SENTINEL);
-      return;
-    }
-    changedFirstSegments.add(patch.path[0]);
-  });
-  if (changedFirstSegments.has(ROOT_SENTINEL)) return false;
-  if (targetIsArray) {
-    const t = target;
-    const s = source;
-    if (t.length > s.length) t.length = s.length;
-    for (const idx of changedFirstSegments) {
-      if (typeof idx === "symbol") continue;
-      const i = typeof idx === "number" ? idx : Number(idx);
-      t[i] = s[i];
-    }
-  } else {
-    const t = target;
-    const s = source;
-    const sourceKeys = new Set(Object.keys(s));
-    for (const k of Object.keys(t)) {
-      if (!sourceKeys.has(k)) delete t[k];
-    }
-    for (const k of changedFirstSegments) {
-      if (typeof k === "symbol") continue;
-      t[String(k)] = s[String(k)];
-    }
-  }
-  return true;
-}
-function structuralSnapshot(value) {
-  if (!isDescendable(value)) return value;
-  if (Array.isArray(value)) {
-    const out2 = new Array(value.length);
-    for (let i = 0; i < value.length; i++) {
-      out2[i] = structuralSnapshot(value[i]);
-    }
-    return out2;
-  }
-  const src = value;
-  const out = {};
-  for (const k of Object.keys(src)) {
-    out[k] = structuralSnapshot(src[k]);
-  }
-  return out;
-}
-
-const EMPTY_RESOLVED_FIELD_META = Object.freeze({
-  label: "",
-  description: void 0,
-  placeholder: void 0,
-  meta: Object.freeze({})
-});
-
-function humanize(segment) {
-  if (typeof segment === "number") return "";
-  const str = String(segment);
-  if (str.length === 0) return "";
-  if (/^\d+$/.test(str)) return "";
-  const tokens = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((part) => part.length > 0);
-  if (tokens.length === 0) return "";
-  return tokens.map((part) => {
-    const head = part[0];
-    return head === void 0 ? part : head.toUpperCase() + part.slice(1).toLowerCase();
-  }).join(" ");
-}
+const plugin = require('./attaform.Dee2rU1P.cjs');
+const paths = require('./attaform.BBM2muQ9.cjs');
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -415,14 +248,230 @@ function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
   return rec;
 }
 
-function buildFieldStateAccessor(state, getFormMetaBase) {
+function isDescendable(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function appendSegment(prefix, segment) {
+  const next = new Array(prefix.length + 1);
+  for (let i = 0; i < prefix.length; i++) {
+    const s = prefix[i];
+    next[i] = s;
+  }
+  next[prefix.length] = segment;
+  return next;
+}
+function diffAndApply(oldValue, newValue, prefix, visit) {
+  if (Object.is(oldValue, newValue)) return;
+  const oldIsDescendable = isDescendable(oldValue);
+  const newIsDescendable = isDescendable(newValue);
+  if (oldValue === void 0 && newIsDescendable) {
+    if (Array.isArray(newValue)) {
+      for (let i = 0; i < newValue.length; i++) {
+        diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+      }
+    } else {
+      const rec = newValue;
+      for (const k of Object.keys(rec)) {
+        diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+      }
+    }
+    return;
+  }
+  if (oldIsDescendable && newValue === void 0) {
+    if (Array.isArray(oldValue)) {
+      for (let i = 0; i < oldValue.length; i++) {
+        diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+      }
+    } else {
+      const rec = oldValue;
+      for (const k of Object.keys(rec)) {
+        diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+      }
+    }
+    return;
+  }
+  if (oldIsDescendable && newIsDescendable) {
+    const oldIsArray = Array.isArray(oldValue);
+    const newIsArray = Array.isArray(newValue);
+    if (oldIsArray && newIsArray) {
+      const oldArr = oldValue;
+      const newArr = newValue;
+      const max = Math.max(oldArr.length, newArr.length);
+      for (let i = 0; i < max; i++) {
+        diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+      }
+      return;
+    }
+    if (!oldIsArray && !newIsArray) {
+      const oldRec = oldValue;
+      const newRec = newValue;
+      const seen = /* @__PURE__ */ new Set();
+      for (const k of Object.keys(oldRec)) {
+        seen.add(k);
+        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+      }
+      for (const k of Object.keys(newRec)) {
+        if (seen.has(k)) continue;
+        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+      }
+      return;
+    }
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldIsDescendable && !newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (!oldIsDescendable && newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldValue === void 0) {
+    visit({ kind: "added", path: prefix, newValue });
+    return;
+  }
+  if (newValue === void 0) {
+    visit({ kind: "removed", path: prefix, oldValue });
+    return;
+  }
+  visit({ kind: "changed", path: prefix, oldValue, newValue });
+}
+function applyChangedKeys(target, source) {
+  if (!isDescendable(target) || !isDescendable(source)) return false;
+  const targetIsArray = Array.isArray(target);
+  const sourceIsArray = Array.isArray(source);
+  if (targetIsArray !== sourceIsArray) return false;
+  const ROOT_SENTINEL = Symbol.for("attaform.applyChangedKeys.rootMismatch");
+  const changedFirstSegments = /* @__PURE__ */ new Set();
+  diffAndApply(target, source, [], (patch) => {
+    if (patch.path.length === 0) {
+      changedFirstSegments.add(ROOT_SENTINEL);
+      return;
+    }
+    changedFirstSegments.add(patch.path[0]);
+  });
+  if (changedFirstSegments.has(ROOT_SENTINEL)) return false;
+  if (targetIsArray) {
+    const t = target;
+    const s = source;
+    if (t.length > s.length) t.length = s.length;
+    for (const idx of changedFirstSegments) {
+      if (typeof idx === "symbol") continue;
+      const i = typeof idx === "number" ? idx : Number(idx);
+      t[i] = s[i];
+    }
+  } else {
+    const t = target;
+    const s = source;
+    const sourceKeys = new Set(Object.keys(s));
+    for (const k of Object.keys(t)) {
+      if (!sourceKeys.has(k)) delete t[k];
+    }
+    for (const k of changedFirstSegments) {
+      if (typeof k === "symbol") continue;
+      t[String(k)] = s[String(k)];
+    }
+  }
+  return true;
+}
+function applyPatchesForward(root, patches) {
+  let current = root;
+  for (const patch of patches) {
+    if (patch.path.length === 0) {
+      current = patch.kind === "removed" ? void 0 : patch.newValue;
+      continue;
+    }
+    if (patch.kind === "removed") {
+      current = deleteAtPath(current, patch.path);
+    } else {
+      current = setAtPath(current, patch.path, patch.newValue);
+    }
+  }
+  return current;
+}
+function applyPatchesInverse(root, patches) {
+  let current = root;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.path.length === 0) {
+      if (patch.kind === "added") {
+        current = void 0;
+      } else {
+        current = patch.oldValue;
+      }
+      continue;
+    }
+    if (patch.kind === "added") {
+      current = deleteAtPath(current, patch.path);
+    } else {
+      current = setAtPath(current, patch.path, patch.oldValue);
+    }
+  }
+  return current;
+}
+function structuralSnapshot(value) {
+  if (!isDescendable(value)) return value;
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      out2[i] = structuralSnapshot(value[i]);
+    }
+    return out2;
+  }
+  const src = value;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    out[k] = structuralSnapshot(src[k]);
+  }
+  return out;
+}
+
+const EMPTY_RESOLVED_FIELD_META = Object.freeze({
+  label: "",
+  description: void 0,
+  placeholder: void 0,
+  meta: Object.freeze({})
+});
+
+function humanize(segment) {
+  if (typeof segment === "number") return "";
+  const str = String(segment);
+  if (str.length === 0) return "";
+  if (/^\d+$/.test(str)) return "";
+  const tokens = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((part) => part.length > 0);
+  if (tokens.length === 0) return "";
+  return tokens.map((part) => {
+    const head = part[0];
+    return head === void 0 ? part : head.toUpperCase() + part.slice(1).toLowerCase();
+  }).join(" ");
+}
+
+function isUnderStubAncestor(state, segments) {
+  for (let i = 0; i < segments.length; i++) {
+    const ancestorPath = segments.slice(0, i);
+    const du = state.schema.getUnionDiscriminatorAtPath(ancestorPath);
+    if (du === void 0) continue;
+    const ancestorValue = getAtPath(state.form.value, ancestorPath);
+    if (ancestorValue === null || typeof ancestorValue !== "object") continue;
+    const discValue = ancestorValue[du.discriminatorKey];
+    if (discValue === void 0) return true;
+    if (!du.isVariantSelected(discValue)) return true;
+  }
+  return false;
+}
+function buildFieldStateAccessor(state, getFormMetaBase, options) {
   const cache = /* @__PURE__ */ new Map();
+  const predicate = options?.shouldShowErrors;
   return function getFieldState(pathInput) {
     const { segments, key } = paths.canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = vue.computed(
-      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, getFormMetaBase) : buildContainerFieldState(state, segments, key, getFormMetaBase)
+      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, getFormMetaBase, predicate)
     );
     cache.set(key, c);
     return c;
@@ -442,7 +491,8 @@ function buildLeafFieldStateBase(state, segments, key) {
   if (userForKey !== void 0) errors.push(...userForKey);
   const validating = (state.fieldValidationCounts.get(key) ?? 0) > 0;
   const gated = state.pathHasAsyncValidation(segments) && !state.firstValidationDone.value;
-  const valid = !gated && errors.length === 0 && !validating;
+  const isOrphan = segments.length > 0 && !hasAtPath(state.form.value, segments) && isUnderStubAncestor(state, segments);
+  const valid = !gated && errors.length === 0 && !validating && !isOrphan;
   const elementRecord = state.elements.get(key);
   const elementsArr = elementRecord ? Object.freeze([...elementRecord.elements]) : EMPTY_ELEMENTS;
   const firstElement = elementsArr[0] ?? null;
@@ -472,9 +522,9 @@ function buildLeafFieldStateBase(state, segments, key) {
     meta: resolved.meta
   };
 }
-function buildLeafFieldState(state, segments, key, getFormMetaBase) {
+function buildLeafFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
   const base = buildLeafFieldStateBase(state, segments, key);
-  return decorateWithDerivedProps(base, state, getFormMetaBase);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
 }
 function buildContainerFieldStateBase(state, segments, _key) {
   const formValue = state.form.value;
@@ -542,13 +592,14 @@ function buildContainerFieldStateBase(state, segments, _key) {
     meta: resolved.meta
   };
 }
-function buildContainerFieldState(state, segments, key, getFormMetaBase) {
+function buildContainerFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
   const base = buildContainerFieldStateBase(state, segments);
-  return decorateWithDerivedProps(base, state, getFormMetaBase);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors) {
   const firstError = base.errors[0];
-  const showErrors = base.errors.length > 0 && state.shouldShowErrors(base, getFormMetaBase());
+  const predicate = shouldShowErrors ?? state.shouldShowErrors;
+  const showErrors = base.errors.length > 0 && predicate(base, getFormMetaBase());
   return { ...base, showErrors, firstError };
 }
 function aggregateErrorsAt(state, prefix) {
@@ -733,14 +784,16 @@ function buildErrorsProxy(state) {
   return buildSurfaceProxy({
     schema: state.schema,
     resolveLeaf: (path) => {
-      if (!hasAtPath(state.form.value, path)) return void 0;
       const { key } = paths.canonicalizePath(path);
-      const schemaForKey = state.schemaErrors.get(key);
-      const blankForKey = state.derivedBlankErrors.value.get(key);
       const userForKey = state.userErrors.get(key);
+      const isActive = hasAtPath(state.form.value, path);
       const merged = [];
-      if (schemaForKey !== void 0) merged.push(...schemaForKey);
-      if (blankForKey !== void 0) merged.push(...blankForKey);
+      if (isActive) {
+        const schemaForKey = state.schemaErrors.get(key);
+        const blankForKey = state.derivedBlankErrors.value.get(key);
+        if (schemaForKey !== void 0) merged.push(...schemaForKey);
+        if (blankForKey !== void 0) merged.push(...blankForKey);
+      }
       if (userForKey !== void 0) merged.push(...userForKey);
       return merged.length === 0 ? void 0 : merged;
     },
@@ -765,7 +818,7 @@ function buildErrorsProxy(state) {
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
   const tree = Array.isArray(liveContainer) ? [] : {};
-  const collect = (store) => {
+  const collect = (store, applyActivePathFilter) => {
     entries: for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
       const fullPath = paths.segmentsForPathKey(pathKey);
@@ -774,13 +827,13 @@ function materializeErrors(state, containerSegments) {
       for (let i = 0; i < containerSegments.length; i++) {
         if (fullPath[i] !== containerSegments[i]) continue entries;
       }
-      if (!hasAtPath(state.form.value, fullPath)) continue;
+      if (applyActivePathFilter && !hasAtPath(state.form.value, fullPath)) continue;
       placeAt(tree, fullPath.slice(containerSegments.length), errors);
     }
   };
-  collect(state.schemaErrors);
-  collect(state.derivedBlankErrors.value);
-  collect(state.userErrors);
+  collect(state.schemaErrors, true);
+  collect(state.derivedBlankErrors.value, true);
+  collect(state.userErrors, false);
   return tree;
 }
 function placeAt(tree, path, errors) {
@@ -811,11 +864,13 @@ function buildFieldArrayApi(state) {
     const current = state.getValueAtPath(segments);
     return Array.isArray(current) ? current.slice() : [];
   }
-  function writeArray(path, next) {
+  function writeArray(path, next, arrayOp) {
     const { segments, key } = paths.canonicalizePath(path);
-    return state.setValueAtPath(segments, next, {
-      persist: state.persistOptIns.hasAnyOptInForPath(key)
-    });
+    const meta = {
+      persist: state.persistOptIns.hasAnyOptInForPath(key),
+      ...arrayOp !== void 0 ? { arrayOp } : {}
+    };
+    return state.setValueAtPath(segments, next, meta);
   }
   return {
     append(path, value) {
@@ -826,18 +881,19 @@ function buildFieldArrayApi(state) {
     prepend(path, value) {
       const next = readArray(path);
       next.unshift(value);
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "shift-from", index: 0 });
     },
     insert(path, index, value) {
       const next = readArray(path);
       next.splice(index, 0, value);
-      return writeArray(path, next);
+      const clampedIndex = Math.max(0, Math.min(index, next.length));
+      return writeArray(path, next, { kind: "shift-from", index: clampedIndex });
     },
     remove(path, index) {
       const next = readArray(path);
       if (index < 0 || index >= next.length) return false;
       next.splice(index, 1);
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "shift-from", index });
     },
     swap(path, a, b) {
       const next = readArray(path);
@@ -847,7 +903,7 @@ function buildFieldArrayApi(state) {
       const tmp = next[a];
       next[a] = next[b];
       next[b] = tmp;
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "swap", a, b });
     },
     move(path, from, to) {
       const next = readArray(path);
@@ -855,13 +911,17 @@ function buildFieldArrayApi(state) {
       const [item] = next.splice(from, 1);
       const clampedTo = Math.max(0, Math.min(to, next.length));
       next.splice(clampedTo, 0, item);
-      return writeArray(path, next);
+      return writeArray(path, next, {
+        kind: "shift-range",
+        fromIndex: Math.min(from, clampedTo),
+        toIndex: Math.max(from, clampedTo)
+      });
     },
     replace(path, index, value) {
       const next = readArray(path);
       if (index < 0 || index >= next.length) return false;
       next[index] = value;
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "replace-at", index });
     }
   };
 }
@@ -890,8 +950,12 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "placeholder",
   "meta"
 ]);
-function buildFieldStateProxy(state, getFormMetaBase) {
-  const getFieldStateAt = buildFieldStateAccessor(state, getFormMetaBase);
+function buildFieldStateProxy(state, getFormMetaBase, options) {
+  const getFieldStateAt = buildFieldStateAccessor(
+    state,
+    getFormMetaBase,
+    options?.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0
+  );
   const snapshotFieldStateAt = (path) => {
     const view = getFieldStateAt(path).value;
     const snapshot = {};
@@ -982,10 +1046,25 @@ function walk$2(value, basePath, schema, snapshotFieldStateAt) {
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
-const DEFAULT_HISTORY_MAX_SNAPSHOTS = 50;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
 const PERSISTENCE_KEY_PREFIX = "attaform:";
 const RESERVED_KEY_PREFIX = "__atta:";
 const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const DEFAULT_MAX_RECURSION_DEPTH = 64;
+function normalizeNumericOption(config) {
+  const { value, source, allowInfinity, min, defaultValue } = config;
+  if (allowInfinity && value === Infinity) return Infinity;
+  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+    if (plugin.__DEV__) {
+      const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
+      console.warn(
+        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
+      );
+    }
+    return defaultValue;
+  }
+  return Math.max(min, Math.floor(value));
+}
 
 const PERSISTENCE_MODULE_KEY = "persistence";
 async function getStorageAdapter(storage) {
@@ -1160,20 +1239,29 @@ function mergeDeep(target, source, path, schema) {
   if (source === null || typeof source !== "object") return source;
   if (Array.isArray(source)) return source;
   if (!isPlainRecord(source)) return source;
-  let mergeTarget = target;
   if (schema !== void 0) {
     const du = schema.getUnionDiscriminatorAtPath(path);
     if (du !== void 0) {
-      const sourceDisc = source[du.discriminatorKey];
-      const targetDisc = isPlainRecord(target) ? target[du.discriminatorKey] : void 0;
-      if (sourceDisc !== void 0 && !Object.is(sourceDisc, targetDisc)) {
+      const sourceRecord = source;
+      const sourceDisc = sourceRecord[du.discriminatorKey];
+      if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
+        return { [du.discriminatorKey]: sourceDisc };
+      }
+      if (sourceDisc !== void 0) {
         const variantDefault = du.getVariantDefault(sourceDisc);
         if (isPlainRecord(variantDefault)) {
-          mergeTarget = 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);
+          }
+          return out2;
         }
       }
+      return {};
     }
   }
+  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);
@@ -1202,14 +1290,14 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     });
     let gen = 0;
     async function kickoff(data, path, captured) {
-      state.activeValidations.value += 1;
-      result.value = {
-        pending: true,
-        errors: void 0,
-        success: false,
-        formKey: state.formKey
-      };
       try {
+        state.activeValidations.value += 1;
+        result.value = {
+          pending: true,
+          errors: void 0,
+          success: false,
+          formKey: state.formKey
+        };
         const refinement = await runRefinementValidation(data, path);
         if (captured !== gen) return;
         result.value = settled(composeWithDerivedBlank(refinement, path));
@@ -1253,14 +1341,44 @@ function buildProcessForm(state, formInstanceId, options = {}) {
   async function validateAsync(pathInput) {
     const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
     const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
-    state.activeValidations.value += 1;
     try {
+      state.activeValidations.value += 1;
       const refinement = await runRefinementValidation(dataAtPath, segments);
       return stripData(composeWithDerivedBlank(refinement, segments));
+    } catch (err) {
+      return adapterThrowResponse(err);
+    } finally {
+      state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
+    }
+  }
+  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);
     }
   }
+  function adapterThrowResponse(err) {
+    return {
+      success: false,
+      data: void 0,
+      errors: [
+        {
+          message: adapterThrowMessage(err),
+          path: [],
+          formKey: state.formKey,
+          code: AttaformErrorCode.AdapterThrew
+        }
+      ],
+      formKey: state.formKey
+    };
+  }
   async function runRefinementValidation(data, path) {
     return await state.schema.validateAtPath(data, path);
   }
@@ -1282,14 +1400,17 @@ function buildProcessForm(state, formInstanceId, options = {}) {
       if (event !== void 0 && "preventDefault" in event && typeof event.preventDefault === "function") {
         event.preventDefault();
       }
+      if (state.activeSubmissions.value > 0) {
+        return;
+      }
       const genAtEntry = state.submissionGeneration.value;
-      state.activeSubmissions.value += 1;
-      state.submitting.value = true;
-      state.submitError.value = null;
-      state.cancelFieldValidation();
-      state.activeValidations.value += 1;
       let validationSettled = false;
       try {
+        state.activeSubmissions.value += 1;
+        state.submitting.value = true;
+        state.submitError.value = null;
+        state.cancelFieldValidation();
+        state.activeValidations.value += 1;
         const refinement = await runRefinementValidation(state.form.value, void 0);
         const merged = composeWithDerivedBlank(refinement, void 0);
         state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
@@ -1338,7 +1459,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     };
     return submitHandler;
   };
-  return { validate, validateAsync, handleSubmit };
+  return { validate, validateAsync, process, handleSubmit };
 }
 function toSegments(pathInput) {
   return paths.canonicalizePath(pathInput).segments;
@@ -1676,11 +1797,12 @@ 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) {
+function attachFocusListeners(state, segments, element, instanceMeta) {
   const target = element;
   if (target[attaformListenersSymbol] !== void 0) return;
-  const handleFocus = () => state.markFocused(segments, true);
-  const handleBlur = () => state.markFocused(segments, false);
+  const focusMeta = instanceMeta !== void 0 ? { instance: instanceMeta } : void 0;
+  const handleFocus = () => state.markFocused(segments, true, focusMeta);
+  const handleBlur = () => state.markFocused(segments, false, focusMeta);
   element.addEventListener("focus", handleFocus);
   element.addEventListener("blur", handleBlur);
   target[attaformListenersSymbol] = { handleFocus, handleBlur };
@@ -1693,7 +1815,13 @@ function detachFocusListeners(element) {
   element.removeEventListener("blur", listeners.handleBlur);
   delete target[attaformListenersSymbol];
 }
-function buildRegister(state, formInstanceId) {
+function buildRegister(state, formInstanceId, instanceConfig) {
+  const coerceIndex = instanceConfig?.coerce !== void 0 ? resolveCoercionIndex(instanceConfig.coerce) : state.coerceIndex;
+  const instanceMeta = instanceConfig?.instanceMeta;
+  const withInstanceMeta = (meta) => {
+    if (instanceMeta === void 0) return meta;
+    return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
+  };
   const lastTypedFormByPath = /* @__PURE__ */ new Map();
   return function register(pathInput, options) {
     const { segments, key: pathKey } = paths.canonicalizePath(pathInput);
@@ -1716,16 +1844,23 @@ function buildRegister(state, formInstanceId) {
     const slimDefault = state.schema.getDefaultAtPath(segments);
     const persist = options?.persist === true;
     const acknowledgeSensitive = options?.acknowledgeSensitive === true;
+    const multiTab = options?.multiTab !== false;
     const transforms = options?.transforms ?? EMPTY_TRANSFORMS;
+    const markNoSync = !multiTab ? () => {
+      state.incrementNoSyncOptOut(pathKey);
+    } : void 0;
+    const unmarkNoSync = !multiTab ? () => {
+      state.decrementNoSyncOptOut(pathKey);
+    } : void 0;
     const coerce = buildCoerceFn(
       state.schema,
       segments,
-      state.coerceIndex
+      coerceIndex
     );
     const coerceElement = buildElementCoerceFn(
       state.schema,
       segments,
-      state.coerceIndex
+      coerceIndex
     );
     if (persist && !state.ssr && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
       throw new plugin.AnonPersistError({
@@ -1739,22 +1874,26 @@ function buildRegister(state, formInstanceId) {
       displayValue,
       lastTypedForm,
       markBlank: () => {
-        return state.setValueAtPath(segments, slimDefault, {
-          blank: true,
-          persist
-        });
+        return state.setValueAtPath(
+          segments,
+          slimDefault,
+          withInstanceMeta({
+            blank: true,
+            persist
+          })
+        );
       },
       registerElement: (element) => {
         if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
-        if (added) attachFocusListeners(state, segments, element);
+        if (added) attachFocusListeners(state, segments, element, instanceMeta);
       },
       deregisterElement: (element) => {
         detachFocusListeners(element);
         state.deregisterElement(segments, element);
       },
       setValueWithInternalPath: (value, meta) => {
-        return state.setValueAtPath(segments, value, meta);
+        return state.setValueAtPath(segments, value, withInstanceMeta(meta));
       },
       // Called by the `vRegisterHint` compile-time transform's wrapping
       // IIFE on every server-side render of `<element v-register="…">`.
@@ -1780,6 +1919,10 @@ function buildRegister(state, formInstanceId) {
       persist,
       acknowledgeSensitive,
       persistOptIns: state.persistOptIns,
+      isSensitivePath: state.isSensitivePath,
+      multiTab,
+      ...markNoSync !== void 0 ? { markNoSync } : {},
+      ...unmarkNoSync !== void 0 ? { unmarkNoSync } : {},
       transforms,
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {}
@@ -1937,6 +2080,8 @@ function buildValuesProxy(form) {
   const inner = vue.computed(() => vue.readonly(form.value));
   const target = (() => {
   });
+  const valuesToString = () => JSON.stringify(inner.value);
+  const valuesToPrimitive = (hint) => hint === "number" ? NaN : valuesToString();
   return new Proxy(target, {
     apply(_, __, args) {
       const arg = args[0];
@@ -1950,8 +2095,16 @@ function buildValuesProxy(form) {
       return cursor;
     },
     get(_, key) {
-      if (typeof key === "symbol") return Reflect.get(target, key);
+      if (typeof key === "symbol") {
+        if (key === Symbol.toPrimitive) return valuesToPrimitive;
+        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];
     },
     has(_, key) {
@@ -1990,6 +2143,14 @@ function buildValuesProxy(form) {
   });
 }
 
+function blankForKind(slimDefault) {
+  if (typeof slimDefault === "string") return "";
+  if (typeof slimDefault === "number") return 0;
+  if (typeof slimDefault === "bigint") return 0n;
+  if (typeof slimDefault === "boolean") return false;
+  if (slimDefault === null) return null;
+  return void 0;
+}
 function readonlySetSnapshot(source) {
   const snapshot = new Set(source);
   return new Proxy(snapshot, {
@@ -2005,15 +2166,36 @@ function readonlySetSnapshot(source) {
   });
 }
 function buildFormApi(state, formInstanceId, options = {}) {
-  const register = buildRegister(state, formInstanceId);
+  const instanceMeta = (() => {
+    const bag = {};
+    if (options.validateOn !== void 0) bag.validateOn = options.validateOn;
+    if (options.debounceMs !== void 0) bag.debounceMs = options.debounceMs;
+    if (options.rememberVariants !== void 0) bag.rememberVariants = options.rememberVariants;
+    return Object.keys(bag).length > 0 ? bag : void 0;
+  })();
+  const withInstanceMeta = (meta) => {
+    if (instanceMeta === void 0) return meta;
+    return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
+  };
+  const registerConfig = {
+    ...instanceMeta !== void 0 ? { instanceMeta } : {},
+    ...options.coerce !== void 0 ? { coerce: options.coerce } : {}
+  };
+  const register = buildRegister(
+    state,
+    formInstanceId,
+    Object.keys(registerConfig).length > 0 ? registerConfig : void 0
+  );
   const processOptions = options.onInvalidSubmit !== void 0 ? { onInvalidSubmit: options.onInvalidSubmit } : {};
   const {
     validate: validateBuilt,
     validateAsync: validateAsyncBuilt,
+    process: processBuilt,
     handleSubmit
   } = buildProcessForm(state, formInstanceId, processOptions);
   const validate = (pathInput) => validateBuilt(pathInput);
   const validateAsync = (pathInput) => validateAsyncBuilt(pathInput);
+  const process = (pathInput) => processBuilt(pathInput);
   function pathToRef(pathInput) {
     const segments = paths.canonicalizePath(pathInput).segments;
     return vue.computed(() => getAtPath(state.form.value, segments));
@@ -2025,22 +2207,36 @@ function buildFormApi(state, formInstanceId, options = {}) {
         next,
         state.schema
       );
-      const ok2 = state.setValueAtPath([], walked2.cleanedValues);
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
       if (!ok2) return false;
       for (const pathKey of walked2.paths) {
         const segments2 = paths.segmentsForPathKey(pathKey);
         if (segments2 === null) continue;
-        state.setValueAtPath(segments2, state.schema.getDefaultAtPath(segments2), {
-          blank: true
-        });
+        state.setValueAtPath(
+          segments2,
+          state.schema.getDefaultAtPath(segments2),
+          withInstanceMeta({ blank: true })
+        );
       }
       return true;
     }
     const segments = paths.canonicalizePath(pathOrValue).segments;
     if (isUnset(maybeValue)) {
-      return state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
-        blank: true
-      });
+      const last = segments.length > 0 ? segments[segments.length - 1] : void 0;
+      if (typeof last === "string") {
+        const parent = segments.slice(0, -1);
+        const parentDU = state.schema.getUnionDiscriminatorAtPath(parent);
+        if (parentDU?.discriminatorKey === last) {
+          const slimDefault = state.schema.getDefaultAtPath(segments);
+          const blank = blankForKind(slimDefault);
+          return state.setValueAtPath(segments, blank, withInstanceMeta({ blank: true }));
+        }
+      }
+      return state.setValueAtPath(
+        segments,
+        state.schema.getDefaultAtPath(segments),
+        withInstanceMeta({ blank: true })
+      );
     }
     let resolvedValue;
     if (typeof maybeValue === "function") {
@@ -2048,9 +2244,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
       const prev = current === void 0 ? state.schema.getDefaultAtPath(segments) : current;
       resolvedValue = maybeValue(prev);
       if (isUnset(resolvedValue)) {
-        return state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
-          blank: true
-        });
+        return state.setValueAtPath(
+          segments,
+          state.schema.getDefaultAtPath(segments),
+          withInstanceMeta({ blank: true })
+        );
       }
     } else {
       resolvedValue = maybeValue;
@@ -2060,28 +2258,52 @@ function buildFormApi(state, formInstanceId, options = {}) {
       segments,
       state.schema
     );
-    const ok = state.setValueAtPath(segments, walked.cleanedValues);
+    const ok = state.setValueAtPath(segments, walked.cleanedValues, withInstanceMeta());
     if (!ok) return false;
     for (const pathKey of walked.paths) {
       const blankSegments = paths.segmentsForPathKey(pathKey);
       if (blankSegments === null) continue;
-      state.setValueAtPath(blankSegments, state.schema.getDefaultAtPath(blankSegments), {
-        blank: true
-      });
+      state.setValueAtPath(
+        blankSegments,
+        state.schema.getDefaultAtPath(blankSegments),
+        withInstanceMeta({ blank: true })
+      );
     }
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
+  function filterToOwnFormKey(errors, op) {
+    const own = [];
+    let dropped = 0;
+    for (const e of errors) {
+      if (e.formKey === state.formKey) own.push(e);
+      else dropped++;
+    }
+    if (plugin.__DEV__ && dropped > 0) {
+      console.warn(
+        `[attaform] ${op}: dropped ${dropped} error(s) with non-matching formKey (this form's key is "${String(state.formKey)}"). Errors are scoped to the form that produced them \u2014 pass them to the matching form instance.`
+      );
+    }
+    return own;
+  }
   function setFieldErrors(errors) {
-    state.setAllUserErrors(errors);
+    const preserved = state.userErrors.get(paths.FORM_ERRORS_PATH_KEY);
+    state.setAllUserErrors(filterToOwnFormKey(errors, "setFieldErrors"));
+    if (preserved !== void 0 && preserved.length > 0) {
+      state.userErrors.set(paths.FORM_ERRORS_PATH_KEY, preserved);
+    }
   }
   function addFieldErrors(errors) {
-    state.addUserErrors(errors);
+    state.addUserErrors(filterToOwnFormKey(errors, "addFieldErrors"));
   }
   function clearFieldErrors(path) {
     if (path === void 0) {
+      const preserved = state.userErrors.get(paths.FORM_ERRORS_PATH_KEY);
       state.clearSchemaErrors();
       state.clearUserErrors();
+      if (preserved !== void 0 && preserved.length > 0) {
+        state.userErrors.set(paths.FORM_ERRORS_PATH_KEY, preserved);
+      }
       return;
     }
     const segments = paths.canonicalizePath(path).segments;
@@ -2114,11 +2336,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
     () => state.firstValidationDone.value && state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
   );
   const history = options.history;
-  const undo = history?.undo ?? (() => false);
-  const redo = history?.redo ?? (() => false);
-  const canUndo = history?.canUndo ?? vue.computed(() => false);
-  const canRedo = history?.canRedo ?? vue.computed(() => false);
-  const historySize = history?.historySize ?? vue.computed(() => 0);
+  const formHistory = vue.readonly(
+    vue.reactive({
+      undo: history?.undo ?? (() => false),
+      redo: history?.redo ?? (() => false),
+      clear: history?.clear ?? (() => {
+      }),
+      canUndo: history?.canUndo ?? vue.computed(() => false),
+      canRedo: history?.canRedo ?? vue.computed(() => false),
+      size: history?.historySize ?? vue.computed(() => 0)
+    })
+  );
   const metaErrors = vue.computed(
     () => aggregateErrorsAt(state, [])
   );
@@ -2129,13 +2357,15 @@ function buildFormApi(state, formInstanceId, options = {}) {
       submitting: state.submitting.value,
       submitCount: state.submitCount.value,
       submitError: state.submitError.value,
-      canUndo: canUndo.value,
-      canRedo: canRedo.value,
-      historySize: historySize.value,
       instanceId: formInstanceId
     };
   };
-  const getRootFieldStateAt = buildFieldStateAccessor(state, getFormMetaBase);
+  const fieldStateAccessorOptions = options.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0;
+  const getRootFieldStateAt = buildFieldStateAccessor(
+    state,
+    getFormMetaBase,
+    fieldStateAccessorOptions
+  );
   const rootFieldState = getRootFieldStateAt([]);
   const formMeta = vue.readonly(
     vue.reactive({
@@ -2188,9 +2418,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
       submitting,
       submitCount,
       submitError,
-      canUndo,
-      canRedo,
-      historySize,
       // Per-`useForm()`-call identity. Stable for one mount; new on
       // re-mount; orthogonal to `form.key` (which is the user-supplied
       // shared identifier). Useful for devtools panels disambiguating
@@ -2212,9 +2439,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
       for (const pathKey of walked.paths) {
         const segments = paths.segmentsForPathKey(pathKey);
         if (segments === null) continue;
-        state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
-          blank: true
-        });
+        state.setValueAtPath(
+          segments,
+          state.schema.getDefaultAtPath(segments),
+          withInstanceMeta({ blank: true })
+        );
         state.originalBlankPaths.add(pathKey);
       }
     }
@@ -2231,7 +2460,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
   const persist = async (pathInput, options2) => {
     const segments = paths.canonicalizePath(pathInput).segments;
-    plugin.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true);
+    plugin.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2265,7 +2494,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return readonlySetSnapshot(state.blankPaths);
   });
   const valuesProxy = buildValuesProxy(state.form);
-  const fieldStateProxy = buildFieldStateProxy(state, getFormMetaBase);
+  const fieldStateProxy = buildFieldStateProxy(state, getFormMetaBase, fieldStateAccessorOptions);
   return {
     handleSubmit,
     // `values` is the callable readonly Proxy. Each `get` trap reads
@@ -2278,6 +2507,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     setValue: setValueImpl,
     validate,
     validateAsync,
+    process,
     register,
     key: state.formKey,
     errors: errorsProxy,
@@ -2294,9 +2524,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     clearPersistedDraft,
     focusFirstError,
     scrollToFirstError,
-    touch,
-    undo,
-    redo,
+    touch,
+    history: formHistory,
     append: fieldArrays.append,
     prepend: fieldArrays.prepend,
     insert: fieldArrays.insert,
@@ -2341,6 +2570,42 @@ 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)) {
+      if (warned !== void 0 && plugin.__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;
@@ -2350,21 +2615,96 @@ function isPathKeyUnder(existingKey, parentPath) {
   }
   return true;
 }
+function stripSymbolsDeep(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    let mutated2 = false;
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      const cleaned = stripSymbolsDeep(value[i]);
+      out2[i] = cleaned;
+      if (cleaned !== value[i]) mutated2 = true;
+    }
+    return mutated2 ? out2 : value;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  const symKeys = Object.getOwnPropertySymbols(value);
+  const stringKeys = Object.keys(value);
+  let mutated = symKeys.length > 0;
+  const out = {};
+  const src = value;
+  for (const k of stringKeys) {
+    const cleaned = stripSymbolsDeep(src[k]);
+    out[k] = cleaned;
+    if (cleaned !== src[k]) mutated = true;
+  }
+  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 createFormStore(options) {
   const { formKey, schema, defaultValues, strict = true, hydration } = options;
   const ssr = options.ssr === true;
   const rememberVariants = options.rememberVariants !== false;
   const fieldValidationMode = options.validateOn ?? "change";
-  const fieldValidationDebounceMs = options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS;
+  const fieldValidationDebounceMs = normalizeNumericOption({
+    value: options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS,
+    source: "useForm.debounceMs",
+    allowInfinity: false,
+    min: 0,
+    defaultValue: DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS
+  });
   const fieldValidationState = /* @__PURE__ */ new Map();
   const formChangeListeners = /* @__PURE__ */ new Set();
   const submitSuccessListeners = /* @__PURE__ */ new Set();
   const resetListeners = /* @__PURE__ */ new Set();
   const persistOptIns = plugin.createPersistOptInRegistry();
+  const noSyncPaths = /* @__PURE__ */ new Set();
+  const noSyncPathCounts = /* @__PURE__ */ new Map();
+  function incrementNoSyncOptOut(path) {
+    const next = (noSyncPathCounts.get(path) ?? 0) + 1;
+    noSyncPathCounts.set(path, next);
+    if (next === 1) noSyncPaths.add(path);
+  }
+  function decrementNoSyncOptOut(path) {
+    const current = noSyncPathCounts.get(path) ?? 0;
+    if (current <= 1) {
+      noSyncPathCounts.delete(path);
+      noSyncPaths.delete(path);
+      return;
+    }
+    noSyncPathCounts.set(path, current - 1);
+  }
   const coerceIndex = resolveCoercionIndex(options.coerce);
   const resolvedShouldShowErrors = resolveShouldShowErrors(
     options.shouldShowErrors
   );
+  const resolvedIsSensitivePath = options.isSensitivePath ?? plugin.isSensitivePath;
+  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? plugin.segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -2375,7 +2715,10 @@ function createFormStore(options) {
   });
   const schemaInitialData = schemaResponse.data;
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
-  const form = vue.ref(initialData);
+  const stubbedInitialData = applyDuStubs(schema, initialData, {
+    warn: true
+  });
+  const form = vue.ref(stubbedInitialData);
   const fields = vue.reactive(/* @__PURE__ */ new Map());
   const elements = vue.reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -2391,6 +2734,40 @@ function createFormStore(options) {
     originalBlankPaths.add(raw);
   }
   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 "shift-from":
+        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.index);
+        return;
+      case "shift-range":
+        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.fromIndex && i <= op.toIndex);
+        return;
+      case "swap":
+        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
+        return;
+      case "replace-at":
+        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.index);
+        return;
+    }
+  }
   const pathOrdinals = /* @__PURE__ */ new Map();
   let nextOrdinal = 0;
   function ensurePathOrdinal(key) {
@@ -2542,9 +2919,35 @@ function createFormStore(options) {
     }
   }
   function setValueAtPath(path, value, meta) {
+    value = stripSymbolsDeep(value);
+    value = schema.normalizeWriteValueAtPath(value, path);
     if (!isSlimPrimitiveValid(schema, form, path, value)) {
       return false;
     }
+    if (path.length >= 2) {
+      for (let i = 0; i < path.length - 1; i++) {
+        const ancestorPath = path.slice(0, i + 1);
+        const du = schema.getUnionDiscriminatorAtPath(ancestorPath);
+        if (du === void 0) continue;
+        const nextSeg = path[i + 1];
+        if (nextSeg === du.discriminatorKey) continue;
+        const ancestorValue = getAtPath(form.value, ancestorPath);
+        if (!isPlainRecord(ancestorValue)) continue;
+        const discValue = ancestorValue[du.discriminatorKey];
+        if (discValue === void 0) {
+          return false;
+        }
+        if (!du.isVariantSelected(discValue)) {
+          return false;
+        }
+        const variantDefault = du.getVariantDefault(discValue);
+        if (!isPlainRecord(variantDefault)) continue;
+        if (typeof nextSeg !== "string") continue;
+        if (!(nextSeg in variantDefault)) {
+          return false;
+        }
+      }
+    }
     if (meta?.skipDiscriminatorReshape !== true) {
       if (path.length > 0) {
         const last = path[path.length - 1];
@@ -2565,6 +2968,14 @@ function createFormStore(options) {
                   meta
                 );
               }
+              return reshapeUnionVariant(
+                parentPath,
+                oldValue,
+                value,
+                { [last]: value },
+                void 0,
+                meta
+              );
             }
           }
         }
@@ -2573,12 +2984,13 @@ function createFormStore(options) {
         const selfDU = schema.getUnionDiscriminatorAtPath(path);
         if (selfDU !== void 0) {
           const valueRecord = value;
-          const discValue = valueRecord[selfDU.discriminatorKey];
+          const discKey = selfDU.discriminatorKey;
+          const discValue = valueRecord[discKey];
+          const currentUnionValue = getAtPath(form.value, path);
+          const oldDiscValue = isPlainRecord(currentUnionValue) ? currentUnionValue[discKey] : void 0;
           if (discValue !== void 0) {
             const variantDefault = selfDU.getVariantDefault(discValue);
             if (variantDefault !== void 0 && isPlainRecord(variantDefault)) {
-              const currentUnionValue = getAtPath(form.value, path);
-              const oldDiscValue = isPlainRecord(currentUnionValue) ? currentUnionValue[selfDU.discriminatorKey] : void 0;
               return reshapeUnionVariant(
                 path,
                 oldDiscValue,
@@ -2588,7 +3000,16 @@ function createFormStore(options) {
                 meta
               );
             }
+            return reshapeUnionVariant(
+              path,
+              oldDiscValue,
+              discValue,
+              { [discKey]: discValue },
+              void 0,
+              meta
+            );
           }
+          return reshapeUnionVariant(path, oldDiscValue, void 0, {}, void 0, meta);
         }
       }
     }
@@ -2605,12 +3026,17 @@ function createFormStore(options) {
     }
     const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
     applyFormReplacement(nextForm, meta);
-    if (fieldValidationMode === "change") {
-      scheduleFieldValidation(
-        path,
-        false
-        /* debounced */
-      );
+    if (meta?.arrayOp !== void 0) {
+      applyArrayOpToMemory(path, meta.arrayOp);
+    } else if (Array.isArray(value) && Array.isArray(currentValue)) {
+      clearVariantMemoryUnderPath(path);
+    }
+    const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
+    if (effectiveModeAfterWrite === "change") {
+      scheduleFieldValidation(path, false, {
+        ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+        ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+      });
     }
     return true;
   }
@@ -2619,9 +3045,10 @@ function createFormStore(options) {
     const parentKey = paths.canonicalizePath(parentPath).key;
     let baseline = variantDefault;
     let restoredBlanks;
-    if (rememberVariants && !sameDisc) {
+    const effectiveRemember = meta?.instance?.rememberVariants ?? rememberVariants;
+    if (effectiveRemember && !sameDisc) {
       if (oldDiscValue !== void 0) {
-        const currentValue2 = JSON.parse(JSON.stringify(getAtPath(form.value, parentPath)));
+        const currentValue2 = cloneVariantSnapshot(getAtPath(form.value, parentPath));
         const outgoingBlanks = [];
         for (const k of blankPaths) {
           if (isPathKeyUnder(k, parentPath)) outgoingBlanks.push(k);
@@ -2643,7 +3070,10 @@ function createFormStore(options) {
         restoredBlanks = [...restored.blankPaths];
       }
     }
-    const finalValue = consumerOverrides !== void 0 ? { ...baseline, ...consumerOverrides } : baseline;
+    const layered = consumerOverrides !== void 0 ? { ...baseline, ...consumerOverrides } : baseline;
+    const finalValue = applyDuStubs(schema, layered, {
+      basePath: parentPath
+    });
     let newBlankPaths;
     if (restoredBlanks !== void 0) {
       newBlankPaths = restoredBlanks;
@@ -2662,9 +3092,10 @@ function createFormStore(options) {
       for (const k of newBlankPaths) blankPaths.add(k);
       return true;
     }
-    const nextForm = parentPath.length === 0 ? finalValue : setAtPath(form.value, parentPath, finalValue);
+    const nextForm = parentPath.length === 0 ? finalValue : setAtPathWithSchemaFill(form.value, schema, parentPath, finalValue);
     let appliedSync = false;
-    if (fieldValidationMode === "change") {
+    const reshapeMode = meta?.instance?.validateOn ?? fieldValidationMode;
+    if (reshapeMode === "change") {
       const syncOrPromise = schema.validateAtPath(finalValue, parentPath, { sync: true });
       if (!(syncOrPromise instanceof Promise)) {
         const reStamped = syncOrPromise.success ? [] : syncOrPromise.errors.map((err) => ({
@@ -2684,17 +3115,18 @@ function createFormStore(options) {
     }
     applyFormReplacement(nextForm, meta);
     for (const k of newBlankPaths) blankPaths.add(k);
-    if (fieldValidationMode === "change" && !appliedSync) {
-      scheduleFieldValidation(
-        parentPath,
-        false
-        /* debounced */
-      );
+    if (reshapeMode === "change" && !appliedSync) {
+      scheduleFieldValidation(parentPath, false, {
+        ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+        ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+      });
     }
     return true;
   }
-  function scheduleFieldValidation(path, immediate) {
-    if (fieldValidationMode === "submit") return;
+  function scheduleFieldValidation(path, immediate, override) {
+    const effectiveMode = override?.mode ?? fieldValidationMode;
+    if (effectiveMode === "submit") return;
+    const effectiveDebounce = override?.debounceMs ?? fieldValidationDebounceMs;
     const { key } = paths.canonicalizePath(path);
     const prev = fieldValidationState.get(key);
     if (prev !== void 0) {
@@ -2708,8 +3140,17 @@ function createFormStore(options) {
       fresh.timer = null;
       if (controller.signal.aborted) return;
       const data = getAtPath(form.value, path);
-      activeValidations.value += 1;
-      incFieldValidation(key);
+      let activeIncremented = false;
+      try {
+        activeValidations.value += 1;
+        activeIncremented = true;
+        incFieldValidation(key);
+      } catch (err) {
+        if (activeIncremented) {
+          activeValidations.value = Math.max(0, activeValidations.value - 1);
+        }
+        throw err;
+      }
       void Promise.resolve().then(() => schema.validateAtPath(data, path)).then((response) => {
         if (controller.signal.aborted) return;
         const reStamped = response.success ? [] : response.errors.map((err) => ({
@@ -2723,10 +3164,10 @@ function createFormStore(options) {
         decFieldValidation(key);
       });
     };
-    if (immediate || fieldValidationDebounceMs === 0) {
+    if (immediate || effectiveDebounce === 0) {
       run();
     } else {
-      fresh.timer = setTimeout(run, fieldValidationDebounceMs);
+      fresh.timer = setTimeout(run, effectiveDebounce);
     }
   }
   function cancelFieldValidation() {
@@ -2790,6 +3231,8 @@ function createFormStore(options) {
     submitSuccessListeners.clear();
     resetListeners.clear();
     persistOptIns.clear();
+    noSyncPaths.clear();
+    noSyncPathCounts.clear();
   }
   function getValueAtPath(path) {
     return getAtPath(form.value, path);
@@ -2924,7 +3367,7 @@ function createFormStore(options) {
     if (current?.connected === true) return;
     touchFieldRecord(key, path, { connected: true });
   }
-  function markFocused(path, focused) {
+  function markFocused(path, focused, meta) {
     const { key } = paths.canonicalizePath(path);
     touchFieldRecord(key, path, {
       focused,
@@ -2933,12 +3376,12 @@ function createFormStore(options) {
       // a field is currently focused we keep whatever value it held.
       touched: focused ? fields.get(key)?.touched ?? null : true
     });
-    if (!focused && fieldValidationMode === "blur") {
-      scheduleFieldValidation(
-        path,
-        true
-        /* immediate */
-      );
+    const focusMode = meta?.instance?.validateOn ?? fieldValidationMode;
+    if (!focused && focusMode === "blur") {
+      scheduleFieldValidation(path, true, {
+        ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+        ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+      });
     }
   }
   function markTouched(path) {
@@ -2964,11 +3407,14 @@ function createFormStore(options) {
     }
   }
   function reset(nextDefaultValues) {
-    const next = schema.getDefaultValues({
+    const resetSource = nextDefaultValues ?? defaultValues;
+    const completedResetConstraints = resetSource === void 0 ? void 0 : mergeStructural(schema, [], resetSource);
+    const resetResponse = schema.getDefaultValues({
       useDefaultSchemaValues: true,
-      constraints: nextDefaultValues ?? defaultValues,
+      constraints: completedResetConstraints,
       strict
-    }).data;
+    });
+    const next = resetResponse.data;
     applyFormReplacement(next);
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -2987,6 +3433,24 @@ function createFormStore(options) {
     }
     schemaErrors.clear();
     userErrors.clear();
+    if (strict && !resetResponse.success) {
+      setAllSchemaErrors(resetResponse.errors);
+    }
+    if (strict) {
+      const syncResult = schema.validateAtPath(form.value, void 0, { sync: true });
+      if (!(syncResult instanceof Promise) && !syncResult.success) {
+        applySchemaErrorsForSubtree([], syncResult.errors);
+      }
+    }
+    firstValidationDone.value = !strict || schema.needsAsyncValidation?.() !== true;
+    const needsAsync = !ssr && strict && schema.needsAsyncValidation?.() === true;
+    if (needsAsync) {
+      queueMicrotask(() => scheduleFieldValidation(
+        [],
+        true
+        /* immediate */
+      ));
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const [pathKey, record] of fields) {
       fields.set(pathKey, {
@@ -3030,30 +3494,28 @@ function createFormStore(options) {
           `[attaform] resetField: leaf write rejected for path '${targetKey}' \u2014 originals contain a value that doesn't satisfy the slim primitive shape. This is a bug in the construction pipeline.`
         );
       }
-      schemaErrors.delete(targetKey);
-      userErrors.delete(targetKey);
-      clearFieldRecordFlags(targetKey);
-      return;
-    }
-    let subtree = void 0;
-    let anyMatch = false;
-    for (const [, entry] of originals) {
-      const leafSegments = entry.segments;
-      if (!isPathPrefix(targetSegments, leafSegments)) continue;
-      if (leafSegments.length === targetSegments.length) continue;
-      anyMatch = true;
-      const relative = leafSegments.slice(targetSegments.length);
-      if (subtree === void 0) {
-        subtree = typeof relative[0] === "number" ? [] : {};
-      }
-      subtree = setAtPath(subtree, relative, entry.value);
-    }
-    if (!anyMatch) return;
-    const wroteSubtree = setValueAtPath(targetSegments, subtree);
-    if (!wroteSubtree) {
-      console.error(
-        `[attaform] resetField: subtree write rejected at path '${targetKey}' \u2014 originals contain values that don't satisfy the slim primitive shape. This is a bug in the construction pipeline.`
-      );
+    } else {
+      let subtree = void 0;
+      let anyMatch = false;
+      for (const [, entry] of originals) {
+        const leafSegments = entry.segments;
+        if (!isPathPrefix(targetSegments, leafSegments)) continue;
+        if (leafSegments.length === targetSegments.length) continue;
+        anyMatch = true;
+        const relative = leafSegments.slice(targetSegments.length);
+        if (subtree === void 0) {
+          subtree = typeof relative[0] === "number" ? [] : {};
+        }
+        subtree = setAtPath(subtree, relative, entry.value);
+      }
+      if (anyMatch) {
+        const wroteSubtree = setValueAtPath(targetSegments, subtree);
+        if (!wroteSubtree) {
+          console.error(
+            `[attaform] resetField: subtree write rejected at path '${targetKey}' \u2014 originals contain values that don't satisfy the slim primitive shape. This is a bug in the construction pipeline.`
+          );
+        }
+      }
     }
     deleteErrorsUnderPrefix(schemaErrors, targetSegments);
     deleteErrorsUnderPrefix(userErrors, targetSegments);
@@ -3183,6 +3645,11 @@ function createFormStore(options) {
     awaitPendingWrites,
     modules,
     persistOptIns,
+    isSensitivePath: resolvedIsSensitivePath,
+    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
+    noSyncPaths,
+    incrementNoSyncOptOut,
+    decrementNoSyncOptOut,
     coerceIndex,
     blankPaths,
     originalBlankPaths,
@@ -3190,43 +3657,140 @@ function createFormStore(options) {
   };
 }
 
-function getComputedSchema(formKey, schemaOrCallback) {
-  if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey);
+function getComputedSchema(formKey, schemaOrCallback, options) {
+  if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey, options);
   return schemaOrCallback;
 }
 
+function captureErrorEntries(map) {
+  const out = [];
+  for (const [k, v] of map) out.push([k, [...v]]);
+  return out;
+}
+function errorsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const bMap = /* @__PURE__ */ new Map();
+  for (const [k, v] of b) bMap.set(k, v);
+  for (const [k, v] of a) {
+    const bv = bMap.get(k);
+    if (bv === void 0) return false;
+    if (v.length !== bv.length) return false;
+    for (let i = 0; i < v.length; i++) {
+      const av = v[i];
+      const bvi = bv[i];
+      if (av === bvi) continue;
+      if (av.message !== bvi.message) return false;
+      if (av.code !== bvi.code) return false;
+      if (av.formKey !== bvi.formKey) return false;
+      if (av.path !== bvi.path) {
+        if (av.path.length !== bvi.path.length) return false;
+        for (let j = 0; j < av.path.length; j++) {
+          if (av.path[j] !== bvi.path[j]) return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function diffBlankPaths$1(prev, curr) {
+  const added = [];
+  const removed = [];
+  for (const k of curr) if (!prev.has(k)) added.push(k);
+  for (const k of prev) if (!curr.has(k)) removed.push(k);
+  return { added, removed };
+}
+function applyDeltaForward(snap, d) {
+  const nextForm = applyPatchesForward(snap.form, d.formPatches);
+  const nextBlank = new Set(snap.blankPaths);
+  for (const k of d.blankPathsRemoved) nextBlank.delete(k);
+  for (const k of d.blankPathsAdded) nextBlank.add(k);
+  return {
+    form: nextForm,
+    blankPaths: [...nextBlank],
+    schemaErrors: d.schemaErrors !== void 0 ? d.schemaErrors.after : snap.schemaErrors,
+    userErrors: d.userErrors !== void 0 ? d.userErrors.after : snap.userErrors
+  };
+}
+function applyDeltaInverse(snap, d) {
+  const prevForm = applyPatchesInverse(snap.form, d.formPatches);
+  const prevBlank = new Set(snap.blankPaths);
+  for (const k of d.blankPathsAdded) prevBlank.delete(k);
+  for (const k of d.blankPathsRemoved) prevBlank.add(k);
+  return {
+    form: prevForm,
+    blankPaths: [...prevBlank],
+    schemaErrors: d.schemaErrors !== void 0 ? d.schemaErrors.before : snap.schemaErrors,
+    userErrors: d.userErrors !== void 0 ? d.userErrors.before : snap.userErrors
+  };
+}
 function createHistoryModule(state, config) {
-  const max = typeof config === "object" ? config.max ?? DEFAULT_HISTORY_MAX_SNAPSHOTS : DEFAULT_HISTORY_MAX_SNAPSHOTS;
-  const undoStack = vue.shallowRef([]);
-  const redoStack = vue.shallowRef([]);
-  let suppressNext = false;
+  const max = normalizeNumericOption({
+    value: typeof config === "object" ? config.max ?? DEFAULT_HISTORY_MAX_SNAPSHOTS : DEFAULT_HISTORY_MAX_SNAPSHOTS,
+    source: "useForm.history.max",
+    allowInfinity: false,
+    min: 0,
+    defaultValue: DEFAULT_HISTORY_MAX_SNAPSHOTS
+  });
   function captureSnapshot() {
     return {
       form: structuralSnapshot(state.form.value),
       blankPaths: [...state.blankPaths],
-      schemaErrors: [...state.schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
-      userErrors: [...state.userErrors.entries()].map(([k, v]) => [k, [...v]])
+      schemaErrors: captureErrorEntries(state.schemaErrors),
+      userErrors: captureErrorEntries(state.userErrors)
     };
   }
-  function pushSnapshot(snap) {
-    const next = [...undoStack.value, snap];
-    undoStack.value = next.length > max ? next.slice(-max) : next;
-    redoStack.value = [];
+  const initial = captureSnapshot();
+  const base = vue.shallowRef(initial);
+  const currentSnapshot = vue.shallowRef(initial);
+  const undoDeltas = vue.shallowRef([]);
+  const redoDeltas = vue.shallowRef([]);
+  let suppressNext = false;
+  function appendDelta(delta, newCurrent) {
+    if (max === 0) {
+      base.value = newCurrent;
+      currentSnapshot.value = newCurrent;
+      redoDeltas.value = [];
+      return;
+    }
+    undoDeltas.value = [...undoDeltas.value, delta];
+    redoDeltas.value = [];
+    currentSnapshot.value = newCurrent;
+    while (1 + undoDeltas.value.length > max && undoDeltas.value.length > 0) {
+      const oldest = undoDeltas.value[0];
+      base.value = applyDeltaForward(base.value, oldest);
+      undoDeltas.value = undoDeltas.value.slice(1);
+    }
   }
-  pushSnapshot(captureSnapshot());
-  const unsubscribeChange = state.onFormChange(() => {
+  const unsubscribeChange = state.onFormChange((_next, meta) => {
     if (suppressNext) {
       suppressNext = false;
       return;
     }
-    pushSnapshot(captureSnapshot());
-  });
-  const unsubscribeReset = state.onReset(() => {
-    undoStack.value = [];
-    redoStack.value = [];
-    pushSnapshot(captureSnapshot());
+    if (meta?.hydration === true) {
+      clear();
+      return;
+    }
+    if (meta?.crossTab === true) {
+      currentSnapshot.value = captureSnapshot();
+      return;
+    }
+    const newSnap = captureSnapshot();
+    const prevSnap = currentSnapshot.value;
+    const formPatches = [];
+    diffAndApply(prevSnap.form, newSnap.form, [], (p) => formPatches.push(p));
+    const prevBlankSet = new Set(prevSnap.blankPaths);
+    const currBlankSet = new Set(newSnap.blankPaths);
+    const blankDiff = diffBlankPaths$1(prevBlankSet, currBlankSet);
+    const delta = {
+      formPatches,
+      blankPathsAdded: blankDiff.added,
+      blankPathsRemoved: blankDiff.removed,
+      ...errorsEqual(prevSnap.schemaErrors, newSnap.schemaErrors) ? {} : { schemaErrors: { before: prevSnap.schemaErrors, after: newSnap.schemaErrors } },
+      ...errorsEqual(prevSnap.userErrors, newSnap.userErrors) ? {} : { userErrors: { before: prevSnap.userErrors, after: newSnap.userErrors } }
+    };
+    appendDelta(delta, newSnap);
   });
-  function restore(snap) {
+  function restoreCurrent(snap) {
     suppressNext = true;
     state.blankPaths.clear();
     for (const key of snap.blankPaths) state.blankPaths.add(key);
@@ -3239,38 +3803,46 @@ function createHistoryModule(state, config) {
     state.setAllUserErrors(userFlat);
   }
   function undo() {
-    if (undoStack.value.length <= 1) return false;
-    const current = undoStack.value[undoStack.value.length - 1];
-    const prev = undoStack.value[undoStack.value.length - 2];
-    if (current === void 0 || prev === void 0) return false;
-    redoStack.value = [...redoStack.value, current];
-    undoStack.value = undoStack.value.slice(0, -1);
-    restore(prev);
+    if (undoDeltas.value.length === 0) return false;
+    const d = undoDeltas.value[undoDeltas.value.length - 1];
+    const restored = applyDeltaInverse(currentSnapshot.value, d);
+    redoDeltas.value = [...redoDeltas.value, d];
+    undoDeltas.value = undoDeltas.value.slice(0, -1);
+    currentSnapshot.value = restored;
+    restoreCurrent(restored);
     return true;
   }
   function redo() {
-    if (redoStack.value.length === 0) return false;
-    const next = redoStack.value[redoStack.value.length - 1];
-    if (next === void 0) return false;
-    redoStack.value = redoStack.value.slice(0, -1);
-    undoStack.value = [...undoStack.value, next];
-    restore(next);
+    if (redoDeltas.value.length === 0) return false;
+    const d = redoDeltas.value[redoDeltas.value.length - 1];
+    const next = applyDeltaForward(currentSnapshot.value, d);
+    undoDeltas.value = [...undoDeltas.value, d];
+    redoDeltas.value = redoDeltas.value.slice(0, -1);
+    currentSnapshot.value = next;
+    restoreCurrent(next);
     return true;
   }
-  const canUndo = vue.computed(() => undoStack.value.length > 1);
-  const canRedo = vue.computed(() => redoStack.value.length > 0);
-  const historySize = vue.computed(() => undoStack.value.length + redoStack.value.length);
+  function clear() {
+    const fresh = captureSnapshot();
+    base.value = fresh;
+    currentSnapshot.value = fresh;
+    undoDeltas.value = [];
+    redoDeltas.value = [];
+  }
+  const canUndo = vue.computed(() => undoDeltas.value.length > 0);
+  const canRedo = vue.computed(() => redoDeltas.value.length > 0);
+  const historySize = vue.computed(() => 1 + undoDeltas.value.length + redoDeltas.value.length);
   return {
     undo,
     redo,
+    clear,
     canUndo,
     canRedo,
     historySize,
     dispose() {
       unsubscribeChange();
-      unsubscribeReset();
-      undoStack.value = [];
-      redoStack.value = [];
+      undoDeltas.value = [];
+      redoDeltas.value = [];
     }
   };
 }
@@ -3288,12 +3860,368 @@ function hashStableString(input, seed = 0) {
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, "0");
 }
 
+const PROTOCOL_VERSION = 1;
+const JOIN_COLLECTION_WINDOW_MS = 50;
+const SNAPSHOT_TIMEOUT_MS = 200;
+const MAX_LEADER_ATTEMPTS = 3;
+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 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 (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;
+    }
+    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
+    };
+  }
+  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;
+    try {
+      channel.postMessage(msg);
+    } 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;
+      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] };
+  }
+  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;
+      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 {
+        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;
+    try {
+      options.validateForm(msg.form);
+    } catch {
+      return;
+    }
+    if (snapshotTimeoutTimer !== null) {
+      clearTimeout(snapshotTimeoutTimer);
+      snapshotTimeoutTimer = null;
+    }
+    if (joinCollectionTimer !== null) {
+      clearTimeout(joinCollectionTimer);
+      joinCollectionTimer = null;
+    }
+    applyIncomingForm(msg.form, msg.blankPaths);
+    lifecycle = "established";
+    peerIds.clear();
+  }
+  function respondToHello() {
+    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
+  }
+  function respondToSnapshotRequest() {
+    const scrubbedForm = stripSensitivePathsDeep(state.form.value, [], options.isSensitivePath);
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "snapshot",
+      senderId,
+      form: scrubbedForm,
+      blankPaths: [...state.blankPaths]
+    });
+  }
+  channel.onmessage = (event) => {
+    if (disposed) return;
+    const data = event.data;
+    if (!isValidSyncMessage(data)) return;
+    const msg = data;
+    if (msg.senderId === senderId) return;
+    switch (msg.kind) {
+      case "hello":
+        if (lifecycle !== "established") return;
+        respondToHello();
+        break;
+      case "announce":
+        if (lifecycle === "joining") peerIds.add(msg.senderId);
+        break;
+      case "requestSnapshot":
+        if (lifecycle !== "established") return;
+        if (msg.targetId !== senderId) return;
+        respondToSnapshotRequest();
+        break;
+      case "snapshot":
+        handleSnapshot(msg);
+        break;
+      case "patches":
+        handlePatches(msg);
+        break;
+    }
+  };
+  function electLeaderAndRequest() {
+    if (disposed) return;
+    if (peerIds.size === 0) {
+      lifecycle = "established";
+      refreshPrior();
+      return;
+    }
+    const sorted = [...peerIds].sort();
+    const leaderId = sorted[0];
+    peerIds.delete(leaderId);
+    leaderAttempts++;
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "requestSnapshot",
+      senderId,
+      targetId: leaderId
+    });
+    snapshotTimeoutTimer = setTimeout(() => {
+      snapshotTimeoutTimer = null;
+      if (disposed) return;
+      if (lifecycle === "established") return;
+      if (leaderAttempts >= MAX_LEADER_ATTEMPTS || peerIds.size === 0) {
+        lifecycle = "established";
+        refreshPrior();
+        return;
+      }
+      electLeaderAndRequest();
+    }, SNAPSHOT_TIMEOUT_MS);
+  }
+  function joinFlow() {
+    safePost({ v: PROTOCOL_VERSION, kind: "hello", senderId });
+    joinCollectionTimer = setTimeout(() => {
+      joinCollectionTimer = null;
+      if (disposed) return;
+      if (lifecycle === "established") return;
+      electLeaderAndRequest();
+    }, JOIN_COLLECTION_WINDOW_MS);
+  }
+  joinFlow();
+  return {
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      if (joinCollectionTimer !== null) {
+        clearTimeout(joinCollectionTimer);
+        joinCollectionTimer = null;
+      }
+      if (snapshotTimeoutTimer !== null) {
+        clearTimeout(snapshotTimeoutTimer);
+        snapshotTimeoutTimer = null;
+      }
+      unsubscribeChange();
+      try {
+        channel.close();
+      } catch {
+      }
+    },
+    lifecycle: () => lifecycle,
+    senderId,
+    channelName
+  };
+}
+const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+
+const warned = /* @__PURE__ */ new Set();
+function warnOnceInsecureContext(feature) {
+  if (!plugin.__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 useAbstractForm(configuration) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
     throw new plugin.InvalidUseFormConfigError();
   }
   const key = resolveFormKey(configuration.key);
-  const resolvedSchema = getComputedSchema(key, configuration.schema);
+  const instance = vue.getCurrentInstance();
+  if (instance !== null) plugin.ensureAttaformInstalled(instance.appContext.app);
+  const registry = plugin.useRegistry();
+  const merged = mergeWithDefaults(registry.defaults, configuration);
+  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 plugin.AnonPersistError({
       cause: "no-key",
@@ -3301,13 +4229,10 @@ function useAbstractForm(configuration) {
       callSite: plugin.captureUserCallSite()
     });
   }
-  const instance = vue.getCurrentInstance();
-  if (instance !== null) plugin.ensureAttaformInstalled(instance.appContext.app);
-  const registry = plugin.useRegistry();
-  const merged = mergeWithDefaults(registry.defaults, configuration);
   const existing = registry.forms.get(key);
   if (plugin.__DEV__ && existing !== void 0) {
     warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+    warnOnPersistDivergence(key, existing, configuration.persist);
   }
   const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
   if (vue.getCurrentScope() !== void 0) {
@@ -3318,16 +4243,54 @@ function useAbstractForm(configuration) {
   if (existing === void 0 && !registry.ssr) {
     if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
       const resolvedPersist = normalizePersistConfig(merged.persist);
-      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());
+      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 !== false && 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);
@@ -3349,6 +4312,22 @@ function useAbstractForm(configuration) {
   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.shouldShowErrors !== void 0) {
+    apiOptions.shouldShowErrors = resolveShouldShowErrors(merged.shouldShowErrors);
+  }
+  if (merged.coerce !== void 0) {
+    apiOptions.coerce = merged.coerce;
+  }
+  if (merged.rememberVariants !== void 0) {
+    apiOptions.rememberVariants = merged.rememberVariants;
+  }
   return buildFormApi(state, formInstanceId, apiOptions);
 }
 function mergeWithDefaults(defaults, configuration) {
@@ -3360,6 +4339,9 @@ function mergeWithDefaults(defaults, configuration) {
   const validateOn = configuration.validateOn ?? defaults.validateOn;
   const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
   const shouldShowErrors = configuration.shouldShowErrors ?? defaults.shouldShowErrors;
+  const maxRecursionDepth = configuration.maxRecursionDepth ?? defaults.maxRecursionDepth;
+  const sensitiveNames = configuration.sensitiveNames ?? defaults.sensitiveNames;
+  const multiTab = configuration.multiTab ?? defaults.multiTab;
   return {
     ...configuration,
     ...strict === void 0 ? {} : { strict },
@@ -3369,7 +4351,10 @@ function mergeWithDefaults(defaults, configuration) {
     ...coerce === void 0 ? {} : { coerce },
     ...validateOn === void 0 ? {} : { validateOn },
     ...debounceMs === void 0 ? {} : { debounceMs },
-    ...shouldShowErrors === void 0 ? {} : { shouldShowErrors }
+    ...shouldShowErrors === void 0 ? {} : { shouldShowErrors },
+    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
+    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
+    ...multiTab === void 0 ? {} : { multiTab }
   };
 }
 const HISTORY_MODULE_KEY = "history";
@@ -3381,6 +4366,9 @@ function buildFreshState(key, schema, configuration, registry) {
     schema
   );
   const initialBlankPaths = pending === void 0 ? walked.paths : void 0;
+  const resolvedSensitiveNames = configuration.sensitiveNames;
+  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : plugin.createIsSensitivePath(resolvedSensitiveNames);
+  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : plugin.createSegmentMatchesSensitive(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -3393,7 +4381,9 @@ function buildFreshState(key, schema, configuration, registry) {
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
     ...configuration.shouldShowErrors !== void 0 ? { shouldShowErrors: configuration.shouldShowErrors } : {},
-    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {}
+    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {},
+    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {},
+    ...resolvedSegmentMatchesSensitive !== void 0 ? { segmentMatchesSensitive: resolvedSegmentMatchesSensitive } : {}
   };
   const state = createFormStore(createOptions);
   registry.forms.set(
@@ -3452,11 +4442,47 @@ function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
   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 = config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS;
+  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);
@@ -3491,6 +4517,7 @@ function wirePersistence(state, config) {
   }, 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();
@@ -3524,7 +4551,7 @@ function wirePersistence(state, config) {
         payload.data.form,
         state.schema
       );
-      state.applyFormReplacement(merged);
+      state.applyFormReplacement(merged, { hydration: true });
       const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
       for (const k of persistedLeafPaths) {
         state.blankPaths.delete(k);
@@ -3655,6 +4682,7 @@ function wirePersistence(state, config) {
     });
   }
   return {
+    wiredConfig: config,
     writePathImmediately,
     clearPersistedDraft,
     awaitPendingWrites,
@@ -3729,7 +4757,11 @@ function injectForm(key) {
   }
   const ambientInstanceId = vue.getCurrentInstance() !== null ? vue.inject(plugin.kFormInstanceId, null) : null;
   const formInstanceId = ambientInstanceId ?? (vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
-  return buildFormApi(state, formInstanceId, apiOptions);
+  return buildFormApi(
+    state,
+    formInstanceId,
+    apiOptions
+  );
 }
 function resolveState(key, registry) {
   if (key !== void 0) {
@@ -3782,8 +4814,9 @@ exports.humanize = humanize;
 exports.injectForm = injectForm;
 exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
+exports.normalizeNumericOption = normalizeNumericOption;
 exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
-//# sourceMappingURL=attaform.fegmBJaq.cjs.map
+//# sourceMappingURL=attaform.BFumZXY2.cjs.map