attaform 0.16.4 → 0.17.0

package/dist/shared/{attaform.DyV1O4tI.mjs → attaform.BT55rDNN.mjs}

@@ -1,173 +1,6 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, shallowRef, getCurrentInstance, provide, useId, toRaw, inject } from 'vue';
-import { s as segmentsForPathKey, i as isPathPrefix, F as FORM_ERRORS_PATH_KEY, c as canonicalizePath, R as ROOT_PATH, b as FORM_ERRORS_PATH } from './attaform.DZRj9s0s.mjs';
-import { _ as __DEV__, e as SubmitErrorHandlerError, A as AnonPersistError, m as captureUserCallSite, n as enforceSensitiveCheck, o as createPersistOptInRegistry, b as InvalidUseFormConfigError, p as ensureAttaformInstalled, l as useRegistry, q as kFormContext, r as kFormInstanceId, d as ReservedFormKeyError } from './attaform.BfMxsfmE.mjs';
-
-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(" ");
-}
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, provide, useId, inject } from 'vue';
+import { _ as __DEV__, e as SubmitErrorHandlerError, A as AnonPersistError, l as captureUserCallSite, m as enforceSensitiveCheck, s as segmentMatchesSensitive, n as isSensitivePath, o as createPersistOptInRegistry, b as InvalidUseFormConfigError, p as ensureAttaformInstalled, j as useRegistry, q as kFormContext, r as kFormInstanceId, d as ReservedFormKeyError, t as createIsSensitivePath, w as createSegmentMatchesSensitive } from './attaform.CIEQgJnM.mjs';
+import { c as canonicalizePath, s as segmentsForPathKey, i as isPathPrefix, F as FORM_ERRORS_PATH_KEY, R as ROOT_PATH, b as FORM_ERRORS_PATH } from './attaform.h1sq3BFu.mjs';
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -413,14 +246,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 } = canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = 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;
@@ -440,7 +489,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;
@@ -470,9 +520,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;
@@ -540,13 +590,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) {
@@ -731,14 +782,16 @@ function buildErrorsProxy(state) {
   return buildSurfaceProxy({
     schema: state.schema,
     resolveLeaf: (path) => {
-      if (!hasAtPath(state.form.value, path)) return void 0;
       const { key } = 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;
     },
@@ -763,7 +816,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 = segmentsForPathKey(pathKey);
@@ -772,13 +825,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) {
@@ -809,11 +862,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 } = 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) {
@@ -824,18 +879,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);
@@ -845,7 +901,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);
@@ -853,13 +909,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 });
     }
   };
 }
@@ -888,8 +948,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 = {};
@@ -980,10 +1044,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 (__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) {
@@ -1158,20 +1237,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);
@@ -1200,14 +1288,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));
@@ -1251,14 +1339,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);
   }
@@ -1280,14 +1398,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);
@@ -1336,7 +1457,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     };
     return submitHandler;
   };
-  return { validate, validateAsync, handleSubmit };
+  return { validate, validateAsync, process, handleSubmit };
 }
 function toSegments(pathInput) {
   return canonicalizePath(pathInput).segments;
@@ -1674,11 +1795,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 };
@@ -1691,7 +1813,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 } = canonicalizePath(pathInput);
@@ -1714,16 +1842,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 AnonPersistError({
@@ -1737,22 +1872,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="…">`.
@@ -1778,6 +1917,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 } : {}
@@ -1935,6 +2078,8 @@ function buildValuesProxy(form) {
   const inner = computed(() => 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];
@@ -1948,8 +2093,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) {
@@ -1988,6 +2141,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, {
@@ -2003,15 +2164,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 = canonicalizePath(pathInput).segments;
     return computed(() => getAtPath(state.form.value, segments));
@@ -2023,22 +2205,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 = 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 = 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") {
@@ -2046,9 +2242,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;
@@ -2058,28 +2256,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 = 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 (__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(FORM_ERRORS_PATH_KEY);
+    state.setAllUserErrors(filterToOwnFormKey(errors, "setFieldErrors"));
+    if (preserved !== void 0 && preserved.length > 0) {
+      state.userErrors.set(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(FORM_ERRORS_PATH_KEY);
       state.clearSchemaErrors();
       state.clearUserErrors();
+      if (preserved !== void 0 && preserved.length > 0) {
+        state.userErrors.set(FORM_ERRORS_PATH_KEY, preserved);
+      }
       return;
     }
     const segments = canonicalizePath(path).segments;
@@ -2112,11 +2334,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 ?? computed(() => false);
-  const canRedo = history?.canRedo ?? computed(() => false);
-  const historySize = history?.historySize ?? computed(() => 0);
+  const formHistory = readonly(
+    reactive({
+      undo: history?.undo ?? (() => false),
+      redo: history?.redo ?? (() => false),
+      clear: history?.clear ?? (() => {
+      }),
+      canUndo: history?.canUndo ?? computed(() => false),
+      canRedo: history?.canRedo ?? computed(() => false),
+      size: history?.historySize ?? computed(() => 0)
+    })
+  );
   const metaErrors = computed(
     () => aggregateErrorsAt(state, [])
   );
@@ -2127,13 +2355,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 = readonly(
     reactive({
@@ -2186,9 +2416,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
@@ -2210,9 +2437,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
       for (const pathKey of walked.paths) {
         const segments = 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);
       }
     }
@@ -2229,7 +2458,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
   const persist = async (pathInput, options2) => {
     const segments = canonicalizePath(pathInput).segments;
-    enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true);
+    enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2263,7 +2492,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
@@ -2276,6 +2505,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     setValue: setValueImpl,
     validate,
     validateAsync,
+    process,
     register,
     key: state.formKey,
     errors: errorsProxy,
@@ -2292,9 +2522,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     clearPersistedDraft,
     focusFirstError,
     scrollToFirstError,
-    touch,
-    undo,
-    redo,
+    touch,
+    history: formHistory,
     append: fieldArrays.append,
     prepend: fieldArrays.prepend,
     insert: fieldArrays.insert,
@@ -2339,6 +2568,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 && __DEV__) {
+        const dotted = path.map((s) => String(s)).join(".") || "(root)";
+        const key = `${dotted}::${String(discValue)}`;
+        if (!warned.has(key)) {
+          warned.add(key);
+          console.warn(
+            `[attaform] defaultValues at '${dotted}' carries discriminator '${du.discriminatorKey}=${JSON.stringify(discValue)}' which isn't a known variant. Form mounts in a stub holding only the discriminator key. Validation will surface the mismatch.`
+          );
+        }
+      }
+      return { [du.discriminatorKey]: discValue };
+    }
+  }
+  const out = {};
+  for (const k of Object.keys(rec)) {
+    out[k] = walkDuStubs(schema, rec[k], [...path, k], warned);
+  }
+  return out;
+}
 function isPathKeyUnder(existingKey, parentPath) {
   const parsed = segmentsForPathKey(existingKey);
   if (parsed === null) return false;
@@ -2348,21 +2613,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 = 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 = 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 ?? isSensitivePath;
+  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -2373,7 +2713,10 @@ function createFormStore(options) {
   });
   const schemaInitialData = schemaResponse.data;
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
-  const form = ref(initialData);
+  const stubbedInitialData = applyDuStubs(schema, initialData, {
+    warn: true
+  });
+  const form = ref(stubbedInitialData);
   const fields = reactive(/* @__PURE__ */ new Map());
   const elements = reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -2389,6 +2732,40 @@ function createFormStore(options) {
     originalBlankPaths.add(raw);
   }
   const variantMemory = /* @__PURE__ */ new Map();
+  function clearVariantMemoryUnderPath(arrayPath) {
+    for (const memKey of [...variantMemory.keys()]) {
+      const segs = segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (isPathPrefix(arrayPath, segs)) variantMemory.delete(memKey);
+    }
+  }
+  function clearVariantMemoryAtArrayIndices(arrayPath, indexFilter) {
+    for (const memKey of [...variantMemory.keys()]) {
+      const segs = segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= arrayPath.length) continue;
+      const idxSeg = segs[arrayPath.length];
+      if (typeof idxSeg !== "number") continue;
+      if (indexFilter(idxSeg)) variantMemory.delete(memKey);
+    }
+  }
+  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) {
@@ -2540,9 +2917,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];
@@ -2563,6 +2966,14 @@ function createFormStore(options) {
                   meta
                 );
               }
+              return reshapeUnionVariant(
+                parentPath,
+                oldValue,
+                value,
+                { [last]: value },
+                void 0,
+                meta
+              );
             }
           }
         }
@@ -2571,12 +2982,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,
@@ -2586,7 +2998,16 @@ function createFormStore(options) {
                 meta
               );
             }
+            return reshapeUnionVariant(
+              path,
+              oldDiscValue,
+              discValue,
+              { [discKey]: discValue },
+              void 0,
+              meta
+            );
           }
+          return reshapeUnionVariant(path, oldDiscValue, void 0, {}, void 0, meta);
         }
       }
     }
@@ -2603,12 +3024,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;
   }
@@ -2617,9 +3043,10 @@ function createFormStore(options) {
     const parentKey = 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);
@@ -2641,7 +3068,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;
@@ -2660,9 +3090,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) => ({
@@ -2682,17 +3113,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 } = canonicalizePath(path);
     const prev = fieldValidationState.get(key);
     if (prev !== void 0) {
@@ -2706,8 +3138,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) => ({
@@ -2721,10 +3162,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() {
@@ -2788,6 +3229,8 @@ function createFormStore(options) {
     submitSuccessListeners.clear();
     resetListeners.clear();
     persistOptIns.clear();
+    noSyncPaths.clear();
+    noSyncPathCounts.clear();
   }
   function getValueAtPath(path) {
     return getAtPath(form.value, path);
@@ -2922,7 +3365,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 } = canonicalizePath(path);
     touchFieldRecord(key, path, {
       focused,
@@ -2931,12 +3374,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) {
@@ -2962,11 +3405,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) => {
@@ -2985,6 +3431,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, {
@@ -3028,30 +3492,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);
@@ -3181,6 +3643,11 @@ function createFormStore(options) {
     awaitPendingWrites,
     modules,
     persistOptIns,
+    isSensitivePath: resolvedIsSensitivePath,
+    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
+    noSyncPaths,
+    incrementNoSyncOptOut,
+    decrementNoSyncOptOut,
     coerceIndex,
     blankPaths,
     originalBlankPaths,
@@ -3188,43 +3655,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 = shallowRef([]);
-  const redoStack = 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 = shallowRef(initial);
+  const currentSnapshot = shallowRef(initial);
+  const undoDeltas = shallowRef([]);
+  const redoDeltas = 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);
@@ -3237,38 +3801,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 = computed(() => undoStack.value.length > 1);
-  const canRedo = computed(() => redoStack.value.length > 0);
-  const historySize = computed(() => undoStack.value.length + redoStack.value.length);
+  function clear() {
+    const fresh = captureSnapshot();
+    base.value = fresh;
+    currentSnapshot.value = fresh;
+    undoDeltas.value = [];
+    redoDeltas.value = [];
+  }
+  const canUndo = computed(() => undoDeltas.value.length > 0);
+  const canRedo = computed(() => redoDeltas.value.length > 0);
+  const historySize = 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 = [];
     }
   };
 }
@@ -3286,12 +3858,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 } = 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 = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankAdded.push(k);
+    }
+    const safeBlankRemoved = [];
+    for (const k of msg.blankPathsRemoved) {
+      const segs = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankRemoved.push(k);
+    }
+    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+      return;
+    }
+    const candidate = applyPatchesForward(state.form.value, safePatches);
+    try {
+      options.validateForm(state.form.value);
+      try {
+        options.validateForm(candidate);
+      } catch {
+        return;
+      }
+    } catch {
+    }
+    const nextBlankPaths = new Set(state.blankPaths);
+    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
+    for (const k of safeBlankAdded) nextBlankPaths.add(k);
+    applyIncomingForm(candidate, [...nextBlankPaths]);
+  }
+  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 (!__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 InvalidUseFormConfigError();
   }
   const key = resolveFormKey(configuration.key);
-  const resolvedSchema = getComputedSchema(key, configuration.schema);
+  const instance = getCurrentInstance();
+  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
+  const registry = 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 AnonPersistError({
       cause: "no-key",
@@ -3299,13 +4227,10 @@ function useAbstractForm(configuration) {
       callSite: captureUserCallSite()
     });
   }
-  const instance = getCurrentInstance();
-  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
-  const registry = useRegistry();
-  const merged = mergeWithDefaults(registry.defaults, configuration);
   const existing = registry.forms.get(key);
   if (__DEV__ && existing !== void 0) {
     warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+    warnOnPersistDivergence(key, existing, configuration.persist);
   }
   const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
   if (getCurrentScope() !== void 0) {
@@ -3316,16 +4241,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);
@@ -3347,6 +4310,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) {
@@ -3358,6 +4337,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 },
@@ -3367,7 +4349,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";
@@ -3379,6 +4364,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 : createIsSensitivePath(resolvedSensitiveNames);
+  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : createSegmentMatchesSensitive(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -3391,7 +4379,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(
@@ -3450,11 +4440,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);
@@ -3489,6 +4515,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();
@@ -3522,7 +4549,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);
@@ -3653,6 +4680,7 @@ function wirePersistence(state, config) {
     });
   }
   return {
+    wiredConfig: config,
     writePathImmediately,
     clearPersistedDraft,
     awaitPendingWrites,
@@ -3727,7 +4755,11 @@ function injectForm(key) {
   }
   const ambientInstanceId = getCurrentInstance() !== null ? inject(kFormInstanceId, null) : null;
   const formInstanceId = ambientInstanceId ?? (getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
-  return buildFormApi(state, formInstanceId, apiOptions);
+  return buildFormApi(
+    state,
+    formInstanceId,
+    apiOptions
+  );
 }
 function resolveState(key, registry) {
   if (key !== void 0) {
@@ -3771,5 +4803,5 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, isUnset as a, defaultShouldShowErrors as b, defineCoercion as c, defaultCoercionRules as d, useAbstractForm as e, setAtPath as f, getAtPath as g, humanize as h, injectForm as i, isPlainRecord as j, slimKindOf as s, unset as u };
-//# sourceMappingURL=attaform.DyV1O4tI.mjs.map
+export { AttaformErrorCode as A, isUnset as a, defaultShouldShowErrors as b, defineCoercion as c, defaultCoercionRules as d, useAbstractForm as e, setAtPath as f, getAtPath as g, humanize as h, injectForm as i, isPlainRecord as j, normalizeNumericOption as n, slimKindOf as s, unset as u };
+//# sourceMappingURL=attaform.BT55rDNN.mjs.map