attaform 0.18.2 → 0.20.0

package/dist/shared/{attaform.II89Pcf4.cjs → attaform.DL4CQ-oW.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.BqK_L4gK.cjs');
+const paths = require('./attaform.BPy-4qRx.cjs');
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -64,7 +64,7 @@ function setAtPathOffset(root, path, value, offset) {
     arr[head] = setAtPathOffset(arr[head], path, value, nextOffset);
     return arr;
   }
-  const rec = isPlainRecord(root) ? { ...root } : {};
+  const rec = isPlainRecord(root) ? Object.assign(/* @__PURE__ */ Object.create(null), root) : /* @__PURE__ */ Object.create(null);
   rec[head] = setAtPathOffset(rec[head], path, value, nextOffset);
   return rec;
 }
@@ -165,7 +165,7 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
       return consumer;
     }
     let mutated = false;
-    const out = { ...consumer };
+    const out = Object.assign(/* @__PURE__ */ Object.create(null), consumer);
     for (const key of Object.keys(defaultValue)) {
       if (!(key in consumer)) {
         const defAtKey = defaultValue[key];
@@ -429,13 +429,81 @@ function structuralSnapshot(value) {
     return out2;
   }
   const src = value;
-  const out = {};
+  const out = /* @__PURE__ */ Object.create(null);
   for (const k of Object.keys(src)) {
     out[k] = structuralSnapshot(src[k]);
   }
   return out;
 }
 
+const defaultDisplayState = (field, formMeta) => {
+  const gateOpen = formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
+  if (!gateOpen) return "idle";
+  if (field.validating === true) return "pending";
+  const hasOwnError = field.errors.some(
+    (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
+  );
+  if (hasOwnError) return "error";
+  if (field.valid === true && field.blank !== true && field.dirty === true) return "success";
+  return "idle";
+};
+function resolveGetDisplayState(config) {
+  return config ?? defaultDisplayState;
+}
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
+const PERSISTENCE_KEY_PREFIX = "attaform:";
+const RESERVED_KEY_PREFIX = "__atta:";
+const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
+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 (paths.__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));
+}
+
+function hashStableString(input, seed = 0) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, "0");
+}
+
+const ANON_STEM = "atta";
+function readableFormKeyStem(formKey) {
+  if (formKey === "" || formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return ANON_STEM;
+  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|(?<!-)-+$/g, "");
+  return sanitized === "" ? ANON_STEM : sanitized;
+}
+function fieldIdToken(formInstanceId, pathKey) {
+  return hashStableString(`${formInstanceId}:${pathKey}`).slice(-7);
+}
+function computeFieldIdentity(formInstanceId, formKey, pathKey) {
+  const id = `${readableFormKeyStem(formKey)}-${fieldIdToken(formInstanceId, pathKey)}`;
+  return {
+    id,
+    aria: Object.freeze({ errorId: `${id}-error`, descriptionId: `${id}-description` })
+  };
+}
+
 const EMPTY_RESOLVED_FIELD_META = Object.freeze({
   label: "",
   description: void 0,
@@ -456,6 +524,7 @@ function humanize(segment) {
   }).join(" ");
 }
 
+const warnedDisplayStatePredicates = /* @__PURE__ */ new WeakSet();
 function isUnderStubAncestor(state, segments) {
   for (let i = 0; i < segments.length; i++) {
     const ancestorPath = segments.slice(0, i);
@@ -469,21 +538,21 @@ function isUnderStubAncestor(state, segments) {
   }
   return false;
 }
-function buildFieldStateAccessor(state, getFormMetaBase, options) {
+function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options) {
   const cache = /* @__PURE__ */ new Map();
-  const predicate = options?.shouldShowErrors;
+  const predicate = options?.getDisplayState;
   return function getFieldState(pathInput) {
     const { segments, key } = paths.canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = vue.computed(
-      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, getFormMetaBase, predicate)
+      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate) : buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, predicate)
     );
     cache.set(key, c);
     return c;
   };
 }
-function buildLeafFieldStateBase(state, segments, key) {
+function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const record = state.fields.get(key);
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
@@ -513,6 +582,8 @@ function buildLeafFieldStateBase(state, segments, key) {
     focused: record?.focused ?? null,
     blurred: record?.blurred ?? null,
     touched: record?.touched ?? false,
+    interacted: record?.interacted ?? false,
+    blurredAfterInteraction: record?.blurredAfterInteraction ?? false,
     connected: record?.connected ?? false,
     element: firstElement,
     elements: elementsArr,
@@ -521,6 +592,8 @@ function buildLeafFieldStateBase(state, segments, key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank: state.blankPaths.has(key),
     label,
     description: resolved.description,
@@ -528,31 +601,32 @@ function buildLeafFieldStateBase(state, segments, key) {
     meta: resolved.meta
   };
 }
-function buildLeafFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
-  const base = buildLeafFieldStateBase(state, segments, key);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
+function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+  const base = buildLeafFieldStateBase(state, segments, key, formInstanceId);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
 }
-function buildContainerFieldStateBase(state, segments, _key) {
+function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
   const value = state.getValueAtPath(segments);
-  const original = state.originals.get(paths.canonicalizePath(segments).key)?.value;
+  const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
   let dirty = false;
   let focused = false;
   let blurred = false;
   let touched = false;
+  let interacted = false;
+  let blurredAfterInteraction = false;
   let connected = false;
   let validating = false;
   let updatedAt = null;
   let asyncPending = false;
-  for (const [, entry] of state.originals) {
+  for (const [leafKey, entry] of state.originals) {
     if (!paths.isPathPrefix(segments, entry.segments)) continue;
     if (segments.length === entry.segments.length) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
-    const leafKey = paths.canonicalizePath(entry.segments).key;
     const leafRecord = state.fields.get(leafKey);
-    if (!state.isPristineAtPath(entry.segments)) {
+    if (!state.isPristineAtPathByKey(leafKey, entry.segments)) {
       pristine = false;
       dirty = true;
     }
@@ -560,14 +634,20 @@ function buildContainerFieldStateBase(state, segments, _key) {
     if (leafRecord?.focused === true) focused = true;
     if (leafRecord?.blurred === true) blurred = true;
     if (leafRecord?.touched === true) touched = true;
+    if (leafRecord?.interacted === true) interacted = true;
+    if (leafRecord?.blurredAfterInteraction === true) blurredAfterInteraction = true;
     if (leafRecord?.connected === true) connected = true;
     if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) validating = true;
-    if (state.pathHasAsyncValidation(entry.segments)) asyncPending = true;
+    if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
     }
   }
+  if (!dirty && state.hasStructuralChangeUnder(segments)) {
+    pristine = false;
+    dirty = true;
+  }
   const errors = aggregateErrorsAt(state, segments);
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
   const gated = asyncPending && !state.firstValidationDone.value;
@@ -583,6 +663,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     focused,
     blurred,
     touched,
+    interacted,
+    blurredAfterInteraction,
     connected,
     element: null,
     elements: EMPTY_ELEMENTS,
@@ -591,6 +673,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank,
     label,
     description: resolved.description,
@@ -598,15 +682,36 @@ function buildContainerFieldStateBase(state, segments, _key) {
     meta: resolved.meta
   };
 }
-function buildContainerFieldState(state, segments, key, getFormMetaBase, shouldShowErrors) {
-  const base = buildContainerFieldStateBase(state, segments);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors);
+function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
+  const base = buildContainerFieldStateBase(state, segments, key, formInstanceId);
+  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase, shouldShowErrors) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState) {
   const firstError = base.errors[0];
-  const predicate = shouldShowErrors ?? state.shouldShowErrors;
-  const showErrors = base.errors.length > 0 && predicate(base, getFormMetaBase());
-  return { ...base, showErrors, firstError };
+  const predicate = getDisplayState ?? state.getDisplayState;
+  const formMeta = getFormMetaBase();
+  let displayState;
+  try {
+    displayState = predicate(base, formMeta);
+  } catch (err) {
+    if (paths.__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
+      warnedDisplayStatePredicates.add(predicate);
+      console.warn(
+        "[attaform] custom getDisplayState threw \u2014 falling back to defaultDisplayState. Subsequent throws from the same predicate will not warn again.",
+        err
+      );
+    }
+    displayState = defaultDisplayState(base, formMeta);
+  }
+  return {
+    ...base,
+    displayState,
+    showErrors: displayState === "error",
+    showPending: displayState === "pending",
+    showSuccess: displayState === "success",
+    showIdle: displayState === "idle",
+    firstError
+  };
 }
 function aggregateErrorsAt(state, prefix) {
   const formValue = state.form.value;
@@ -632,6 +737,41 @@ function aggregateErrorsAt(state, prefix) {
 }
 const EMPTY_ELEMENTS = Object.freeze([]);
 
+function liveKeysAtPath(state, segments) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    const keys = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
+    return keys;
+  }
+  if (typeof value === "object") return Object.keys(value);
+  return [];
+}
+function isArrayPath(state, segments) {
+  if (segments.length === 0) return false;
+  return Array.isArray(getAtPath(state.form.value, segments));
+}
+
+function warnReadOnly(surface, action, key) {
+  if (!paths.__DEV__) return;
+  const phrase = action === "write" ? `write to "${String(key)}"` : `${action} of "${String(key)}"`;
+  console.warn(
+    `[attaform] ${surface} is read-only \u2014 ${phrase} was ignored. Mutate the form via setValue / the directive / field-array helpers instead.`
+  );
+}
+function makeReadonlyCoercion(snapshot) {
+  const toString = () => JSON.stringify(snapshot());
+  return {
+    toString,
+    valueOf() {
+      return this;
+    },
+    toJSON: snapshot,
+    toPrimitive: (hint) => hint === "number" ? NaN : toString()
+  };
+}
+
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
@@ -663,12 +803,12 @@ function buildSurfaceProxy(opts) {
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const snapshotContainer = () => opts.materializeContainer === void 0 ? {} : opts.materializeContainer(segments);
-    const containerToJSON = () => snapshotContainer();
-    const containerToString = () => JSON.stringify(snapshotContainer());
-    function containerValueOf() {
-      return this;
-    }
-    const containerToPrimitive = (hint) => hint === "number" ? NaN : containerToString();
+    const {
+      toString: containerToString,
+      valueOf: containerValueOf,
+      toJSON: containerToJSON,
+      toPrimitive: containerToPrimitive
+    } = makeReadonlyCoercion(snapshotContainer);
     const target = isArrayLike ? [] : (() => {
     });
     const proxy = new Proxy(target, {
@@ -693,6 +833,9 @@ function buildSurfaceProxy(opts) {
           return opts.containerOwnKeys === void 0 ? 0 : opts.containerOwnKeys(segments).length;
         }
         const childSegs = [...segments, keyToSegment(key)];
+        if ((isArrayLike || opts.isArrayContainer?.(segments) === true) && typeof keyToSegment(key) === "string" && key in Array.prototype) {
+          return Reflect.get(Array.prototype, key);
+        }
         if (key === "toString" || key === "valueOf") {
           if (!schemaHasPath(childSegs)) {
             return key === "toString" ? containerToString : containerValueOf;
@@ -737,10 +880,25 @@ function buildSurfaceProxy(opts) {
         };
       },
       // Block writes at the proxy boundary. Mutations go through
-      // `setValue`, the directive, or the field-array helpers.
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // `setValue`, the directive, or the field-array helpers. Each
+      // trap returns `true` (warn-and-noop) — returning `false` from a
+      // `set`/`delete`/`defineProperty` trap throws `TypeError` under
+      // strict mode (every ESM / `<script setup>`), which would surface
+      // a host-level exception in consumer code that the library
+      // documents as "writes are ignored." Aligns with the contract on
+      // `form.values` / `wizard.statuses`.
+      set: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "write", key);
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "delete", key);
+        return true;
+      },
+      defineProperty: (_, key) => {
+        warnReadOnly("form.fields / form.errors", "define", key);
+        return true;
+      }
     });
     containerCache.set(cacheKey, proxy);
     return proxy;
@@ -762,11 +920,12 @@ function buildSurfaceProxy(opts) {
       }
       return snapshot;
     };
-    const leafToString = () => JSON.stringify(snapshotLeaf());
-    function leafValueOf() {
-      return this;
-    }
-    const leafToPrimitive = (hint) => hint === "number" ? NaN : leafToString();
+    const {
+      toString: leafToString,
+      valueOf: leafValueOf,
+      toJSON: leafToJSONHandler,
+      toPrimitive: leafToPrimitive
+    } = makeReadonlyCoercion(snapshotLeaf);
     const target = (() => {
     });
     const proxy = new Proxy(target, {
@@ -784,7 +943,7 @@ function buildSurfaceProxy(opts) {
         if (typeof key !== "string") return void 0;
         if (key === "toString") return leafToString;
         if (key === "valueOf") return leafValueOf;
-        if (key === "toJSON") return snapshotLeaf;
+        if (key === "toJSON") return leafToJSONHandler;
         if (leafKeys.has(key)) {
           const leaf = opts.resolveLeaf(segments);
           return readLeafKey(leaf, key);
@@ -811,9 +970,22 @@ function buildSurfaceProxy(opts) {
           writable: false
         };
       },
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // Same warn-and-noop contract as the container traps above.
+      // Returning `true` keeps strict-mode callers from throwing on
+      // `form.fields.email.value = …`; the actual readonly guarantee
+      // is the absence of any mutation, not the host-level reject.
+      set: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "write", key);
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "delete", key);
+        return true;
+      },
+      defineProperty: (_, key) => {
+        warnReadOnly("form.fields.<leaf>", "define", key);
+        return true;
+      }
     });
     leafViewCache.set(cacheKey, proxy);
     return proxy;
@@ -877,33 +1049,53 @@ function buildErrorsProxy(state) {
     // working — the call-form just extends that semantic to
     // containers and dynamic paths.
     resolveCallTarget: (path) => aggregateErrorsAt(state, path),
-    // Mirror `form.fields` enumeration: `Object.keys(form.errors.items)`
-    // and `v-for="(errs, idx) in form.errors.items"` walk the live
-    // array indices / object keys at the path. Iteration yields the
-    // descended sub-proxies (one per live key), so consumers can
-    // `form.errors.items[idx]` straight from the entry.
-    containerOwnKeys: (segments) => liveKeysAtPath$1(state, segments),
-    isArrayContainer: (segments) => isArrayPath$1(state, segments)
+    // Enumeration unions the live form-data keys at this path with the
+    // first-child segments drawn from every error store. Without the
+    // union, `Object.keys(form.errors)` / `{...form.errors}` /
+    // `v-for="(errs, k) in form.errors"` silently dropped two
+    // important error classes that the dot / call / JSON.stringify
+    // surfaces already exposed:
+    //
+    //   - **Form-level** errors at the synthetic `['']` path (set via
+    //     `setFormErrors` or root cross-field refines).
+    //   - **Server-only** errors at a key the schema doesn't know
+    //     about (`['ghost']`, `['address', 'ghost']`).
+    //
+    // The union closes that gap so `ownKeys` agrees with the rest of
+    // the surface. Active-path filter mirrors `resolveLeaf`:
+    // library-produced verdicts (schema + derived-blank) at unreachable
+    // paths stay hidden; user-supplied errors are unconditional.
+    containerOwnKeys: (segments) => errorAwareContainerKeys(state, segments),
+    isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
-function liveKeysAtPath$1(state, segments) {
-  const value = getAtPath(state.form.value, segments);
-  if (value === null || value === void 0) return [];
-  if (Array.isArray(value)) {
-    const keys = new Array(value.length);
-    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
-    return keys;
-  }
-  if (typeof value === "object") return Object.keys(value);
-  return [];
-}
-function isArrayPath$1(state, segments) {
-  if (segments.length === 0) return false;
-  return Array.isArray(getAtPath(state.form.value, segments));
+function errorAwareContainerKeys(state, segments) {
+  const keys = new Set(liveKeysAtPath(state, segments));
+  const formValue = state.form.value;
+  const walk = (store, applyActivePathFilter) => {
+    for (const [pathKey, errors] of store) {
+      if (errors.length === 0) continue;
+      if (pathKey === paths.FORM_ERRORS_PATH_KEY) {
+        if (segments.length === 0) keys.add("");
+        continue;
+      }
+      const decoded = paths.segmentsForPathKey(pathKey);
+      if (decoded === null) continue;
+      if (decoded.length <= segments.length) continue;
+      if (!paths.isPathPrefix(segments, decoded)) continue;
+      if (applyActivePathFilter && !hasAtPath(formValue, decoded)) continue;
+      const nextSeg = decoded[segments.length];
+      keys.add(typeof nextSeg === "number" ? String(nextSeg) : nextSeg);
+    }
+  };
+  walk(state.schemaErrors, true);
+  walk(state.derivedBlankErrors.value, true);
+  walk(state.userErrors, false);
+  return [...keys];
 }
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
-  const tree = Array.isArray(liveContainer) ? [] : {};
+  const tree = Array.isArray(liveContainer) ? [] : /* @__PURE__ */ Object.create(null);
   const collect = (store, applyActivePathFilter) => {
     entries: for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
@@ -953,7 +1145,7 @@ function placeAt(tree, path, errors) {
     const cursorRecord2 = cursor;
     let child = cursorRecord2[key];
     if (child === null || child === void 0 || typeof child !== "object") {
-      child = typeof nextSeg === "number" ? [] : {};
+      child = typeof nextSeg === "number" ? [] : /* @__PURE__ */ Object.create(null);
       cursorRecord2[key] = child;
     }
     cursor = child;
@@ -988,19 +1180,20 @@ function buildFieldArrayApi(state) {
     prepend(path, value) {
       const next = readArray(path);
       next.unshift(value);
-      return writeArray(path, next, { kind: "shift-from", index: 0 });
+      return writeArray(path, next, { kind: "insert", index: 0 });
     },
     insert(path, index, value) {
       const next = readArray(path);
-      next.splice(index, 0, value);
-      const clampedIndex = Math.max(0, Math.min(index, next.length));
-      return writeArray(path, next, { kind: "shift-from", index: clampedIndex });
+      const preLen = next.length;
+      const insertIndex = index < 0 ? Math.max(0, preLen + index) : Math.min(index, preLen);
+      next.splice(insertIndex, 0, value);
+      return writeArray(path, next, { kind: "insert", index: insertIndex });
     },
     remove(path, index) {
       const next = readArray(path);
       if (index < 0 || index >= next.length) return false;
       next.splice(index, 1);
-      return writeArray(path, next, { kind: "shift-from", index });
+      return writeArray(path, next, { kind: "remove", index });
     },
     swap(path, a, b) {
       const next = readArray(path);
@@ -1018,11 +1211,7 @@ 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, {
-        kind: "shift-range",
-        fromIndex: Math.min(from, clampedTo),
-        toIndex: Math.max(from, clampedTo)
-      });
+      return writeArray(path, next, { kind: "move", from, to: clampedTo });
     },
     replace(path, index, value) {
       const next = readArray(path);
@@ -1041,6 +1230,8 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "focused",
   "blurred",
   "touched",
+  "interacted",
+  "blurredAfterInteraction",
   "connected",
   "element",
   "elements",
@@ -1048,20 +1239,28 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "errors",
   "validating",
   "valid",
+  "displayState",
   "showErrors",
+  "showPending",
+  "showSuccess",
+  "showIdle",
   "firstError",
   "path",
+  "id",
+  "aria",
+  "key",
   "blank",
   "label",
   "description",
   "placeholder",
   "meta"
 ]);
-function buildFieldStateProxy(state, getFormMetaBase, options) {
+function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
   const getFieldStateAt = buildFieldStateAccessor(
     state,
+    formInstanceId,
     getFormMetaBase,
-    options?.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0
+    options?.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0
   );
   const snapshotFieldStateAt = (path) => {
     const view = getFieldStateAt(path).value;
@@ -1110,9 +1309,34 @@ function buildFieldStateProxy(state, getFormMetaBase, options) {
           writable: false
         };
       },
-      set: () => false,
-      deleteProperty: () => false,
-      defineProperty: () => false
+      // Warn-and-noop: returning `false` here throws `TypeError` under
+      // strict mode (`form.fields('email').value = 1` from any ESM
+      // module), which would violate the documented "writes are
+      // ignored" contract. Mirrors `values-proxy` / `wizard-statuses-proxy`.
+      set: (_, key) => {
+        if (paths.__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
+          );
+        }
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        if (paths.__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 delete of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      },
+      defineProperty: (_, key) => {
+        if (paths.__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 define of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      }
     });
     terminalCache.set(cacheKey, proxy);
     return proxy;
@@ -1128,21 +1352,6 @@ function buildFieldStateProxy(state, getFormMetaBase, options) {
     isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
-function liveKeysAtPath(state, segments) {
-  const value = getAtPath(state.form.value, segments);
-  if (value === null || value === void 0) return [];
-  if (Array.isArray(value)) {
-    const keys = new Array(value.length);
-    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
-    return keys;
-  }
-  if (typeof value === "object") return Object.keys(value);
-  return [];
-}
-function isArrayPath(state, segments) {
-  if (segments.length === 0) return false;
-  return Array.isArray(getAtPath(state.form.value, segments));
-}
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
   const liveValue = getAtPath(state.form.value, containerSegments);
   return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
@@ -1168,29 +1377,6 @@ function walk$2(value, basePath, schema, snapshotFieldStateAt) {
   return result;
 }
 
-const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
-const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
-const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
-const PERSISTENCE_KEY_PREFIX = "attaform:";
-const RESERVED_KEY_PREFIX = "__atta:";
-const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
-const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
-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 (paths.__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) {
   if (typeof storage === "object") return storage;
@@ -1209,7 +1395,7 @@ async function getStorageAdapter(storage) {
     }
   }
 }
-const PERSISTED_ENVELOPE_VERSION = 5;
+const PERSISTED_ENVELOPE_VERSION = 6;
 function readPersistedPayload(value) {
   if (value === null || value === void 0 || typeof value !== "object") return null;
   const envelope = value;
@@ -1233,12 +1419,7 @@ function warnVersionMismatch(observedVersion) {
 function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
   let transientList;
   if (blankPaths !== void 0 && blankPaths.size > 0) {
-    const dotted = [];
-    for (const key of blankPaths) {
-      const d = paths.pathKeyToDotted(key);
-      if (d !== null) dotted.push(d);
-    }
-    transientList = dotted.length > 0 ? dotted : void 0;
+    transientList = [...blankPaths];
   }
   if (include === "form") {
     if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
@@ -1260,30 +1441,35 @@ function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPat
 function createDebouncedWriter(write, debounceMs) {
   let timer = null;
   let pending = null;
+  let writeGeneration = 0;
+  function runWrite() {
+    const gen = ++writeGeneration;
+    pending = write().finally(() => {
+      if (writeGeneration === gen) pending = null;
+    });
+  }
   function schedule() {
     if (timer !== null) clearTimeout(timer);
     if (debounceMs === 0) {
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
       return;
     }
     timer = setTimeout(() => {
       timer = null;
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
     }, debounceMs);
   }
   async function flush() {
     if (timer !== null) {
       clearTimeout(timer);
       timer = null;
-      pending = write().finally(() => {
-        pending = null;
-      });
+      runWrite();
+    }
+    while (pending !== null) {
+      const awaited = pending;
+      await awaited;
+      if (pending === awaited) break;
     }
-    if (pending !== null) await pending;
   }
   function cancel() {
     if (timer !== null) {
@@ -1296,7 +1482,7 @@ function createDebouncedWriter(write, debounceMs) {
 function resolveStorageKeyBase(config, formKey) {
   return config.key ?? `${PERSISTENCE_KEY_PREFIX}${formKey}`;
 }
-async function cleanupOrphanKeys(adapter, base, currentKey) {
+async function removeMatchingKeys(adapter, base, keepKey) {
   let keys;
   try {
     keys = await adapter.listKeys(base);
@@ -1304,12 +1490,15 @@ async function cleanupOrphanKeys(adapter, base, currentKey) {
     return;
   }
   for (const key of keys) {
-    if (key === currentKey) continue;
+    if (key === keepKey) continue;
     if (key === base || key.startsWith(`${base}:`)) {
       void adapter.removeItem(key).catch(() => void 0);
     }
   }
 }
+async function cleanupOrphanKeys(adapter, base, currentKey) {
+  await removeMatchingKeys(adapter, base, currentKey);
+}
 const STANDARD_STORAGE_KINDS = ["local", "session", "indexeddb"];
 function normalizePersistConfig(input) {
   if (typeof input === "string") return { storage: input };
@@ -1320,12 +1509,7 @@ async function sweepAllOrphansAcrossStandardStores(base) {
   for (const kind of STANDARD_STORAGE_KINDS) {
     try {
       const adapter = await getStorageAdapter(kind);
-      const keys = await adapter.listKeys(base);
-      for (const key of keys) {
-        if (key === base || key.startsWith(`${base}:`)) {
-          void adapter.removeItem(key).catch(() => void 0);
-        }
-      }
+      await removeMatchingKeys(adapter, base);
     } catch {
     }
   }
@@ -1336,12 +1520,7 @@ async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
     if (kind === configuredKind) continue;
     try {
       const adapter = await getStorageAdapter(kind);
-      const keys = await adapter.listKeys(base);
-      for (const key of keys) {
-        if (key === base || key.startsWith(`${base}:`)) {
-          void adapter.removeItem(key).catch(() => void 0);
-        }
-      }
+      await removeMatchingKeys(adapter, base);
     } catch {
     }
   }
@@ -1357,6 +1536,29 @@ function pluckPaths(form, pathKeys) {
   }
   return sparse ?? {};
 }
+function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
+  const acknowledgedSensitive = [];
+  for (const key of optedInPaths) {
+    const segs = paths.segmentsForPathKey(key);
+    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
+  }
+  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => paths.isPathPrefix(prefix, path));
+  const walk = (path, value) => {
+    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {
+      return void 0;
+    }
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
+    if (!isPlainRecord(value)) return value;
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value)) {
+      const walked = walk([...path, key], value[key]);
+      if (walked !== void 0) out[key] = walked;
+    }
+    return out;
+  };
+  return walk([], form);
+}
 function filterErrorsByPaths(errors, pathKeys) {
   const out = /* @__PURE__ */ new Map();
   for (const [key, value] of errors) {
@@ -1383,7 +1585,7 @@ function mergeDeep(target, source, path, schema) {
       if (sourceDisc !== void 0) {
         const variantDefault = du.getVariantDefault(sourceDisc);
         if (isPlainRecord(variantDefault)) {
-          const out2 = { ...variantDefault };
+          const out2 = Object.assign(/* @__PURE__ */ Object.create(null), 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);
@@ -1395,7 +1597,7 @@ function mergeDeep(target, source, path, schema) {
     }
   }
   const mergeTarget = target;
-  const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
+  const out = isPlainRecord(mergeTarget) ? Object.assign(/* @__PURE__ */ Object.create(null), mergeTarget) : /* @__PURE__ */ Object.create(null);
   for (const key of Object.keys(source)) {
     out[key] = mergeDeep(out[key], source[key], [...path, key], schema);
   }
@@ -1498,39 +1700,44 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     }
     return result;
   }
-  async function validateAsync(pathInput) {
+  async function runImperativeValidation(pathInput, config) {
     const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
     const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
     try {
       state.activeValidations.value += 1;
-      state.cancelFieldValidation();
+      if (config.cancelInFlight) state.cancelFieldValidation();
       const refinement = await runRefinementValidation(dataAtPath, segments);
-      const scopePath = segments ?? [];
-      const errors = refinement.success ? [] : refinement.errors;
-      const reStamped = segments === void 0 ? errors : errors.map((err) => ({
-        ...err,
-        path: [...segments, ...err.path]
-      }));
-      state.applySchemaErrorsForSubtree(scopePath, reStamped);
-      return stripData(composeWithDerivedBlank(refinement, segments));
+      if (config.commitToSchemaErrors) {
+        const scopePath = segments ?? [];
+        const errors = refinement.success ? [] : refinement.errors;
+        const reStamped = segments === void 0 ? errors : errors.map((err) => ({
+          ...err,
+          path: [...segments, ...err.path]
+        }));
+        state.applySchemaErrorsForSubtree(scopePath, reStamped);
+      }
+      return { ok: true, refinement, segments };
     } catch (err) {
-      return adapterThrowResponse(err);
+      return { ok: false, error: adapterThrowResponse(err) };
     } finally {
       state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
     }
   }
+  async function validateAsync(pathInput) {
+    const result = await runImperativeValidation(pathInput, {
+      cancelInFlight: true,
+      commitToSchemaErrors: true
+    });
+    if (!result.ok) return result.error;
+    return stripData(composeWithDerivedBlank(result.refinement, result.segments));
+  }
   async function process(pathInput) {
-    const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
-    const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
-    try {
-      state.activeValidations.value += 1;
-      const refinement = await runRefinementValidation(dataAtPath, segments);
-      return composeWithDerivedBlank(refinement, segments);
-    } catch (err) {
-      return adapterThrowResponse(err);
-    } finally {
-      state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
-    }
+    const result = await runImperativeValidation(pathInput, {
+      cancelInFlight: false,
+      commitToSchemaErrors: false
+    });
+    if (!result.ok) return result.error;
+    return composeWithDerivedBlank(result.refinement, result.segments);
   }
   function adapterThrowResponse(err) {
     return {
@@ -1968,7 +2175,6 @@ function coerceValue(value, accepted, elementAccepted, index) {
 }
 
 const EMPTY_TRANSFORMS = Object.freeze([]);
-const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 const attaformListenersSymbol = Symbol.for("attaform:focus-listeners");
 function attachFocusListeners(state, segments, element, instanceMeta) {
   const target = element;
@@ -1996,6 +2202,8 @@ function detachFocusListeners(element) {
 function buildRegister(state, formInstanceId, instanceConfig) {
   const coerceIndex = instanceConfig?.coerce !== void 0 ? resolveCoercionIndex(instanceConfig.coerce) : state.coerceIndex;
   const instanceMeta = instanceConfig?.instanceMeta;
+  const formAutoAria = instanceConfig?.autoAria ?? true;
+  const getDisplayStateAt = instanceConfig?.getDisplayStateAt;
   const withInstanceMeta = (meta) => {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
@@ -2017,7 +2225,11 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       if (typed !== null && typeof raw === "number" && parseFloat(typed) === raw) {
         return typed;
       }
-      return String(raw);
+      try {
+        return String(raw);
+      } catch {
+        return Object.prototype.toString.call(raw);
+      }
     });
     const slimDefault = state.schema.getDefaultAtPath(segments);
     const slimTypes = state.schema.getSlimPrimitiveTypesAtPath(segments);
@@ -2050,6 +2262,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         callSite: paths.captureUserCallSite()
       });
     }
+    const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
+    const isRequired = state.schema.isRequiredAtPath(segments);
+    const ariaEnabled = options?.autoAria ?? formAutoAria;
+    const ariaDisplayState = getDisplayStateAt !== void 0 ? vue.computed(() => getDisplayStateAt(segments)) : void 0;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2064,8 +2280,11 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           })
         );
       },
+      markInteracted: () => {
+        state.markInteracted(segments);
+      },
       registerElement: (element) => {
-        if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
+        if (!paths.INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
         if (added) attachFocusListeners(state, segments, element, instanceMeta);
       },
@@ -2108,7 +2327,12 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {},
       acceptsUndefined,
-      acceptsString
+      acceptsString,
+      // --- Aria (internal; consumed by the directive) ---
+      aria,
+      isRequired,
+      ariaEnabled,
+      ...ariaDisplayState !== void 0 ? { ariaDisplayState } : {}
     };
     return vue.shallowReadonly(internalRv);
   };
@@ -2159,7 +2383,7 @@ function walk(input, segments, schema, paths) {
     if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !(slim instanceof Date) && !(slim instanceof RegExp) && !(slim instanceof Map) && !(slim instanceof Set)) {
       for (const k of Object.keys(slim)) allKeys.add(k);
     }
-    const out = {};
+    const out = /* @__PURE__ */ Object.create(null);
     let mutated = allKeys.size !== inputKeys.length;
     for (const key of allKeys) {
       const orig = input[key];
@@ -2188,7 +2412,7 @@ function walkUnspecified(slim, segments, paths$1) {
   }
   if (Array.isArray(slim)) return slim;
   if (slim !== null && typeof slim === "object") {
-    const out = {};
+    const out = /* @__PURE__ */ Object.create(null);
     for (const key of Object.keys(slim)) {
       out[key] = walkUnspecified(slim[key], [...segments, key], paths$1);
     }
@@ -2221,7 +2445,7 @@ function substitute(input, segments, schema, paths) {
   }
   if (typeof input === "object") {
     let mutated = false;
-    const out = {};
+    const out = /* @__PURE__ */ Object.create(null);
     for (const key of Object.keys(input)) {
       const orig = input[key];
       const walked = substitute(orig, [...segments, key], schema, paths);
@@ -2273,70 +2497,86 @@ function expandUnsetAt(segments, schema, paths$1) {
   return result;
 }
 
-function buildValuesProxy(form) {
-  const inner = vue.computed(() => vue.readonly(form.value));
+function buildCallableReadonlySnapshotProxy(opts) {
   const target = (() => {
   });
-  const valuesToString = () => JSON.stringify(inner.value);
-  const valuesToPrimitive = (hint) => hint === "number" ? NaN : valuesToString();
+  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(opts.snapshot);
+  const callResolve = opts.resolveCall ?? ((arg) => opts.resolveKey(String(arg)));
   return new Proxy(target, {
     apply(_, __, args) {
       const arg = args[0];
-      if (arg === void 0) return inner.value;
-      const { segments } = paths.canonicalizePath(arg);
-      let cursor = inner.value;
-      for (const seg of segments) {
-        if (cursor === null || cursor === void 0) return void 0;
-        cursor = cursor[seg];
-      }
-      return cursor;
+      if (arg === void 0) return opts.snapshot();
+      return callResolve(arg);
     },
     get(_, key) {
       if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return valuesToPrimitive;
+        if (key === Symbol.toPrimitive) return toPrimitive;
         return Reflect.get(target, key);
       }
-      if (key === "toJSON") return () => inner.value;
-      if (key === "toString") return valuesToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      return inner.value[key];
+      if (key === "toJSON") return toJSON;
+      if (key === "toString") return toString;
+      if (key === "valueOf") return valueOf;
+      return opts.resolveKey(key);
     },
     has(_, key) {
       if (typeof key === "symbol") return Reflect.has(target, key);
-      return Reflect.has(inner.value, key);
-    },
-    ownKeys() {
-      return Reflect.ownKeys(inner.value);
+      return opts.hasKey(key);
     },
+    ownKeys: () => opts.ownKeys(),
     getOwnPropertyDescriptor(_, key) {
-      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
-      if (desc !== void 0) desc.configurable = true;
-      return desc;
+      if (typeof key !== "string") return void 0;
+      if (opts.describeKey !== void 0) return opts.describeKey(key);
+      if (!opts.hasKey(key)) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: opts.resolveKey(key)
+      };
     },
-    // Match Vue's `readonly()` semantics: writes warn (in dev) and
-    // silently noop (return true). Returning false would throw
-    // TypeError in strict-mode consumers, surprising users who
-    // assigned through the proxy and expected it to be ignored.
-    set(_, key) {
-      if (paths.__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
-        );
-      }
+    set: (_, key) => {
+      warnReadOnly(opts.surface, "write", key);
       return true;
     },
-    deleteProperty(_, key) {
-      if (paths.__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
+    deleteProperty: (_, key) => {
+      warnReadOnly(opts.surface, "delete", key);
       return true;
     },
-    defineProperty: () => true
+    defineProperty: (_, key) => {
+      warnReadOnly(opts.surface, "define", key);
+      return true;
+    }
+  });
+}
+
+function buildValuesProxy(form) {
+  const inner = vue.computed(() => vue.readonly(form.value));
+  return buildCallableReadonlySnapshotProxy({
+    surface: "form.values",
+    snapshot: () => inner.value,
+    // Read through the readonly proxy at access time so Vue's
+    // dependency tracking lands inside the consumer's active effect
+    // — `inner.value[key]` is what triggers per-key tracking.
+    resolveKey: (key) => inner.value[key],
+    // Dynamic path: walk segments through the readonly proxy. Each
+    // step reads through the proxy's own get traps so dependency
+    // tracking propagates at every level.
+    resolveCall: (arg) => {
+      const { segments } = paths.canonicalizePath(arg);
+      let cursor = inner.value;
+      for (const seg of segments) {
+        if (cursor === null || cursor === void 0) return void 0;
+        cursor = cursor[seg];
+      }
+      return cursor;
+    },
+    ownKeys: () => Reflect.ownKeys(inner.value),
+    hasKey: (key) => Reflect.has(inner.value, key),
+    describeKey: (key) => {
+      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
+      if (desc !== void 0) desc.configurable = true;
+      return desc;
+    }
   });
 }
 
@@ -2352,15 +2592,34 @@ function buildFormApi(state, formInstanceId, options = {}) {
     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 getFormMetaBase = () => {
+    const rootBase = buildContainerFieldStateBase(state, paths.ROOT_PATH, paths.ROOT_PATH_KEY, formInstanceId);
+    return {
+      ...rootBase,
+      submitting: state.submitting.value,
+      submissionAttempts: state.submissionAttempts.value,
+      departAttempts: state.departAttempts.value,
+      submitError: state.submitError.value,
+      errorCount: rootBase.errors.length,
+      submitted: state.submitted.value,
+      instanceId: formInstanceId
+    };
   };
-  const register = buildRegister(
+  const fieldStateAccessorOptions = options.getDisplayState !== void 0 ? { getDisplayState: options.getDisplayState } : void 0;
+  const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
-    Object.keys(registerConfig).length > 0 ? registerConfig : void 0
+    getFormMetaBase,
+    fieldStateAccessorOptions
   );
+  const getDisplayStateAt = (segments) => getRootFieldStateAt(segments).value.displayState;
+  const registerConfig = {
+    ...instanceMeta !== void 0 ? { instanceMeta } : {},
+    ...options.coerce !== void 0 ? { coerce: options.coerce } : {},
+    ...options.autoAria !== void 0 ? { autoAria: options.autoAria } : {},
+    getDisplayStateAt
+  };
+  const register = buildRegister(state, formInstanceId, registerConfig);
   const processOptions = options.onInvalidSubmit !== void 0 ? { onInvalidSubmit: options.onInvalidSubmit } : {};
   const defaultInvalidSubmitPolicy = options.onInvalidSubmit ?? "focus-first-error";
   const {
@@ -2383,10 +2642,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
         next,
         state.schema
       );
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      if (!ok2) return false;
       for (const pathKey of walked2.paths) {
-        state.blankPaths.add(pathKey);
+        const blankSegments = paths.segmentsForPathKey(pathKey);
+        if (blankSegments === null) continue;
+        state.setValueAtPath(
+          blankSegments,
+          state.getValueAtPath(blankSegments),
+          withInstanceMeta({ blank: true })
+        );
       }
-      return state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      return true;
     }
     const segments = paths.canonicalizePath(pathOrValue).segments;
     const writeUnsetAt = () => {
@@ -2532,43 +2799,48 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const metaErrors = vue.computed(
     () => aggregateErrorsAt(state, [])
   );
-  const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, paths.ROOT_PATH);
-    return {
-      ...rootBase,
-      submitting: state.submitting.value,
-      submissionAttempts: state.submissionAttempts.value,
-      departAttempts: state.departAttempts.value,
-      submitError: state.submitError.value,
-      errorCount: rootBase.errors.length,
-      submitted: state.submitted.value,
-      instanceId: formInstanceId
-    };
-  };
-  const fieldStateAccessorOptions = options.shouldShowErrors !== void 0 ? { shouldShowErrors: options.shouldShowErrors } : void 0;
-  const getRootFieldStateAt = buildFieldStateAccessor(
-    state,
-    getFormMetaBase,
-    fieldStateAccessorOptions
-  );
   const rootFieldState = getRootFieldStateAt([]);
   const formMeta = vue.readonly(
     vue.reactive({
-      // FieldState fields — read through one shared root computed. Each
-      // property accesses `rootFieldState.value[X]`, so any descendant
-      // change re-evaluates the root computed once (Vue's reactive
-      // graph dedupes the dependent re-renders).
-      value: vue.computed(() => rootFieldState.value.value),
-      original: vue.computed(() => rootFieldState.value.original),
-      pristine: vue.computed(() => rootFieldState.value.pristine),
-      dirty: vue.computed(() => rootFieldState.value.dirty),
-      focused: vue.computed(() => rootFieldState.value.focused),
-      blurred: vue.computed(() => rootFieldState.value.blurred),
-      touched: vue.computed(() => rootFieldState.value.touched),
-      connected: vue.computed(() => rootFieldState.value.connected),
-      element: vue.computed(() => rootFieldState.value.element),
-      elements: vue.computed(() => rootFieldState.value.elements),
-      updatedAt: vue.computed(() => rootFieldState.value.updatedAt),
+      get value() {
+        return rootFieldState.value.value;
+      },
+      get original() {
+        return rootFieldState.value.original;
+      },
+      get pristine() {
+        return rootFieldState.value.pristine;
+      },
+      get dirty() {
+        return rootFieldState.value.dirty;
+      },
+      get focused() {
+        return rootFieldState.value.focused;
+      },
+      get blurred() {
+        return rootFieldState.value.blurred;
+      },
+      get touched() {
+        return rootFieldState.value.touched;
+      },
+      get interacted() {
+        return rootFieldState.value.interacted;
+      },
+      get blurredAfterInteraction() {
+        return rootFieldState.value.blurredAfterInteraction;
+      },
+      get connected() {
+        return rootFieldState.value.connected;
+      },
+      get element() {
+        return rootFieldState.value.element;
+      },
+      get elements() {
+        return rootFieldState.value.elements;
+      },
+      get updatedAt() {
+        return rootFieldState.value.updatedAt;
+      },
       // Whole-form validating mirrors the LIFECYCLE counter
       // (`state.activeValidations`) ORed with any per-leaf validation
       // in flight (via `rootFieldState.validating`). A submit-time
@@ -2586,19 +2858,56 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // keep the explicit form-level computation for the gate.
       valid,
       errors: metaErrors,
-      // `showErrors` / `firstError` flow through the same root
-      // field-state computed as the rest of the FieldState surface,
-      // so `form.meta.showErrors` matches `form.fields().showErrors`
-      // exactly — the predicate runs once at the root and the result
-      // is shared.
-      showErrors: vue.computed(() => rootFieldState.value.showErrors),
-      firstError: vue.computed(() => rootFieldState.value.firstError),
-      path: vue.computed(() => rootFieldState.value.path),
-      blank: vue.computed(() => rootFieldState.value.blank),
-      label: vue.computed(() => rootFieldState.value.label),
-      description: vue.computed(() => rootFieldState.value.description),
-      placeholder: vue.computed(() => rootFieldState.value.placeholder),
-      meta: vue.computed(() => rootFieldState.value.meta),
+      // `displayState` / the `show*` booleans / `firstError` flow
+      // through the same root field-state computed as the rest of the
+      // FieldState surface, so `form.meta.displayState` matches
+      // `form.fields().displayState` exactly — the predicate runs once
+      // at the root and the result is shared.
+      get displayState() {
+        return rootFieldState.value.displayState;
+      },
+      get showErrors() {
+        return rootFieldState.value.showErrors;
+      },
+      get showPending() {
+        return rootFieldState.value.showPending;
+      },
+      get showSuccess() {
+        return rootFieldState.value.showSuccess;
+      },
+      get showIdle() {
+        return rootFieldState.value.showIdle;
+      },
+      get firstError() {
+        return rootFieldState.value.firstError;
+      },
+      get path() {
+        return rootFieldState.value.path;
+      },
+      get id() {
+        return rootFieldState.value.id;
+      },
+      get aria() {
+        return rootFieldState.value.aria;
+      },
+      get key() {
+        return rootFieldState.value.key;
+      },
+      get blank() {
+        return rootFieldState.value.blank;
+      },
+      get label() {
+        return rootFieldState.value.label;
+      },
+      get description() {
+        return rootFieldState.value.description;
+      },
+      get placeholder() {
+        return rootFieldState.value.placeholder;
+      },
+      get meta() {
+        return rootFieldState.value.meta;
+      },
       // Lifecycle (form-level only — not on FieldState).
       submitting,
       submissionAttempts,
@@ -2607,7 +2916,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // Scalar mirror over the array — meta is a single sticky surface
       // for both templates and `useWizard`'s `FormStatus`, so the
       // projection lives here.
-      errorCount: vue.computed(() => metaErrors.value.length),
+      get errorCount() {
+        return metaErrors.value.length;
+      },
       submitted,
       // Per-`useForm()`-call identity. Stable for one mount; new on
       // re-mount; orthogonal to `form.key` (which is the user-supplied
@@ -2644,12 +2955,20 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   function clear(pathInput) {
-    const segments = pathInput === void 0 ? paths.ROOT_PATH : paths.canonicalizePath(pathInput).segments;
-    return state.clear(segments);
+    if (pathInput === void 0) {
+      return setValueImpl(unset);
+    }
+    return setValueImpl(pathInput, unset);
   }
   const persist = async (pathInput, options2) => {
     const segments = paths.canonicalizePath(pathInput).segments;
-    paths.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
+    if (!paths.allowSensitivePersist(
+      segments,
+      options2?.acknowledgeSensitive === true,
+      state.isSensitivePath
+    )) {
+      return;
+    }
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2709,13 +3028,43 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return Object.freeze(view);
   });
   const valuesProxy = buildValuesProxy(state.form);
-  const fieldStateProxy = buildFieldStateProxy(state, getFormMetaBase, fieldStateAccessorOptions);
+  const fieldStateProxy = buildFieldStateProxy(
+    state,
+    formInstanceId,
+    getFormMetaBase,
+    fieldStateAccessorOptions
+  );
+  const needsLazyGate = state.defaultValuesFactory.value !== void 0 || state.hasSsrPrefetch;
   function gated(fn) {
+    if (!needsLazyGate) return fn;
     return ((...args) => {
       void state.activate();
       return fn(...args);
     });
   }
+  const callTerminal = fieldStateProxy;
+  const EMPTY_FIELD_LIST = Object.freeze([]);
+  function list(path) {
+    const { segments } = paths.canonicalizePath(path);
+    const value = state.getValueAtPath(segments);
+    if (!Array.isArray(value)) return EMPTY_FIELD_LIST;
+    const out = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) out[i] = callTerminal(`${path}.${i}`);
+    return Object.freeze(out);
+  }
+  const EMPTY_FIELD_RECORD = Object.freeze({});
+  function record(path) {
+    const { segments } = paths.canonicalizePath(path);
+    const value = state.getValueAtPath(segments);
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      return EMPTY_FIELD_RECORD;
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value)) {
+      out[key] = callTerminal(`${path}.${key}`);
+    }
+    return Object.freeze(out);
+  }
   return {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
@@ -2797,6 +3146,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     swap: gated(fieldArrays.swap),
     move: gated(fieldArrays.move),
     replace: gated(fieldArrays.replace),
+    list: gated(list),
+    record: gated(record),
     get blankPaths() {
       void state.activate();
       return blankPathsView;
@@ -2804,47 +3155,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
 }
 
-const defaultShouldShowErrors = (field, formMeta) => {
-  const hasOwnError = field.errors.some(
-    (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
-  );
-  if (!hasOwnError) return false;
-  if (field.validating === true) return false;
-  if (formMeta.submissionAttempts > 0) return true;
-  return field.touched === true && field.focused !== true;
-};
-const SHOW_ALWAYS = () => true;
-const SHOW_NEVER = () => false;
-function resolveShouldShowErrors(config) {
-  if (config === void 0) return defaultShouldShowErrors;
-  if (config === true) return SHOW_ALWAYS;
-  if (config === false) return SHOW_NEVER;
-  return config;
-}
-
-function isHydratedFieldRecord(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const r = value;
-  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean";
-}
-function isHydratedValidationErrorArray(value) {
-  if (!Array.isArray(value)) return false;
-  for (const entry of value) {
-    if (typeof entry !== "object" || entry === null) return false;
-    const e = entry;
-    if (typeof e.message !== "string") return false;
-    if (!Array.isArray(e.path)) return false;
-    if (typeof e.formKey !== "string") return false;
-    if (typeof e.code !== "string") return false;
-  }
-  return true;
-}
-function warnMalformedHydration(formKey, kind, rawKey) {
-  if (!paths.__DEV__) return;
-  console.warn(
-    `[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);
@@ -2873,49 +3183,74 @@ function walkDuStubs(schema, value, path, warned) {
           );
         }
       }
-      return { [du.discriminatorKey]: discValue };
+      const stub = /* @__PURE__ */ Object.create(null);
+      stub[du.discriminatorKey] = discValue;
+      return stub;
     }
   }
-  const out = {};
+  const out = /* @__PURE__ */ Object.create(null);
   for (const k of Object.keys(rec)) {
     out[k] = walkDuStubs(schema, rec[k], [...path, k], warned);
   }
   return out;
 }
-function isPathKeyUnder(existingKey, parentPath) {
-  const parsed = paths.segmentsForPathKey(existingKey);
-  if (parsed === null) return false;
-  if (parsed.length <= parentPath.length) return false;
-  for (let i = 0; i < parentPath.length; i++) {
-    if (parsed[i] !== parentPath[i]) return false;
-  }
-  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;
+
+function createVariantMemory() {
+  const memory = /* @__PURE__ */ new Map();
+  function clearAtArrayIndices(arrayPath, indexFilter) {
+    for (const memKey of [...memory.keys()]) {
+      const segs = paths.segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= arrayPath.length) continue;
+      const idxSeg = segs[arrayPath.length];
+      if (typeof idxSeg !== "number") continue;
+      if (indexFilter(idxSeg)) memory.delete(memKey);
     }
-    return 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;
+  return {
+    clear() {
+      memory.clear();
+    },
+    clearUnderPath(parentPath) {
+      for (const memKey of [...memory.keys()]) {
+        const segs = paths.segmentsForPathKey(memKey);
+        if (segs === null) continue;
+        if (paths.isPathPrefix(parentPath, segs)) memory.delete(memKey);
+      }
+    },
+    applyArrayOp(arrayPath, op) {
+      switch (op.kind) {
+        case "insert":
+        case "remove":
+          clearAtArrayIndices(arrayPath, (i) => i >= op.index);
+          return;
+        case "move": {
+          const lo = Math.min(op.from, op.to);
+          const hi = Math.max(op.from, op.to);
+          clearAtArrayIndices(arrayPath, (i) => i >= lo && i <= hi);
+          return;
+        }
+        case "swap":
+          clearAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
+          return;
+        case "replace-at":
+          clearAtArrayIndices(arrayPath, (i) => i === op.index);
+          return;
+      }
+    },
+    recordOutgoing(unionKey, discValue, snapshot) {
+      let perUnion = memory.get(unionKey);
+      if (perUnion === void 0) {
+        perUnion = /* @__PURE__ */ new Map();
+        memory.set(unionKey, perUnion);
+      }
+      perUnion.set(discValue, snapshot);
+    },
+    lookupIncoming(unionKey, discValue) {
+      return memory.get(unionKey)?.get(discValue);
+    }
+  };
 }
 function cloneVariantSnapshot(value) {
   if (value === null || typeof value !== "object") return value;
@@ -2938,51 +3273,404 @@ function cloneVariantSnapshot(value) {
     return out2;
   }
   const src = raw;
-  const out = {};
+  const out = /* @__PURE__ */ Object.create(null);
   for (const k of Object.keys(src)) out[k] = cloneVariantSnapshot(src[k]);
   return out;
 }
-function walkAuthoredFromConstraints(value, prefix, out) {
-  if (prefix.length > 0) out.add(paths.canonicalizePath(prefix).key);
-  if (isPlainRecord(value)) {
-    for (const k of Object.keys(value)) {
-      walkAuthoredFromConstraints(value[k], [...prefix, k], out);
+
+function createArrayIdentity(getArrayLength) {
+  const tokens = /* @__PURE__ */ new Map();
+  const baselines = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const allocate = () => `k${(counter++).toString(36)}`;
+  function ensure(arrayKey, expectedLen) {
+    let ids = tokens.get(arrayKey);
+    const firstTrack = ids === void 0;
+    if (ids === void 0) {
+      ids = [];
+      tokens.set(arrayKey, ids);
+    }
+    while (ids.length < expectedLen) ids.push(allocate());
+    if (ids.length > expectedLen) ids.length = expectedLen;
+    if (firstTrack) baselines.set(arrayKey, [...ids]);
+    return ids;
+  }
+  function orderPristineForKey(arrayKey) {
+    const baseline = baselines.get(arrayKey);
+    const current = tokens.get(arrayKey);
+    if (baseline === void 0 || current === void 0) return true;
+    if (baseline.length !== current.length) return false;
+    for (let i = 0; i < current.length; i++) {
+      if (current[i] !== baseline[i]) return false;
     }
-    return;
+    return true;
   }
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      walkAuthoredFromConstraints(value[i], [...prefix, i], out);
+  return {
+    tokenAt(arraySegs, index) {
+      const len = getArrayLength(arraySegs);
+      if (index < 0 || index >= len) return "";
+      const ids = ensure(paths.canonicalizePath(arraySegs).key, len);
+      return ids[index] ?? "";
+    },
+    applyOp(arraySegs, op) {
+      const arrayKey = paths.canonicalizePath(arraySegs).key;
+      const postLen = getArrayLength(arraySegs);
+      const preLen = op.kind === "insert" ? postLen - 1 : op.kind === "remove" ? postLen + 1 : postLen;
+      const ids = ensure(arrayKey, Math.max(0, preLen));
+      switch (op.kind) {
+        case "insert":
+          ids.splice(op.index, 0, allocate());
+          return;
+        case "remove":
+          ids.splice(op.index, 1);
+          return;
+        case "move": {
+          const [moved] = ids.splice(op.from, 1);
+          ids.splice(op.to, 0, moved ?? allocate());
+          return;
+        }
+        case "swap": {
+          const tmp = ids[op.a] ?? allocate();
+          ids[op.a] = ids[op.b] ?? allocate();
+          ids[op.b] = tmp;
+          return;
+        }
+        case "replace-at":
+          ids[op.index] = allocate();
+          return;
+      }
+    },
+    applyRemap(arrayPath, remap) {
+      if (remap.moved.size === 0 && remap.vacated.size === 0 && remap.fresh.size === 0) return;
+      const relocate = (store) => {
+        const idxPos = arrayPath.length;
+        const snapshots = [];
+        for (const [key, value] of store) {
+          const segments = paths.segmentsForPathKey(key);
+          if (segments === null) continue;
+          if (!paths.isPathPrefix(arrayPath, segments)) continue;
+          if (segments.length <= idxPos) continue;
+          const idxSeg = segments[idxPos];
+          if (typeof idxSeg !== "number") continue;
+          if (!remap.moved.has(idxSeg) && !remap.vacated.has(idxSeg) && !remap.fresh.has(idxSeg)) {
+            continue;
+          }
+          snapshots.push({ segments: [...segments], index: idxSeg, value });
+        }
+        if (snapshots.length === 0) return;
+        for (const snap of snapshots) store.delete(paths.canonicalizePath(snap.segments).key);
+        for (const snap of snapshots) {
+          const target = remap.moved.get(snap.index);
+          if (target === void 0) continue;
+          const relocated = snap.segments.slice();
+          relocated[idxPos] = target;
+          store.set(paths.canonicalizePath(relocated).key, snap.value);
+        }
+      };
+      relocate(tokens);
+      relocate(baselines);
+    },
+    realign(arraySegs) {
+      ensure(paths.canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
+    },
+    hasStructuralChangeUnder(prefix) {
+      for (const arrayKey of tokens.keys()) {
+        if (orderPristineForKey(arrayKey)) continue;
+        const segs = paths.segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        if (paths.isPathPrefix(prefix, segs)) return true;
+      }
+      return false;
+    },
+    rebaselineAll() {
+      for (const arrayKey of [...tokens.keys()]) {
+        const segs = paths.segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        const ids = ensure(arrayKey, getArrayLength(segs));
+        baselines.set(arrayKey, [...ids]);
+      }
     }
-  }
+  };
 }
-function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
-  if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
-    const left = withDefaults;
-    const right = withoutDefaults;
-    const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
-    for (const k of keys) {
-      walkAuthoredFromSchemaDiff(left[k], right[k], [...prefix, k], out);
-    }
-    return;
-  }
-  if (Array.isArray(withDefaults) && Array.isArray(withoutDefaults)) {
-    const len = Math.max(withDefaults.length, withoutDefaults.length);
-    for (let i = 0; i < len; i++) {
-      walkAuthoredFromSchemaDiff(withDefaults[i], withoutDefaults[i], [...prefix, i], out);
-    }
-    return;
-  }
-  if (!Object.is(withDefaults, withoutDefaults) && prefix.length > 0) {
-    out.add(paths.canonicalizePath(prefix).key);
+
+function remapForOp(op, oldLen) {
+  const moved = /* @__PURE__ */ new Map();
+  const vacated = /* @__PURE__ */ new Set();
+  const fresh = /* @__PURE__ */ new Set();
+  switch (op.kind) {
+    case "insert":
+      for (let i = op.index; i < oldLen; i++) moved.set(i, i + 1);
+      fresh.add(op.index);
+      return { moved, vacated, fresh };
+    case "remove":
+      vacated.add(op.index);
+      for (let i = op.index + 1; i < oldLen; i++) moved.set(i, i - 1);
+      return { moved, vacated, fresh };
+    case "move":
+      if (op.from !== op.to) {
+        moved.set(op.from, op.to);
+        if (op.from < op.to) {
+          for (let i = op.from + 1; i <= op.to; i++) moved.set(i, i - 1);
+        } else {
+          for (let i = op.to; i < op.from; i++) moved.set(i, i + 1);
+        }
+      }
+      return { moved, vacated, fresh };
+    case "swap":
+      if (op.a !== op.b) {
+        moved.set(op.a, op.b);
+        moved.set(op.b, op.a);
+      }
+      return { moved, vacated, fresh };
+    case "replace-at":
+      vacated.add(op.index);
+      fresh.add(op.index);
+      return { moved, vacated, fresh };
+  }
+}
+function changedIndices(remap) {
+  const changed = new Set(remap.vacated);
+  for (const [from, to] of remap.moved) {
+    changed.add(from);
+    changed.add(to);
+  }
+  for (const index of remap.fresh) changed.add(index);
+  return changed;
+}
+function elementIndexUnder(arrayPath, key, idxPos) {
+  const segments = paths.segmentsForPathKey(key);
+  if (segments === null) return null;
+  if (!paths.isPathPrefix(arrayPath, segments)) return null;
+  if (segments.length <= idxPos) return null;
+  const index = segments[idxPos];
+  return typeof index === "number" ? index : null;
+}
+function migrateMapSubtree(map, arrayPath, remap, rewriteValue) {
+  const idxPos = arrayPath.length;
+  const snapshots = [];
+  for (const [key, value] of map) {
+    const index = elementIndexUnder(arrayPath, key, idxPos);
+    if (index === null) continue;
+    if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
+    snapshots.push({ segments: [...paths.segmentsForPathKey(key)], index, value });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) map.delete(paths.canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    map.set(paths.canonicalizePath(relocated).key, rewriteValue(snap.value, relocated));
+  }
+}
+function migrateSetSubtree(set, arrayPath, remap) {
+  const idxPos = arrayPath.length;
+  const snapshots = [];
+  for (const key of set) {
+    const index = elementIndexUnder(arrayPath, key, idxPos);
+    if (index === null) continue;
+    if (!remap.moved.has(index) && !remap.vacated.has(index)) continue;
+    snapshots.push({ segments: [...paths.segmentsForPathKey(key)], index });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) set.delete(paths.canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    set.add(paths.canonicalizePath(relocated).key);
   }
 }
-function createFormStore(options) {
-  const { formKey, schema, defaultValues, strict = true, hydration } = options;
-  const ssr = options.ssr === true;
-  const ssrPrefetch = options.ssrPrefetch;
-  const rememberVariants = options.rememberVariants !== false;
-  const fieldValidationMode = options.validateOn ?? "change";
+
+function createArrayBookkeeping(deps) {
+  const {
+    form,
+    fields,
+    userErrors,
+    originals,
+    blankPaths,
+    originalBlankPaths,
+    fieldValidationCounts,
+    fieldValidationState,
+    schemaErrors,
+    activeValidations,
+    arrayIdentity,
+    touchFieldRecord,
+    decFieldValidation
+  } = deps;
+  function migrateElementState(arrayPath, remap) {
+    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
+    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
+      ...record,
+      path: segments
+    }));
+    migrateMapSubtree(
+      userErrors,
+      arrayPath,
+      remap,
+      (errors, segments) => errors.map((error) => ({ ...error, path: [...segments] }))
+    );
+    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
+      segments,
+      value: record.value
+    }));
+    migrateSetSubtree(blankPaths, arrayPath, remap);
+    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
+    arrayIdentity.applyRemap(arrayPath, remap);
+  }
+  function seedFreshElement(arrayPath, freshIndex) {
+    const elementPath = [...arrayPath, freshIndex];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = paths.canonicalizePath(patch.path);
+      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
+      touchFieldRecord(key, patch.path, { updatedAt: now });
+    });
+  }
+  function dropSchemaErrorsAtChangedIndices(arrayPath, remap) {
+    const changed = changedIndices(remap);
+    if (changed.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const key of [...schemaErrors.keys()]) {
+      const segs = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
+    }
+  }
+  function abortValidationAtVacatedIndices(arrayPath, remap) {
+    if (remap.vacated.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
+      }
+      entry.controller.abort();
+      fieldValidationState.delete(key);
+    }
+  }
+  return {
+    migrateElementState,
+    seedFreshElement,
+    dropSchemaErrorsAtChangedIndices,
+    abortValidationAtVacatedIndices
+  };
+}
+
+function isHydratedFieldRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const r = value;
+  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean" && typeof r.interacted === "boolean" && typeof r.blurredAfterInteraction === "boolean";
+}
+function isHydratedValidationErrorArray(value) {
+  if (!Array.isArray(value)) return false;
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) return false;
+    const e = entry;
+    if (typeof e.message !== "string") return false;
+    if (!Array.isArray(e.path)) return false;
+    if (typeof e.formKey !== "string") return false;
+    if (typeof e.code !== "string") return false;
+  }
+  return true;
+}
+function warnMalformedHydration(formKey, kind, rawKey) {
+  if (!paths.__DEV__) return;
+  console.warn(
+    `[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 isPathKeyUnder(existingKey, parentPath) {
+  const parsed = paths.segmentsForPathKey(existingKey);
+  if (parsed === null) return false;
+  if (parsed.length <= parentPath.length) return false;
+  for (let i = 0; i < parentPath.length; i++) {
+    if (parsed[i] !== parentPath[i]) return false;
+  }
+  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 walkAuthoredFromConstraints(value, prefix, out) {
+  if (prefix.length > 0) out.add(paths.canonicalizePath(prefix).key);
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) {
+      walkAuthoredFromConstraints(value[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      walkAuthoredFromConstraints(value[i], [...prefix, i], out);
+    }
+  }
+}
+function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
+  if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
+    const left = withDefaults;
+    const right = withoutDefaults;
+    const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const k of keys) {
+      walkAuthoredFromSchemaDiff(left[k], right[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(withDefaults) && Array.isArray(withoutDefaults)) {
+    const len = Math.max(withDefaults.length, withoutDefaults.length);
+    for (let i = 0; i < len; i++) {
+      walkAuthoredFromSchemaDiff(withDefaults[i], withoutDefaults[i], [...prefix, i], out);
+    }
+    return;
+  }
+  if (!Object.is(withDefaults, withoutDefaults) && prefix.length > 0) {
+    out.add(paths.canonicalizePath(prefix).key);
+  }
+}
+function createFormStore(options) {
+  const { formKey, schema, defaultValues, strict = true, hydration } = options;
+  const ssr = options.ssr === true;
+  const ssrPrefetch = options.ssrPrefetch;
+  const rememberVariants = options.rememberVariants !== false;
+  const fieldValidationMode = options.validateOn ?? "change";
   const fieldValidationDebounceMs = normalizeNumericOption({
     value: options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS,
     source: "useForm.debounceMs",
@@ -3012,11 +3700,8 @@ function createFormStore(options) {
     noSyncPathCounts.set(path, current - 1);
   }
   const coerceIndex = resolveCoercionIndex(options.coerce);
-  const resolvedShouldShowErrors = resolveShouldShowErrors(
-    options.shouldShowErrors
-  );
+  const resolvedGetDisplayState = resolveGetDisplayState(options.getDisplayState);
   const resolvedIsSensitivePath = options.isSensitivePath ?? paths.isSensitivePath;
-  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? paths.segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -3054,6 +3739,16 @@ function createFormStore(options) {
     warn: true
   });
   const form = vue.ref(stubbedInitialData);
+  const arrayIdentity = createArrayIdentity((arraySegs) => {
+    const v = getAtPath(form.value, arraySegs);
+    return Array.isArray(v) ? v.length : 0;
+  });
+  function arrayElementKey(path) {
+    if (path.length === 0) return "";
+    const last = path[path.length - 1];
+    if (typeof last === "number") return arrayIdentity.tokenAt(path.slice(0, -1), last);
+    return "";
+  }
   const fields = vue.reactive(/* @__PURE__ */ new Map());
   const elements = vue.reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -3069,41 +3764,7 @@ function createFormStore(options) {
     blankPaths.add(key);
     originalBlankPaths.add(key);
   }
-  const variantMemory = /* @__PURE__ */ new Map();
-  function clearVariantMemoryUnderPath(arrayPath) {
-    for (const memKey of [...variantMemory.keys()]) {
-      const segs = paths.segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (isPathPrefix(arrayPath, segs)) variantMemory.delete(memKey);
-    }
-  }
-  function clearVariantMemoryAtArrayIndices(arrayPath, indexFilter) {
-    for (const memKey of [...variantMemory.keys()]) {
-      const segs = paths.segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (!isPathPrefix(arrayPath, segs)) continue;
-      if (segs.length <= arrayPath.length) continue;
-      const idxSeg = segs[arrayPath.length];
-      if (typeof idxSeg !== "number") continue;
-      if (indexFilter(idxSeg)) variantMemory.delete(memKey);
-    }
-  }
-  function applyArrayOpToMemory(arrayPath, op) {
-    switch (op.kind) {
-      case "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 variantMemory = createVariantMemory();
   const pathOrdinals = /* @__PURE__ */ new Map();
   let nextOrdinal = 0;
   function ensurePathOrdinal(key) {
@@ -3141,6 +3802,9 @@ function createFormStore(options) {
   const departAttempts = vue.ref(0);
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
+  const pathSnapshots = /* @__PURE__ */ new Map();
+  let scheduleEpoch = 0;
+  let lastCommittedEpoch = 0;
   const hydrating = vue.ref(false);
   const hydrateError = vue.ref(null);
   const defaultValuesFactory = vue.ref(void 0);
@@ -3156,9 +3820,12 @@ function createFormStore(options) {
   const pathAsyncCache = /* @__PURE__ */ new Map();
   function pathHasAsyncValidation(path) {
     const { key } = paths.canonicalizePath(path);
+    return pathHasAsyncValidationByKey(key, path);
+  }
+  function pathHasAsyncValidationByKey(key, segments) {
     const cached = pathAsyncCache.get(key);
     if (cached !== void 0) return cached;
-    const candidates = schema.getSchemasAtPath(path);
+    const candidates = schema.getSchemasAtPath(segments);
     const hasAsync = candidates.some((sub) => sub.needsAsyncValidation?.() === true);
     pathAsyncCache.set(key, hasAsync);
     return hasAsync;
@@ -3211,7 +3878,9 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -3240,9 +3909,29 @@ function createFormStore(options) {
       blurred: patch.blurred !== void 0 ? patch.blurred : current?.blurred ?? null,
       // touched is plain `boolean`; `??` is equivalent to the explicit
       // guard here because `false` is not nullish.
-      touched: patch.touched ?? current?.touched ?? false
+      touched: patch.touched ?? current?.touched ?? false,
+      // interacted is sticky-true; a merge patch only ever sets it, so
+      // `??` preserves the current bit. It flips back to false solely
+      // through the reset paths, which reconstruct the record outright.
+      interacted: patch.interacted ?? current?.interacted ?? false,
+      blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
     });
   }
+  const arrayBookkeeping = createArrayBookkeeping({
+    form,
+    fields,
+    userErrors,
+    originals,
+    blankPaths,
+    originalBlankPaths,
+    fieldValidationCounts,
+    fieldValidationState,
+    schemaErrors,
+    activeValidations,
+    arrayIdentity,
+    touchFieldRecord,
+    decFieldValidation
+  });
   function applyFormReplacement(next, meta) {
     const prev = form.value;
     if (Object.is(prev, next)) return;
@@ -3366,8 +4055,13 @@ function createFormStore(options) {
     const pathKey = paths.canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
-    } else if (blankPaths.has(pathKey)) {
-      blankPaths.delete(pathKey);
+    } else {
+      if (blankPaths.has(pathKey)) blankPaths.delete(pathKey);
+      if (meta?.arrayOp === void 0) {
+        for (const existingKey of [...blankPaths]) {
+          if (isPathKeyUnder(existingKey, path)) blankPaths.delete(existingKey);
+        }
+      }
     }
     const wasAuthoredBefore = authoredPaths.has(pathKey);
     walkAuthoredFromConstraints(value, path, authoredPaths);
@@ -3386,12 +4080,20 @@ function createFormStore(options) {
       }
       return true;
     }
+    const oldArrayLength = Array.isArray(currentValue) ? currentValue.length : 0;
     const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
     applyFormReplacement(nextForm, meta);
     if (meta?.arrayOp !== void 0) {
-      applyArrayOpToMemory(path, meta.arrayOp);
+      const remap = remapForOp(meta.arrayOp, oldArrayLength);
+      arrayBookkeeping.migrateElementState(path, remap);
+      for (const freshIndex of remap.fresh) arrayBookkeeping.seedFreshElement(path, freshIndex);
+      arrayBookkeeping.dropSchemaErrorsAtChangedIndices(path, remap);
+      arrayBookkeeping.abortValidationAtVacatedIndices(path, remap);
+      variantMemory.applyArrayOp(path, meta.arrayOp);
+      arrayIdentity.applyOp(path, meta.arrayOp);
     } else if (Array.isArray(value) && Array.isArray(currentValue)) {
-      clearVariantMemoryUnderPath(path);
+      variantMemory.clearUnderPath(path);
+      arrayIdentity.realign(path);
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
     if (effectiveModeAfterWrite === "change") {
@@ -3415,18 +4117,12 @@ function createFormStore(options) {
         for (const k of blankPaths) {
           if (isPathKeyUnder(k, parentPath)) outgoingBlanks.push(k);
         }
-        let memoryForUnion2 = variantMemory.get(parentKey);
-        if (memoryForUnion2 === void 0) {
-          memoryForUnion2 = /* @__PURE__ */ new Map();
-          variantMemory.set(parentKey, memoryForUnion2);
-        }
-        memoryForUnion2.set(oldDiscValue, {
+        variantMemory.recordOutgoing(parentKey, oldDiscValue, {
           value: currentValue2,
           blankPaths: outgoingBlanks
         });
       }
-      const memoryForUnion = variantMemory.get(parentKey);
-      const restored = memoryForUnion?.get(newDiscValue);
+      const restored = variantMemory.lookupIncoming(parentKey, newDiscValue);
       if (restored !== void 0) {
         baseline = restored.value;
         restoredBlanks = [...restored.blankPaths];
@@ -3498,6 +4194,7 @@ function createFormStore(options) {
     const controller = new AbortController();
     const fresh = { controller, timer: null, settled: false };
     fieldValidationState.set(key, fresh);
+    const myEpoch = ++scheduleEpoch;
     const run = () => {
       fresh.timer = null;
       if (controller.signal.aborted) return;
@@ -3512,11 +4209,25 @@ function createFormStore(options) {
         }
         throw err;
       }
-      void Promise.resolve().then(() => schema.validateAtPath(form.value, void 0)).then((response) => {
+      const subtreeScope = path.length > 0 && schema.hasContainerOrRootRefine?.() === false;
+      const scopePath = subtreeScope ? path : void 0;
+      const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
+      const scopeKey = subtreeScope ? paths.canonicalizePath(path).key : paths.ROOT_PATH_KEY;
+      void Promise.resolve().then(() => schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
         if (controller.signal.aborted) return;
+        if (myEpoch <= lastCommittedEpoch) return;
+        lastCommittedEpoch = myEpoch;
+        if (effectiveMode === "blur") {
+          const snapshotSource = scopePath !== void 0 ? getAtPath(form.value, scopePath) : form.value;
+          pathSnapshots.set(scopeKey, structuralSnapshot(snapshotSource));
+        }
         const errors = response.success ? [] : response.errors;
         const filtered = filterAuthoredErrors(errors);
-        applySchemaErrorsForSubtree([], filtered);
+        const restamped = subtreeScope ? filtered.map((err) => ({
+          ...err,
+          path: [...path, ...err.path]
+        })) : filtered;
+        applySchemaErrorsForSubtree(scopePath ?? [], restamped);
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
@@ -3743,30 +4454,61 @@ function createFormStore(options) {
   }
   function markFocused(path, focused, meta) {
     const { key } = paths.canonicalizePath(path);
+    const current = fields.get(key);
     touchFieldRecord(key, path, {
       focused,
       blurred: !focused,
       // `touched` flips to true on blur and stays true thereafter; while
       // a field is currently focused we keep whatever value it held.
-      touched: focused ? fields.get(key)?.touched ?? false : true
+      touched: focused ? current?.touched ?? false : true,
+      // `blurredAfterInteraction` flips true on the first blur that lands
+      // after a value edit and stays true. A tab-through blur before any
+      // edit leaves it false (`interacted` is still false at that blur),
+      // which is what keeps a clean tab-through from arming the gate.
+      blurredAfterInteraction: !focused && current?.interacted === true ? true : current?.blurredAfterInteraction ?? false
     });
     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 } : {}
-      });
+      const firstInteractiveBlur = current?.interacted === true && current.blurredAfterInteraction !== true;
+      let snapshot = void 0;
+      let snapshotScopeLength = 0;
+      for (let i = path.length; i >= 0; i--) {
+        const ancestorKey = paths.canonicalizePath(path.slice(0, i)).key;
+        const entry = pathSnapshots.get(ancestorKey);
+        if (entry !== void 0) {
+          snapshot = entry;
+          snapshotScopeLength = i;
+          break;
+        }
+      }
+      let changed = true;
+      if (!firstInteractiveBlur && snapshot !== void 0) {
+        const relPath = path.slice(snapshotScopeLength);
+        const snapshotSubtree = getAtPath(snapshot, relPath);
+        const liveSubtree = getAtPath(form.value, path);
+        changed = false;
+        diffAndApply(snapshotSubtree, liveSubtree, path, () => {
+          changed = true;
+        });
+      }
+      if (changed) {
+        scheduleFieldValidation(path, true, {
+          ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+          ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+        });
+      }
     }
   }
-  function markTouched(path) {
+  function markInteracted(path) {
     const { key } = paths.canonicalizePath(path);
-    touchFieldRecord(key, path, { touched: true });
+    if (fields.get(key)?.interacted === true) return;
+    touchFieldRecord(key, path, { interacted: true });
   }
   function touchAtPath(segments) {
     const formValue = form.value;
     let touchedAny = false;
     for (const [, entry] of originals) {
-      if (!isPathPrefix(segments, entry.segments)) continue;
+      if (!paths.isPathPrefix(segments, entry.segments)) continue;
       if (!hasAtPath(formValue, entry.segments)) continue;
       touchedAny = true;
       const leafKey = paths.canonicalizePath(entry.segments).key;
@@ -3780,9 +4522,6 @@ function createFormStore(options) {
       );
     }
   }
-  function clear(path) {
-    return setValueAtPath(path, schema.getEmptyValueAtPath(path));
-  }
   function rehydrate() {
     const factory = defaultValuesFactory.value;
     if (factory === void 0) {
@@ -3872,6 +4611,7 @@ function createFormStore(options) {
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
+    arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
       if (patch.kind !== "added") return;
@@ -3915,7 +4655,9 @@ function createFormStore(options) {
         connected: record.connected,
         focused: record.focused,
         blurred: record.blurred,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     }
     submissionGeneration.value += 1;
@@ -3926,6 +4668,9 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    pathSnapshots.clear();
+    scheduleEpoch = 0;
+    lastCommittedEpoch = 0;
     variantMemory.clear();
     for (const listener of resetListeners) {
       try {
@@ -3937,13 +4682,7 @@ function createFormStore(options) {
   }
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = paths.canonicalizePath(path);
-    for (const memKey of [...variantMemory.keys()]) {
-      const memSegments = paths.segmentsForPathKey(memKey);
-      if (memSegments === null) continue;
-      if (isPathPrefix(targetSegments, memSegments)) {
-        variantMemory.delete(memKey);
-      }
-    }
+    variantMemory.clearUnderPath(targetSegments);
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
       const wrote = setValueAtPath(targetSegments, leafEntry.value);
@@ -3957,7 +4696,7 @@ function createFormStore(options) {
       let anyMatch = false;
       for (const [, entry] of originals) {
         const leafSegments = entry.segments;
-        if (!isPathPrefix(targetSegments, leafSegments)) continue;
+        if (!paths.isPathPrefix(targetSegments, leafSegments)) continue;
         if (leafSegments.length === targetSegments.length) continue;
         anyMatch = true;
         const relative = leafSegments.slice(targetSegments.length);
@@ -3978,14 +4717,14 @@ function createFormStore(options) {
     deleteErrorsUnderPrefix(schemaErrors, targetSegments);
     deleteErrorsUnderPrefix(userErrors, targetSegments);
     for (const [fieldKey, record] of Array.from(fields.entries())) {
-      if (isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
+      if (paths.isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
     }
   }
   function deleteErrorsUnderPrefix(map, prefix) {
     for (const [errorKey, errs] of Array.from(map.entries())) {
       const first = errs[0];
       if (first === void 0) continue;
-      if (isPathPrefix(prefix, first.path)) {
+      if (paths.isPathPrefix(prefix, first.path)) {
         map.delete(errorKey);
       }
     }
@@ -3999,23 +4738,24 @@ function createFormStore(options) {
       connected: record.connected,
       focused: record.focused,
       blurred: record.blurred,
-      touched: false
+      touched: false,
+      interacted: false,
+      blurredAfterInteraction: false
     });
   }
-  function isPathPrefix(prefix, candidate) {
-    if (prefix.length > candidate.length) return false;
-    for (let i = 0; i < prefix.length; i++) {
-      if (prefix[i] !== candidate[i]) return false;
-    }
-    return true;
-  }
   function isPristineAtPath(path) {
     const { key, segments } = paths.canonicalizePath(path);
+    return isPristineAtPathByKey(key, segments);
+  }
+  function isPristineAtPathByKey(key, segments) {
     if (blankPaths.has(key) !== originalBlankPaths.has(key)) return false;
     const entry = originals.get(key);
     if (entry === void 0) return true;
     return Object.is(getAtPath(form.value, segments), entry.value);
   }
+  function hasStructuralChangeUnder(path) {
+    return arrayIdentity.hasStructuralChangeUnder(path);
+  }
   function getFieldRecord(path) {
     const { key } = paths.canonicalizePath(path);
     return fields.get(key);
@@ -4059,7 +4799,7 @@ function createFormStore(options) {
     originals,
     schema,
     ssr,
-    shouldShowErrors: resolvedShouldShowErrors,
+    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4069,6 +4809,7 @@ function createFormStore(options) {
     hydrating,
     hydrateError,
     defaultValuesFactory,
+    hasSsrPrefetch: ssrPrefetch !== void 0,
     defaultsResolved,
     activated,
     activationPromise,
@@ -4078,13 +4819,14 @@ function createFormStore(options) {
     activeValidations,
     firstValidationDone,
     pathHasAsyncValidation,
+    pathHasAsyncValidationByKey,
     fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
+    arrayElementKey,
     reset,
     resetField,
-    clear,
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
@@ -4097,10 +4839,12 @@ function createFormStore(options) {
     registerElement,
     deregisterElement,
     markFocused,
-    markTouched,
+    markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    isPristineAtPathByKey,
+    hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -4116,7 +4860,6 @@ function createFormStore(options) {
     modules,
     persistOptIns,
     isSensitivePath: resolvedIsSensitivePath,
-    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
     noSyncPaths,
     incrementNoSyncOptOut,
     decrementNoSyncOptOut,
@@ -4317,939 +5060,988 @@ function createHistoryModule(state, config) {
   };
 }
 
-function hashStableString(input, seed = 0) {
-  let h1 = 3735928559 ^ seed;
-  let h2 = 1103547991 ^ seed;
-  for (let i = 0; i < input.length; i++) {
-    const ch = input.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  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 isFileLikeValue(value) {
-  if (typeof File !== "undefined" && value instanceof File) return true;
-  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
-  return false;
-}
-function isDangerousSegment(s) {
-  return s === "__proto__" || s === "constructor" || s === "prototype";
-}
-function pathContainsDangerousSegment(path) {
-  for (let i = 0; i < path.length; i++) {
-    if (isDangerousSegment(path[i])) return true;
-  }
-  return false;
-}
-function isInboundShapeAcceptable(schema, path, value) {
-  if (isFileLikeValue(value)) return false;
-  let kind;
-  if (Array.isArray(value)) {
-    kind = "array";
-  } else if (value !== null && typeof value === "object" && isPlainRecord(value)) {
-    kind = "object";
-  } else {
-    kind = slimKindOf(value);
-  }
-  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
-  if (!accepted.has(kind)) return false;
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      if (!isInboundShapeAcceptable(schema, [...path, i], value[i])) return false;
-    }
-    return true;
-  }
-  if (isPlainRecord(value)) {
-    for (const key of Object.keys(value)) {
-      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
+function wirePersistence(state, config) {
+  let fingerprint;
+  try {
+    fingerprint = hashStableString(state.schema.fingerprint());
+  } catch (err) {
+    if (paths.__DEV__) {
+      console.warn(
+        `[attaform] Could not fingerprint the schema for form '${state.formKey}': ${err instanceof Error ? err.message : String(err)}. Persistence falls back to a fingerprint-free key, so a schema change won't auto-invalidate a saved draft.`
+      );
     }
-    return true;
+    fingerprint = "unfingerprinted";
   }
-  return true;
-}
-function diffBlankPaths(prev, curr) {
-  const added = [];
-  const removed = [];
-  const prevSet = new Set(prev);
-  for (const k of curr) if (!prevSet.has(k)) added.push(k);
-  for (const k of prev) if (!curr.has(k)) removed.push(k);
-  return { added, removed };
-}
-function snapshotForm(form) {
-  return structuralSnapshot(form);
-}
-function stripSensitivePathsDeep(value, pathSoFar, isSensitivePath) {
-  if (isFileLikeValue(value)) return void 0;
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) {
-    return value.map((item, i) => stripSensitivePathsDeep(item, [...pathSoFar, i], isSensitivePath));
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== Object.prototype && proto !== null) return value;
-  const out = {};
-  const src = value;
-  for (const key of Object.keys(src)) {
-    const childPath = [...pathSoFar, key];
-    if (isSensitivePath(childPath)) {
-      out[key] = void 0;
-      continue;
-    }
-    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";
+  const base = resolveStorageKeyBase(config, state.formKey);
+  const key = `${base}:${fingerprint}`;
+  const debounceMs = normalizeNumericOption({
+    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,
+    source: "useForm.persist.debounceMs",
+    allowInfinity: false,
+    min: 0,
+    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS
+  });
+  const include = config.include ?? "form";
+  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
+  const adapterPromise = getStorageAdapter(config.storage);
   let disposed = false;
-  const peerIds = /* @__PURE__ */ new Set();
-  let joinCollectionTimer = null;
-  let snapshotTimeoutTimer = null;
-  let leaderAttempts = 0;
-  let prior = {
-    form: snapshotForm(state.form.value),
-    blankPathsSnapshot: [...state.blankPaths]
-  };
-  function safePost(msg) {
-    if (disposed) return;
-    try {
-      channel.postMessage(msg);
-    } catch {
-    }
-  }
-  function refreshPrior() {
-    prior = {
-      form: snapshotForm(state.form.value),
-      blankPathsSnapshot: [...state.blankPaths]
-    };
-  }
-  function isPathLocallySuppressed(path) {
-    if (pathContainsDangerousSegment(path)) return true;
-    if (options.isSensitivePath(path)) return true;
-    const { key } = paths.canonicalizePath([...path]);
-    if (options.noSyncPaths.has(key)) return true;
-    return false;
-  }
-  function postPatches() {
-    if (lifecycle !== "established") return;
-    const next = snapshotForm(state.form.value);
-    const rawPatches = [];
-    diffAndApply(prior.form, next, [], (p) => rawPatches.push(p));
-    const safePatches = [];
-    for (const p of rawPatches) {
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && isFileLikeValue(p.value)) continue;
-      safePatches.push(p);
-    }
-    const { added, removed } = diffBlankPaths(prior.blankPathsSnapshot, state.blankPaths);
-    if (safePatches.length === 0 && added.length === 0 && removed.length === 0) {
-      prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
+  const isDisposed = () => disposed;
+  let inFlightFinalFlush = null;
+  let pendingOptedInPaths = null;
+  const writer = createDebouncedWriter(async () => {
+    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
+    pendingOptedInPaths = null;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    if (optedInPaths.size === 0) {
+      await adapter.removeItem(key);
       return;
     }
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "patches",
-      senderId,
-      formPatches: safePatches,
-      blankPathsAdded: added,
-      blankPathsRemoved: removed
-    });
-    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
-  }
+    const rawForm = vue.toRaw(state.form.value);
+    const filteredForm = stripUnacknowledgedSensitiveLeaves(
+      pluckPaths(rawForm, optedInPaths),
+      optedInPaths,
+      state.isSensitivePath
+    );
+    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
+    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
+    const filteredTransientEmpty = /* @__PURE__ */ new Set();
+    for (const tk of state.blankPaths) {
+      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
+    }
+    const payload = buildPersistedPayload(
+      filteredForm,
+      include,
+      filteredSchemaErrors,
+      filteredUserErrors,
+      filteredTransientEmpty
+    );
+    await adapter.setItem(key, payload);
+  }, debounceMs);
   const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (disposed) return;
-    if (lifecycle !== "established") return;
+    if (isDisposed() || inFlightFinalFlush !== null) return;
     if (meta?.crossTab === true) return;
-    if (meta?.hydration === true) {
-      refreshPrior();
-      return;
-    }
-    postPatches();
+    if (meta?.persist !== true) return;
+    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
+    writer.schedule();
   });
-  function applyIncomingForm(form, blankPaths) {
-    state.blankPaths.clear();
-    for (const k of blankPaths) state.blankPaths.add(k);
-    state.applyFormReplacement(form, { crossTab: true, persist: false });
-    refreshPrior();
+  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
+    if (isDisposed()) return;
+    void (async () => {
+      await writer.flush();
+      if (isDisposed()) return;
+      const adapter = await adapterPromise;
+      if (isDisposed()) return;
+      await adapter.removeItem(key);
+    })();
+  }) : () => void 0;
+  const handlePageHide = () => {
+    if (isDisposed()) return;
+    void writer.flush();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("pagehide", handlePageHide);
   }
-  function handlePatches(msg) {
-    if (lifecycle !== "established") return;
-    const safePatches = [];
-    for (const p of msg.formPatches) {
-      if (!Array.isArray(p.path)) continue;
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && !isInboundShapeAcceptable(state.schema, p.path, p.value)) {
-        continue;
-      }
-      safePatches.push(p);
-    }
-    const safeBlankAdded = [];
-    for (const k of msg.blankPathsAdded) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
-    }
-    const safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
-    }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
-      return;
-    }
-    const candidate = applyPatchesForward(state.form.value, safePatches);
+  void (async () => {
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    void cleanupOrphanKeys(adapter, base, key);
     try {
-      options.validateForm(state.form.value);
-      try {
-        options.validateForm(candidate);
-      } catch {
+      const raw = await adapter.getItem(key);
+      const payload = readPersistedPayload(raw);
+      if (payload === null) {
+        if (raw !== null && raw !== void 0) {
+          await adapter.removeItem(key);
+        }
         return;
       }
+      if (isDisposed()) return;
+      const merged = mergeSparseHydration(
+        vue.toRaw(state.form.value),
+        payload.data.form,
+        state.schema
+      );
+      state.applyFormReplacement(merged, { hydration: true });
+      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
+      for (const k of persistedLeafPaths) {
+        state.blankPaths.delete(k);
+        state.originalBlankPaths.delete(k);
+      }
+      for (const k of payload.data.blankPaths ?? []) {
+        state.blankPaths.add(k);
+        state.originalBlankPaths.add(k);
+      }
+      if (include === "form+errors") {
+        if (payload.data.schemaErrors !== void 0) {
+          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
+          state.setAllSchemaErrors(flat);
+        }
+        if (payload.data.userErrors !== void 0) {
+          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
+          state.setAllUserErrors(flat);
+        }
+      }
+      state.scheduleFieldValidation(
+        [],
+        true
+        /* immediate */
+      );
     } catch {
     }
-    const nextBlankPaths = new Set(state.blankPaths);
-    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
-    for (const k of safeBlankAdded) nextBlankPaths.add(k);
-    applyIncomingForm(candidate, [...nextBlankPaths]);
-  }
-  function handleSnapshot(msg) {
-    if (lifecycle !== "joining") return;
-    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
-    if (snapshotTimeoutTimer !== null) {
-      clearTimeout(snapshotTimeoutTimer);
-      snapshotTimeoutTimer = null;
+  })();
+  async function writePathImmediately(path) {
+    if (isDisposed()) return;
+    await writer.flush();
+    if (isDisposed()) return;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    const baseForm = existing?.data.form ?? /* @__PURE__ */ Object.create(null);
+    const value = getAtPath(vue.toRaw(state.form.value), path);
+    const nextForm = setAtPath(baseForm, path, value);
+    const { key: pathKey } = paths.canonicalizePath(path);
+    const transientSet = new Set(
+      (existing?.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    for (const liveKey of state.blankPaths) {
+      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
+        transientSet.add(liveKey);
+      }
     }
-    if (joinCollectionTimer !== null) {
-      clearTimeout(joinCollectionTimer);
-      joinCollectionTimer = null;
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
+      return;
     }
-    applyIncomingForm(msg.form, msg.blankPaths);
-    lifecycle = "established";
-    peerIds.clear();
-  }
-  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]
-    });
+    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
+    const userMap = new Map(existing?.data.userErrors ?? []);
+    const currentSchema = state.schemaErrors.get(pathKey);
+    const currentUser = state.userErrors.get(pathKey);
+    if (currentSchema !== void 0 && currentSchema.length > 0) {
+      schemaMap.set(pathKey, [...currentSchema]);
+    } else {
+      schemaMap.delete(pathKey);
+    }
+    if (currentUser !== void 0 && currentUser.length > 0) {
+      userMap.set(pathKey, [...currentUser]);
+    } else {
+      userMap.delete(pathKey);
+    }
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
   }
-  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;
+  async function clearPersistedDraft(path) {
+    if (isDisposed()) return;
+    await writer.flush();
+    if (isDisposed()) return;
+    const adapter = await adapterPromise;
+    if (isDisposed()) return;
+    if (path === void 0) {
+      await adapter.removeItem(key);
+      return;
     }
-  };
-  function electLeaderAndRequest() {
-    if (disposed) return;
-    if (peerIds.size === 0) {
-      lifecycle = "established";
-      refreshPrior();
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    if (existing === null) return;
+    const nextForm = deleteAtPath(existing.data.form, path);
+    if (isEmptyContainer(nextForm)) {
+      await adapter.removeItem(key);
       return;
     }
-    const 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);
+    const { key: pathKey } = paths.canonicalizePath(path);
+    const transientSet = new Set(
+      (existing.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
+      return;
+    }
+    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
+    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
+    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
+    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
   }
-  function joinFlow() {
-    safePost({ v: PROTOCOL_VERSION, kind: "hello", senderId });
-    joinCollectionTimer = setTimeout(() => {
-      joinCollectionTimer = null;
-      if (disposed) return;
-      if (lifecycle === "established") return;
-      electLeaderAndRequest();
-    }, JOIN_COLLECTION_WINDOW_MS);
+  function awaitPendingWrites() {
+    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
+    if (isDisposed()) return Promise.resolve();
+    return writer.flush().catch(() => void 0);
   }
-  joinFlow();
-  return {
-    dispose: () => {
-      if (disposed) return;
+  function dispose() {
+    if (isDisposed() || inFlightFinalFlush !== null) return;
+    unsubscribeChange();
+    unsubscribeSuccess();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", handlePageHide);
+    }
+    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
       disposed = true;
-      if (joinCollectionTimer !== null) {
-        clearTimeout(joinCollectionTimer);
-        joinCollectionTimer = null;
-      }
-      if (snapshotTimeoutTimer !== null) {
-        clearTimeout(snapshotTimeoutTimer);
-        snapshotTimeoutTimer = null;
-      }
-      unsubscribeChange();
-      try {
-        channel.close();
-      } catch {
-      }
-    },
-    lifecycle: () => lifecycle,
-    senderId,
-    channelName
+      inFlightFinalFlush = null;
+    });
+  }
+  return {
+    wiredConfig: config,
+    writePathImmediately,
+    clearPersistedDraft,
+    awaitPendingWrites,
+    dispose
   };
 }
-const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
-
-const warned = /* @__PURE__ */ new Set();
-function warnOnceInsecureContext(feature) {
-  if (!paths.__DEV__) return;
-  if (warned.has(feature)) return;
-  warned.add(feature);
-  const message = featureMessage(feature);
-  console.warn(`[attaform] ${message}`);
+function isEmptyContainer(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainRecord(value)) return Object.keys(value).length === 0;
+  return false;
 }
-function featureMessage(feature) {
-  switch (feature) {
-    case "multiTab":
-      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
-    case "persist:local":
-      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
-    case "persist:session":
-      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+function collectPersistedLeafPaths(form) {
+  const out = [];
+  walk(form, []);
+  return out;
+  function walk(node, prefix) {
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        walk(node[i], [...prefix, i]);
+      }
+      return;
+    }
+    if (isPlainRecord(node)) {
+      for (const key of Object.keys(node)) {
+        walk(node[key], [...prefix, key]);
+      }
+      return;
+    }
+    if (prefix.length === 0) return;
+    out.push(paths.canonicalizePath(prefix).key);
   }
 }
-function isSecureContext() {
-  return typeof window !== "undefined" && window.isSecureContext === true;
+function isDescendantPathKey(candidate, ancestor) {
+  if (candidate.length <= ancestor.length) return false;
+  if (!ancestor.endsWith("]")) return false;
+  const childPrefix = `${ancestor.slice(0, -1)},`;
+  return candidate.startsWith(childPrefix);
 }
 
-function resolveTrichotomy(input) {
-  if (typeof input === "function") {
-    return { kind: "async", factory: input };
-  }
-  return { kind: "sync", value: input };
+const PROTOCOL_VERSION = 1;
+const JOIN_COLLECTION_WINDOW_MS = 50;
+const SNAPSHOT_TIMEOUT_MS = 200;
+const MAX_LEADER_ATTEMPTS = 3;
+const SNAPSHOT_RESPONSE_MIN_INTERVAL_MS = 500;
+function isFileLikeValue(value) {
+  if (typeof File !== "undefined" && value instanceof File) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return false;
 }
-
-function useAbstractForm(configuration, options) {
-  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new paths.InvalidUseFormConfigError();
+function isInboundShapeAcceptable(schema, path, value) {
+  if (isFileLikeValue(value)) return false;
+  let kind;
+  if (Array.isArray(value)) {
+    kind = "array";
+  } else if (value !== null && typeof value === "object" && isPlainRecord(value)) {
+    kind = "object";
+  } else {
+    kind = slimKindOf(value);
   }
-  const key = resolveFormKey(configuration.key);
-  const instance = vue.getCurrentInstance();
-  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
-  const registry = options?.registry ?? paths.useRegistry();
-  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
-  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
-  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
-  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
-  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
-  const maxRecursionDepth = normalizeNumericOption({
-    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
-    source: "useForm.maxRecursionDepth",
-    allowInfinity: true,
-    min: 0,
-    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
-  });
-  const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
-  if (configuration.persist !== void 0 && configuration.key === void 0) {
-    throw new paths.AnonPersistError({
-      cause: "no-key",
-      schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: paths.captureUserCallSite()
-    });
-  }
-  const existing = registry.forms.get(key);
-  if (paths.__DEV__ && existing !== void 0) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
-  }
-  const hadPendingHydration = registry.pendingHydration.has(key);
-  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
-  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
-    state.defaultsResolved.value = true;
-  }
-  if (existing === void 0 && resolvedDefaults.kind === "async") {
-    const factory = resolvedDefaults.factory;
-    state.defaultValuesFactory.value = factory;
-    if (hadPendingHydration) {
-      state.hydrating.value = false;
-      state.defaultsResolved.value = true;
-    } else if (registry.ssr) {
-      if (configuration.__ssrAccessed === true) {
-        registry.enqueuePrefetch(key);
-      }
-      vue.onServerPrefetch(() => {
-        if (!registry.shouldPrefetch(key)) return;
-        return state.activate();
-      });
-    }
-  }
-  if (vue.getCurrentScope() !== void 0) {
-    const releaseConsumer = registry.trackConsumer(key);
-    vue.onScopeDispose(releaseConsumer);
-  }
-  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
-  if (existing === void 0 && !registry.ssr) {
-    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
-      const resolvedPersist = normalizePersistConfig(merged.persist);
-      const storageKind = resolvedPersist.storage;
-      const isBuiltinStorage = typeof storageKind === "string";
-      const secureContextOk = !isBuiltinStorage || isSecureContext();
-      if (!secureContextOk) {
-        const feature = storageKind === "session" ? "persist:session" : "persist:local";
-        warnOnceInsecureContext(feature);
-        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
-      } else {
-        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
-        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
-        const persistenceModule = wirePersistence(state, resolvedPersist);
-        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
-        state.registerDrain(() => persistenceModule.awaitPendingWrites());
-        state.registerCleanup(() => persistenceModule.dispose());
-      }
-    } else {
-      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
+  if (!accepted.has(kind)) return false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if (!isInboundShapeAcceptable(schema, [...path, i], value[i])) return false;
     }
+    return true;
   }
-  if (existing === void 0 && merged.multiTab === true && configuration.key !== void 0 && !registry.ssr) {
-    const hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
-    const secureContext = isSecureContext();
-    if (hasBroadcastChannel && secureContext) {
-      let channelName;
-      try {
-        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
-      } catch {
-        channelName = null;
-      }
-      if (channelName !== null) {
-        const syncModule = createMultiTabSyncModule(state, channelName, {
-          isSensitivePath: state.isSensitivePath,
-          noSyncPaths: state.noSyncPaths,
-          validateForm: (form) => {
-            const result = state.schema.validateAtPath(form, void 0, { sync: true });
-            if (result instanceof Promise) return;
-            if (!result.success) {
-              throw new Error("attaform multi-tab sync: post-apply schema validation failed");
-            }
-          }
-        });
-        state.modules.set(MULTI_TAB_SYNC_MODULE_KEY, syncModule);
-        state.registerCleanup(() => syncModule.dispose());
-      }
-    } else if (hasBroadcastChannel && !secureContext) {
-      warnOnceInsecureContext("multiTab");
+  if (isPlainRecord(value)) {
+    for (const key of Object.keys(value)) {
+      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
     }
+    return true;
   }
-  if (existing === void 0 && merged.history !== void 0) {
-    const historyModule = createHistoryModule(state, merged.history);
-    state.modules.set(HISTORY_MODULE_KEY, historyModule);
-    state.registerCleanup(() => historyModule.dispose());
+  return true;
+}
+function diffBlankPaths(prev, curr) {
+  const added = [];
+  const removed = [];
+  const prevSet = new Set(prev);
+  for (const k of curr) if (!prevSet.has(k)) added.push(k);
+  for (const k of prev) if (!curr.has(k)) removed.push(k);
+  return { added, removed };
+}
+function snapshotForm(form) {
+  return structuralSnapshot(form);
+}
+function stripSensitivePathsDeep(value, pathSoFar, isSensitivePath) {
+  if (isFileLikeValue(value)) return void 0;
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map((item, i) => stripSensitivePathsDeep(item, [...pathSoFar, i], isSensitivePath));
   }
-  if (configuration.key === void 0) {
-    recordAmbientProvide(registry.ssr);
-    vue.provide(paths.kFormContext, state);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  const out = /* @__PURE__ */ Object.create(null);
+  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);
   }
-  const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
-  if (vue.getCurrentInstance() !== null) {
-    vue.provide(paths.kFormInstanceId, formInstanceId);
+  return out;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isPatchArray(value) {
+  return Array.isArray(value) && value.every(
+    (p) => p !== null && typeof p === "object" && Array.isArray(p.path)
+  );
+}
+function isValidSyncMessage(data) {
+  if (data === null || typeof data !== "object") return false;
+  const m = data;
+  if (m["v"] !== PROTOCOL_VERSION) return false;
+  if (typeof m["senderId"] !== "string") return false;
+  if (typeof m["kind"] !== "string") return false;
+  switch (m["kind"]) {
+    case "hello":
+    case "announce":
+      return true;
+    case "requestSnapshot":
+      return typeof m["targetId"] === "string";
+    case "snapshot":
+      return isStringArray(m["blankPaths"]) && "form" in m;
+    case "patches":
+      return isPatchArray(m["formPatches"]) && isStringArray(m["blankPathsAdded"]) && isStringArray(m["blankPathsRemoved"]);
+    default:
+      return false;
   }
-  const apiOptions = {};
-  if (merged.onInvalidSubmit !== void 0) {
-    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+}
+function generateSenderId() {
+  try {
+    return globalThis.crypto.randomUUID();
+  } catch {
+    return `atta-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
   }
-  const history = state.modules.get(HISTORY_MODULE_KEY);
-  if (history !== void 0) {
-    apiOptions.history = history;
+}
+function createMultiTabSyncModule(state, channelName, options) {
+  if (typeof BroadcastChannel === "undefined") {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  if (merged.validateOn !== void 0) {
-    apiOptions.validateOn = merged.validateOn;
+  let channel;
+  try {
+    channel = new BroadcastChannel(channelName);
+  } catch {
+    return {
+      dispose: () => void 0,
+      lifecycle: () => "established",
+      senderId: "",
+      channelName
+    };
   }
-  const mergedDebounceMs = merged.debounceMs;
-  if (mergedDebounceMs !== void 0) {
-    apiOptions.debounceMs = mergedDebounceMs;
+  const senderId = generateSenderId();
+  let lifecycle = "joining";
+  let disposed = false;
+  const peerIds = /* @__PURE__ */ new Set();
+  const lastSnapshotResponseAt = /* @__PURE__ */ new Map();
+  let joinCollectionTimer = null;
+  let snapshotTimeoutTimer = null;
+  let leaderAttempts = 0;
+  let prior = {
+    form: snapshotForm(state.form.value),
+    blankPathsSnapshot: [...state.blankPaths]
+  };
+  function safePost(msg) {
+    if (disposed) return;
+    try {
+      channel.postMessage(msg);
+    } catch {
+    }
   }
-  if (merged.shouldShowErrors !== void 0) {
-    apiOptions.shouldShowErrors = resolveShouldShowErrors(merged.shouldShowErrors);
+  function refreshPrior() {
+    prior = {
+      form: snapshotForm(state.form.value),
+      blankPathsSnapshot: [...state.blankPaths]
+    };
   }
-  if (merged.coerce !== void 0) {
-    apiOptions.coerce = merged.coerce;
+  function isPathLocallySuppressed(path) {
+    if (options.isSensitivePath(path)) return true;
+    const { key } = paths.canonicalizePath([...path]);
+    if (options.noSyncPaths.has(key)) return true;
+    return false;
   }
-  if (merged.rememberVariants !== void 0) {
-    apiOptions.rememberVariants = merged.rememberVariants;
+  function postPatches() {
+    if (lifecycle !== "established") return;
+    const next = snapshotForm(state.form.value);
+    const rawPatches = [];
+    diffAndApply(prior.form, next, [], (p) => rawPatches.push(p));
+    const safePatches = [];
+    for (const p of rawPatches) {
+      if (isPathLocallySuppressed(p.path)) continue;
+      if ("value" in p && isFileLikeValue(p.value)) continue;
+      safePatches.push(p);
+    }
+    const { added, removed } = diffBlankPaths(prior.blankPathsSnapshot, state.blankPaths);
+    if (safePatches.length === 0 && added.length === 0 && removed.length === 0) {
+      prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
+      return;
+    }
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "patches",
+      senderId,
+      formPatches: safePatches,
+      blankPathsAdded: added,
+      blankPathsRemoved: removed
+    });
+    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
   }
-  return buildFormApi(
-    state,
-    formInstanceId,
-    apiOptions
-  );
-}
-function mergeWithDefaults(defaults, configuration) {
-  const strict = configuration.strict ?? defaults.strict;
-  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
-  const history = configuration.history ?? defaults.history;
-  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
-  const coerce = configuration.coerce ?? defaults.coerce;
-  const validateOn = configuration.validateOn ?? defaults.validateOn;
-  const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
-  const 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 },
-    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
-    ...history === void 0 ? {} : { history },
-    ...rememberVariants === void 0 ? {} : { rememberVariants },
-    ...coerce === void 0 ? {} : { coerce },
-    ...validateOn === void 0 ? {} : { validateOn },
-    ...debounceMs === void 0 ? {} : { debounceMs },
-    ...shouldShowErrors === void 0 ? {} : { shouldShowErrors },
-    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
-    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
-    ...multiTab === void 0 ? {} : { multiTab }
-  };
-}
-const HISTORY_MODULE_KEY = "history";
-function buildFreshState(key, schema, configuration, registry) {
-  const pending = registry.pendingHydration.get(key);
-  if (pending !== void 0) registry.pendingHydration.delete(key);
-  const walked = walkUnsetSentinels(
-    configuration.defaultValues,
-    schema
-  );
-  let initialBlankPaths;
-  if (pending === void 0) {
-    initialBlankPaths = walked.paths;
+  const 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();
   }
-  const resolvedSensitiveNames = configuration.sensitiveNames;
-  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : paths.createIsSensitivePath(resolvedSensitiveNames);
-  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : paths.createSegmentMatchesSensitive(resolvedSensitiveNames);
-  const createOptions = {
-    formKey: key,
-    schema,
-    defaultValues: walked.cleanedValues,
-    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
-    hydration: pending,
-    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
-    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
-    ssr: registry.ssr,
-    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
-    // records intent on every `state.activate()` so a wizard skip-list
-    // override or a future transform mark has a consistent set to diff
-    // against; `shouldFire` lets the activate path bail when the
-    // wizard explicitly skipped this key — even an explicit
-    // `form.activate()` defers to the wizard's render-efficiency
-    // skip-list on the server.
-    ...registry.ssr ? {
-      ssrPrefetch: {
-        enqueue: () => {
-          registry.enqueuePrefetch(key);
-        },
-        shouldFire: () => registry.shouldPrefetch(key)
+  function handlePatches(msg) {
+    if (lifecycle !== "established") return;
+    const safePatches = [];
+    for (const p of msg.formPatches) {
+      if (!Array.isArray(p.path)) continue;
+      if (isPathLocallySuppressed(p.path)) continue;
+      if ("value" in p && !isInboundShapeAcceptable(state.schema, p.path, p.value)) {
+        continue;
       }
-    } : {},
-    ...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 } : {},
-    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {},
-    ...resolvedSegmentMatchesSensitive !== void 0 ? { segmentMatchesSensitive: resolvedSegmentMatchesSensitive } : {}
-  };
-  const state = createFormStore(createOptions);
-  registry.forms.set(
-    key,
-    state
-  );
-  return state;
-}
-let anonCounter = 0;
-let formInstanceCounter = 0;
-const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(ssr) {
-  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
-  const instance = vue.getCurrentInstance();
-  if (instance === null) return;
-  const instanceKey = instance;
-  const entry = {
-    source: paths.captureUserCallSite()
-  };
-  const existing = ambientProvideHistory.get(instanceKey);
-  if (existing === void 0) {
-    ambientProvideHistory.set(instanceKey, [entry]);
-    return;
-  }
-  existing.push(entry);
-}
-function resolveFormKey(key) {
-  if (key !== void 0 && key !== null && key !== "") {
-    if (key.startsWith(RESERVED_KEY_PREFIX)) {
-      throw new paths.ReservedFormKeyError(key);
+      safePatches.push(p);
     }
-    return key;
+    const safeBlankAdded = [];
+    for (const k of msg.blankPathsAdded) {
+      const segs = paths.canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankAdded.push(k);
+    }
+    const safeBlankRemoved = [];
+    for (const k of msg.blankPathsRemoved) {
+      const segs = paths.canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankRemoved.push(k);
+    }
+    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+      return;
+    }
+    const candidate = applyPatchesForward(state.form.value, safePatches);
+    try {
+      options.validateForm(state.form.value);
+      try {
+        options.validateForm(candidate);
+      } catch {
+        return;
+      }
+    } catch {
+    }
+    const nextBlankPaths = new Set(state.blankPaths);
+    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
+    for (const k of safeBlankAdded) nextBlankPaths.add(k);
+    applyIncomingForm(candidate, [...nextBlankPaths]);
   }
-  if (vue.getCurrentInstance() !== null) {
-    return `${ANONYMOUS_FORM_KEY_PREFIX}${vue.useId()}`;
+  function handleSnapshot(msg) {
+    if (lifecycle !== "joining") return;
+    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
+    if (snapshotTimeoutTimer !== null) {
+      clearTimeout(snapshotTimeoutTimer);
+      snapshotTimeoutTimer = null;
+    }
+    if (joinCollectionTimer !== null) {
+      clearTimeout(joinCollectionTimer);
+      joinCollectionTimer = null;
+    }
+    applyIncomingForm(msg.form, msg.blankPaths);
+    lifecycle = "established";
+    peerIds.clear();
   }
-  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
-}
-function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
-  let existingFp;
-  let incomingFp;
-  try {
-    existingFp = existing.fingerprint();
-    incomingFp = incoming.fingerprint();
-  } catch (error) {
-    console.error(
-      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
-      error
-    );
-    return;
+  function respondToHello() {
+    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
   }
-  if (existingFp === incomingFp) return;
-  console.warn(
-    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
-  existing: ${existingFp}
-  incoming: ${incomingFp}`
-  );
-}
-function warnOnPersistDivergence(key, existing, incomingPersist) {
-  if (incomingPersist === void 0) return;
-  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
-  const incomingNormalized = normalizePersistConfig(incomingPersist);
-  if (wired === void 0) {
-    console.warn(
-      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
-    );
-    return;
+  function respondToSnapshotRequest(requesterId) {
+    const now = Date.now();
+    const last = lastSnapshotResponseAt.get(requesterId);
+    if (last !== void 0 && now - last < SNAPSHOT_RESPONSE_MIN_INTERVAL_MS) return;
+    lastSnapshotResponseAt.set(requesterId, now);
+    const scrubbedForm = stripSensitivePathsDeep(state.form.value, [], options.isSensitivePath);
+    safePost({
+      v: PROTOCOL_VERSION,
+      kind: "snapshot",
+      senderId,
+      form: scrubbedForm,
+      blankPaths: [...state.blankPaths]
+    });
   }
-  if (persistConfigsEquivalent(wired.wiredConfig, incomingNormalized)) return;
-  console.warn(
-    `[attaform] useForm({ key: "${key}" }) passed a persist config that differs from the first useForm({ key }) call's; first wins, this one is ignored.
-  wired:    ${describePersist(wired.wiredConfig)}
-  incoming: ${describePersist(incomingNormalized)}`
-  );
-}
-function persistConfigsEquivalent(a, b) {
-  if (a.storage !== b.storage) return false;
-  if ((a.key ?? void 0) !== (b.key ?? void 0)) return false;
-  if ((a.debounceMs ?? void 0) !== (b.debounceMs ?? void 0)) return false;
-  return true;
-}
-function describePersist(config) {
-  const storage = typeof config.storage === "string" ? config.storage : "custom-adapter";
-  const parts = [`storage=${storage}`];
-  if (config.key !== void 0) parts.push(`key=${config.key}`);
-  if (config.debounceMs !== void 0) parts.push(`debounceMs=${config.debounceMs}`);
-  return `{ ${parts.join(", ")} }`;
-}
-function wirePersistence(state, config) {
-  const fingerprint = hashStableString(state.schema.fingerprint());
-  const base = resolveStorageKeyBase(config, state.formKey);
-  const key = `${base}:${fingerprint}`;
-  const debounceMs = normalizeNumericOption({
-    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,
-    source: "useForm.persist.debounceMs",
-    allowInfinity: false,
-    min: 0,
-    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS
-  });
-  const include = config.include ?? "form";
-  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
-  const adapterPromise = getStorageAdapter(config.storage);
-  let disposed = false;
-  let inFlightFinalFlush = null;
-  let pendingOptedInPaths = null;
-  const writer = createDebouncedWriter(async () => {
-    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
-    pendingOptedInPaths = null;
-    const adapter = await adapterPromise;
+  channel.onmessage = (event) => {
     if (disposed) return;
-    if (optedInPaths.size === 0) {
-      await adapter.removeItem(key);
-      return;
+    try {
+      const data = event.data;
+      if (!isValidSyncMessage(data)) return;
+      const msg = data;
+      if (msg.senderId === senderId) return;
+      switch (msg.kind) {
+        case "hello":
+          if (lifecycle !== "established") return;
+          respondToHello();
+          break;
+        case "announce":
+          if (lifecycle === "joining") peerIds.add(msg.senderId);
+          break;
+        case "requestSnapshot":
+          if (lifecycle !== "established") return;
+          if (msg.targetId !== senderId) return;
+          respondToSnapshotRequest(msg.senderId);
+          break;
+        case "snapshot":
+          handleSnapshot(msg);
+          break;
+        case "patches":
+          handlePatches(msg);
+          break;
+      }
+    } catch {
     }
-    const rawForm = vue.toRaw(state.form.value);
-    const filteredForm = pluckPaths(rawForm, optedInPaths);
-    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
-    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
-    const filteredTransientEmpty = /* @__PURE__ */ new Set();
-    for (const tk of state.blankPaths) {
-      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
-    }
-    const payload = buildPersistedPayload(
-      filteredForm,
-      include,
-      filteredSchemaErrors,
-      filteredUserErrors,
-      filteredTransientEmpty
-    );
-    await adapter.setItem(key, payload);
-  }, debounceMs);
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (disposed || inFlightFinalFlush !== null) return;
-    if (meta?.crossTab === true) return;
-    if (meta?.persist !== true) return;
-    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
-    writer.schedule();
-  });
-  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
+  };
+  function electLeaderAndRequest() {
     if (disposed) return;
-    void (async () => {
-      await writer.flush();
-      if (disposed) return;
-      const adapter = await adapterPromise;
+    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;
-      await adapter.removeItem(key);
-    })();
-  }) : () => void 0;
-  void (async () => {
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    void cleanupOrphanKeys(adapter, base, key);
-    try {
-      const raw = await adapter.getItem(key);
-      const payload = readPersistedPayload(raw);
-      if (payload === null) {
-        if (raw !== null && raw !== void 0) {
-          await adapter.removeItem(key);
-        }
+      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;
-      const merged = mergeSparseHydration(
-        vue.toRaw(state.form.value),
-        payload.data.form,
-        state.schema
-      );
-      state.applyFormReplacement(merged, { hydration: true });
-      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
-      for (const k of persistedLeafPaths) {
-        state.blankPaths.delete(k);
-        state.originalBlankPaths.delete(k);
+      if (lifecycle === "established") return;
+      electLeaderAndRequest();
+    }, JOIN_COLLECTION_WINDOW_MS);
+  }
+  joinFlow();
+  return {
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      if (joinCollectionTimer !== null) {
+        clearTimeout(joinCollectionTimer);
+        joinCollectionTimer = null;
       }
-      for (const k of payload.data.blankPaths ?? []) {
-        const key2 = paths.coerceToPathKey(k);
-        state.blankPaths.add(key2);
-        state.originalBlankPaths.add(key2);
+      if (snapshotTimeoutTimer !== null) {
+        clearTimeout(snapshotTimeoutTimer);
+        snapshotTimeoutTimer = null;
       }
-      if (include === "form+errors") {
-        if (payload.data.schemaErrors !== void 0) {
-          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
-          state.setAllSchemaErrors(flat);
-        }
-        if (payload.data.userErrors !== void 0) {
-          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
-          state.setAllUserErrors(flat);
-        }
+      unsubscribeChange();
+      try {
+        channel.close();
+      } catch {
       }
-      state.scheduleFieldValidation(
-        [],
-        true
-        /* immediate */
-      );
-    } catch {
-    }
-  })();
-  async function writePathImmediately(path) {
-    if (disposed) return;
-    await writer.flush();
-    if (disposed) return;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    const baseForm = existing?.data.form ?? {};
-    const value = getAtPath(vue.toRaw(state.form.value), path);
-    const nextForm = setAtPath(baseForm, path, value);
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing?.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    for (const liveKey of state.blankPaths) {
-      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
-        transientSet.add(liveKey);
+    },
+    lifecycle: () => lifecycle,
+    senderId,
+    channelName
+  };
+}
+const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+
+const warned = /* @__PURE__ */ new Set();
+function warnOnceInsecureContext(feature) {
+  if (!paths.__DEV__) return;
+  if (warned.has(feature)) return;
+  warned.add(feature);
+  const message = featureMessage(feature);
+  console.warn(`[attaform] ${message}`);
+}
+function featureMessage(feature) {
+  switch (feature) {
+    case "multiTab":
+      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
+    case "persist:local":
+      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+    case "persist:session":
+      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+  }
+}
+function isSecureContext() {
+  return typeof window !== "undefined" && window.isSecureContext === true;
+}
+
+function resolveTrichotomy(input) {
+  if (typeof input === "function") {
+    return { kind: "async", factory: input };
+  }
+  return { kind: "sync", value: input };
+}
+
+function useAbstractForm(configuration, options) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new paths.InvalidUseFormConfigError();
+  }
+  const key = resolveFormKey(configuration.key);
+  const instance = vue.getCurrentInstance();
+  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? paths.useRegistry();
+  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
+  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
+  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
+  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
+  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
+  const maxRecursionDepth = normalizeNumericOption({
+    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
+    source: "useForm.maxRecursionDepth",
+    allowInfinity: true,
+    min: 0,
+    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
+  });
+  const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
+  if (configuration.persist !== void 0 && configuration.key === void 0) {
+    throw new paths.AnonPersistError({
+      cause: "no-key",
+      schemaFields: extractSchemaFields(resolvedSchema),
+      callSite: paths.captureUserCallSite()
+    });
+  }
+  const existing = registry.forms.get(key);
+  if (paths.__DEV__ && existing !== void 0) {
+    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+    warnOnPersistDivergence(key, existing, configuration.persist);
+  }
+  const hadPendingHydration = registry.pendingHydration.has(key);
+  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
+    state.defaultsResolved.value = true;
+  }
+  if (existing === void 0 && resolvedDefaults.kind === "async") {
+    const factory = resolvedDefaults.factory;
+    state.defaultValuesFactory.value = factory;
+    if (hadPendingHydration) {
+      state.hydrating.value = false;
+      state.defaultsResolved.value = true;
+    } else if (registry.ssr) {
+      if (configuration.__ssrAccessed === true) {
+        registry.enqueuePrefetch(key);
       }
+      vue.onServerPrefetch(() => {
+        if (!registry.shouldPrefetch(key)) return;
+        return state.activate();
+      });
     }
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
-    const userMap = new Map(existing?.data.userErrors ?? []);
-    const currentSchema = state.schemaErrors.get(pathKey);
-    const currentUser = state.userErrors.get(pathKey);
-    if (currentSchema !== void 0 && currentSchema.length > 0) {
-      schemaMap.set(pathKey, [...currentSchema]);
-    } else {
-      schemaMap.delete(pathKey);
-    }
-    if (currentUser !== void 0 && currentUser.length > 0) {
-      userMap.set(pathKey, [...currentUser]);
+  }
+  if (vue.getCurrentScope() !== void 0) {
+    const releaseConsumer = registry.trackConsumer(key);
+    vue.onScopeDispose(releaseConsumer);
+  }
+  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
+  if (existing === void 0 && !registry.ssr) {
+    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
+      const resolvedPersist = normalizePersistConfig(merged.persist);
+      const storageKind = resolvedPersist.storage;
+      const isBuiltinStorage = typeof storageKind === "string";
+      const secureContextOk = !isBuiltinStorage || isSecureContext();
+      if (!secureContextOk) {
+        const feature = storageKind === "session" ? "persist:session" : "persist:local";
+        warnOnceInsecureContext(feature);
+        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+      } else {
+        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
+        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
+        const persistenceModule = wirePersistence(state, resolvedPersist);
+        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
+        state.registerDrain(() => persistenceModule.awaitPendingWrites());
+        state.registerCleanup(() => persistenceModule.dispose());
+      }
     } else {
-      userMap.delete(pathKey);
+      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
     }
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
   }
-  async function clearPersistedDraft(path) {
-    if (disposed) return;
-    await writer.flush();
-    if (disposed) return;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    if (path === void 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    if (existing === null) return;
-    const nextForm = deleteAtPath(existing.data.form, path);
-    if (isEmptyContainer(nextForm)) {
-      await adapter.removeItem(key);
-      return;
+  if (existing === void 0 && merged.multiTab === true && configuration.key !== void 0 && !registry.ssr) {
+    const hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
+    const secureContext = isSecureContext();
+    if (hasBroadcastChannel && secureContext) {
+      let channelName;
+      try {
+        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
+      } catch {
+        channelName = null;
+      }
+      if (channelName !== null) {
+        const syncModule = createMultiTabSyncModule(state, channelName, {
+          isSensitivePath: state.isSensitivePath,
+          noSyncPaths: state.noSyncPaths,
+          validateForm: (form) => {
+            const result = state.schema.validateAtPath(form, void 0, { sync: true });
+            if (result instanceof Promise) return;
+            if (!result.success) {
+              throw new Error("attaform multi-tab sync: post-apply schema validation failed");
+            }
+          }
+        });
+        state.modules.set(MULTI_TAB_SYNC_MODULE_KEY, syncModule);
+        state.registerCleanup(() => syncModule.dispose());
+      }
+    } else if (hasBroadcastChannel && !secureContext) {
+      warnOnceInsecureContext("multiTab");
     }
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
+  }
+  if (existing === void 0 && merged.history !== void 0) {
+    const historyModule = createHistoryModule(state, merged.history);
+    state.modules.set(HISTORY_MODULE_KEY, historyModule);
+    state.registerCleanup(() => historyModule.dispose());
+  }
+  if (configuration.key === void 0) {
+    recordAmbientProvide(registry.ssr);
+    vue.provide(paths.kFormContext, state);
+  }
+  const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
+  if (vue.getCurrentInstance() !== null) {
+    vue.provide(paths.kFormInstanceId, formInstanceId);
+  }
+  const apiOptions = {};
+  if (merged.onInvalidSubmit !== void 0) {
+    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  }
+  const history = state.modules.get(HISTORY_MODULE_KEY);
+  if (history !== void 0) {
+    apiOptions.history = history;
+  }
+  if (merged.validateOn !== void 0) {
+    apiOptions.validateOn = merged.validateOn;
+  }
+  const mergedDebounceMs = merged.debounceMs;
+  if (mergedDebounceMs !== void 0) {
+    apiOptions.debounceMs = mergedDebounceMs;
+  }
+  if (merged.getDisplayState !== void 0) {
+    apiOptions.getDisplayState = merged.getDisplayState;
+  }
+  if (merged.coerce !== void 0) {
+    apiOptions.coerce = merged.coerce;
+  }
+  if (merged.rememberVariants !== void 0) {
+    apiOptions.rememberVariants = merged.rememberVariants;
+  }
+  if (merged.autoAria !== void 0) {
+    apiOptions.autoAria = merged.autoAria;
+  }
+  return buildFormApi(
+    state,
+    formInstanceId,
+    apiOptions
+  );
+}
+function mergeWithDefaults(defaults, configuration) {
+  const strict = configuration.strict ?? defaults.strict;
+  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
+  const history = configuration.history ?? defaults.history;
+  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
+  const coerce = configuration.coerce ?? defaults.coerce;
+  const validateOn = configuration.validateOn ?? defaults.validateOn;
+  const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
+  const getDisplayState = configuration.getDisplayState ?? defaults.getDisplayState;
+  const maxRecursionDepth = configuration.maxRecursionDepth ?? defaults.maxRecursionDepth;
+  const sensitiveNames = configuration.sensitiveNames ?? defaults.sensitiveNames;
+  const multiTab = configuration.multiTab ?? defaults.multiTab;
+  const autoAria = configuration.autoAria ?? defaults.autoAria;
+  return {
+    ...configuration,
+    ...strict === void 0 ? {} : { strict },
+    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
+    ...history === void 0 ? {} : { history },
+    ...rememberVariants === void 0 ? {} : { rememberVariants },
+    ...coerce === void 0 ? {} : { coerce },
+    ...validateOn === void 0 ? {} : { validateOn },
+    ...debounceMs === void 0 ? {} : { debounceMs },
+    ...getDisplayState === void 0 ? {} : { getDisplayState },
+    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
+    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
+    ...multiTab === void 0 ? {} : { multiTab },
+    ...autoAria === void 0 ? {} : { autoAria }
+  };
+}
+const HISTORY_MODULE_KEY = "history";
+function buildFreshState(key, schema, configuration, registry) {
+  const pending = registry.pendingHydration.get(key);
+  if (pending !== void 0) registry.pendingHydration.delete(key);
+  const walked = walkUnsetSentinels(
+    configuration.defaultValues,
+    schema
+  );
+  let initialBlankPaths;
+  if (pending === void 0) {
+    initialBlankPaths = walked.paths;
+  }
+  const resolvedSensitiveNames = configuration.sensitiveNames;
+  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : paths.createIsSensitivePath(resolvedSensitiveNames);
+  const createOptions = {
+    formKey: key,
+    schema,
+    defaultValues: walked.cleanedValues,
+    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
+    hydration: pending,
+    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
+    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
+    ssr: registry.ssr,
+    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
+    // records intent on every `state.activate()` so a wizard skip-list
+    // override or a future transform mark has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail when the
+    // wizard explicitly skipped this key — even an explicit
+    // `form.activate()` defers to the wizard's render-efficiency
+    // skip-list on the server.
+    ...registry.ssr ? {
+      ssrPrefetch: {
+        enqueue: () => {
+          registry.enqueuePrefetch(key);
+        },
+        shouldFire: () => registry.shouldPrefetch(key)
+      }
+    } : {},
+    ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
+    ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
+    ...configuration.getDisplayState !== void 0 ? { getDisplayState: configuration.getDisplayState } : {},
+    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {},
+    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {}
+  };
+  const state = createFormStore(createOptions);
+  registry.forms.set(
+    key,
+    state
+  );
+  return state;
+}
+let anonCounter = 0;
+let formInstanceCounter = 0;
+const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientProvide(ssr) {
+  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
+  const instance = vue.getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: paths.captureUserCallSite()
+  };
+  const existing = ambientProvideHistory.get(instanceKey);
+  if (existing === void 0) {
+    ambientProvideHistory.set(instanceKey, [entry]);
+    return;
+  }
+  existing.push(entry);
+}
+function resolveFormKey(key) {
+  if (key !== void 0 && key !== null && key !== "") {
+    if (key.startsWith(RESERVED_KEY_PREFIX)) {
+      throw new paths.ReservedFormKeyError(key);
     }
-    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
-    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
-    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
-    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
+    return key;
   }
-  function awaitPendingWrites() {
-    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
-    if (disposed) return Promise.resolve();
-    return writer.flush().catch(() => void 0);
+  if (vue.getCurrentInstance() !== null) {
+    return `${ANONYMOUS_FORM_KEY_PREFIX}${vue.useId()}`;
   }
-  function dispose() {
-    if (disposed || inFlightFinalFlush !== null) return;
-    unsubscribeChange();
-    unsubscribeSuccess();
-    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
-      disposed = true;
-      inFlightFinalFlush = null;
-    });
+  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
+}
+function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
+  let existingFp;
+  let incomingFp;
+  try {
+    existingFp = existing.fingerprint();
+    incomingFp = incoming.fingerprint();
+  } catch (error) {
+    console.error(
+      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
+      error
+    );
+    return;
   }
-  return {
-    wiredConfig: config,
-    writePathImmediately,
-    clearPersistedDraft,
-    awaitPendingWrites,
-    dispose
-  };
+  if (existingFp === incomingFp) return;
+  console.warn(
+    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
+  existing: ${existingFp}
+  incoming: ${incomingFp}`
+  );
 }
-function isEmptyContainer(value) {
-  if (value === void 0 || value === null) return true;
-  if (Array.isArray(value)) return value.length === 0;
-  if (isPlainRecord(value)) return Object.keys(value).length === 0;
-  return false;
+function warnOnPersistDivergence(key, existing, incomingPersist) {
+  if (incomingPersist === void 0) return;
+  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
+  const incomingNormalized = normalizePersistConfig(incomingPersist);
+  if (wired === void 0) {
+    console.warn(
+      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
+    );
+    return;
+  }
+  if (persistConfigsEquivalent(wired.wiredConfig, incomingNormalized)) return;
+  console.warn(
+    `[attaform] useForm({ key: "${key}" }) passed a persist config that differs from the first useForm({ key }) call's; first wins, this one is ignored.
+  wired:    ${describePersist(wired.wiredConfig)}
+  incoming: ${describePersist(incomingNormalized)}`
+  );
+}
+function persistConfigsEquivalent(a, b) {
+  if (a.storage !== b.storage) return false;
+  if ((a.key ?? void 0) !== (b.key ?? void 0)) return false;
+  if ((a.debounceMs ?? void 0) !== (b.debounceMs ?? void 0)) return false;
+  return true;
+}
+function describePersist(config) {
+  const storage = typeof config.storage === "string" ? config.storage : "custom-adapter";
+  const parts = [`storage=${storage}`];
+  if (config.key !== void 0) parts.push(`key=${config.key}`);
+  if (config.debounceMs !== void 0) parts.push(`debounceMs=${config.debounceMs}`);
+  return `{ ${parts.join(", ")} }`;
 }
 const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
 function enforceAnonPersistRule(formKey, ssr) {
@@ -5267,33 +6059,6 @@ function enforceAnonPersistRule(formKey, ssr) {
   }
   return true;
 }
-function collectPersistedLeafPaths(form) {
-  const out = [];
-  walk(form, []);
-  return out;
-  function walk(node, prefix) {
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) {
-        walk(node[i], [...prefix, i]);
-      }
-      return;
-    }
-    if (isPlainRecord(node)) {
-      for (const key of Object.keys(node)) {
-        walk(node[key], [...prefix, key]);
-      }
-      return;
-    }
-    if (prefix.length === 0) return;
-    out.push(paths.canonicalizePath(prefix).key);
-  }
-}
-function isDescendantPathKey(candidate, ancestor) {
-  if (candidate.length <= ancestor.length) return false;
-  if (!ancestor.endsWith("]")) return false;
-  const childPrefix = `${ancestor.slice(0, -1)},`;
-  return candidate.startsWith(childPrefix);
-}
 
 let injectedInstanceCounter = 0;
 function injectForm(input) {
@@ -5373,8 +6138,6 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
-  push() {
-  },
   replace() {
   },
   read() {
@@ -5401,21 +6164,16 @@ function createWizardHistory(param) {
     for (const subscriber of subscribers) subscriber(value);
   }
   window.addEventListener("popstate", handlePopstate);
-  function safeWriteState(key, op) {
+  function safeReplaceState(key) {
     try {
-      const fn = op === "push" ? window.history.pushState : window.history.replaceState;
-      fn.call(window.history, {}, "", buildUrl(key));
+      window.history.replaceState({}, "", buildUrl(key));
     } catch {
     }
   }
   return {
-    push(key) {
-      if (disposed) return;
-      safeWriteState(key, "push");
-    },
     replace(key) {
       if (disposed) return;
-      safeWriteState(key, "replace");
+      safeReplaceState(key);
     },
     read() {
       const url = new URL(window.location.href);
@@ -5474,68 +6232,16 @@ function buildWizardStatusesProxy(statuses) {
     }
     return result;
   });
-  const target = (() => {
-  });
-  const proxyToString = () => JSON.stringify(snapshot.value);
-  const proxyToPrimitive = (hint) => hint === "number" ? NaN : proxyToString();
-  return new Proxy(target, {
-    apply(_, __, args) {
-      const key = args[0];
-      if (key === void 0) return snapshot.value;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    get(_, key) {
-      if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return proxyToPrimitive;
-        return Reflect.get(target, key);
-      }
-      if (key === "toJSON") return () => snapshot.value;
-      if (key === "toString") return proxyToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    has(_, key) {
-      if (typeof key === "symbol") return Reflect.has(target, key);
-      return Object.hasOwn(statuses, key);
-    },
-    ownKeys() {
-      return Object.keys(statuses);
-    },
-    getOwnPropertyDescriptor(_, key) {
-      if (typeof key === "symbol") return void 0;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return {
-        configurable: true,
-        enumerable: true,
-        writable: false,
-        value: computedEntry.value
-      };
-    },
-    set(_, key) {
-      if (paths.__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 write to "${String(key)}" was ignored. Statuses derive from each form's meta; mutate the underlying form instead.`
-        );
-      }
-      return true;
-    },
-    deleteProperty(_, key) {
-      if (paths.__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
-      return true;
-    },
-    defineProperty: () => true
+  return buildCallableReadonlySnapshotProxy({
+    surface: "wizard.statuses",
+    snapshot: () => snapshot.value,
+    resolveKey: (key) => statuses[key]?.value,
+    // Single-key callable form. Strings stringify naturally; non-
+    // string args coerce via `String(arg)` and miss the lookup, which
+    // resolves to `undefined` (consistent with property-access).
+    resolveCall: (arg) => statuses[String(arg)]?.value,
+    ownKeys: () => Object.keys(statuses),
+    hasKey: (key) => Object.hasOwn(statuses, key)
   });
 }
 
@@ -5552,6 +6258,12 @@ const NOOP_VALID_STATUS = {
   submitted: false,
   errorCount: 0
 };
+function asStatusSource(form) {
+  return form;
+}
+function asSubmissionSource(form) {
+  return form;
+}
 function useWizard(options) {
   const rawSteps = Array.isArray(options.steps) ? options.steps : [];
   if (rawSteps.length === 0 && paths.__DEV__) {
@@ -5639,10 +6351,12 @@ function useWizard(options) {
       return { configurable: true, enumerable: true, writable: false, value: form };
     }
   });
-  const slotCtx = vue.computed(() => ({
+  const slotCtx = {
     forms: slotForms,
-    currentKey: activeKey.value === "" ? void 0 : activeKey.value
-  }));
+    get currentKey() {
+      return activeKey.value === "" ? void 0 : activeKey.value;
+    }
+  };
   function resolveSlot(slot, index, ctx) {
     if (typeof slot === "string") {
       return getOrBuildNoop(slot);
@@ -5665,12 +6379,6 @@ function useWizard(options) {
     }
     return result;
   }
-  const lazyCtx = {
-    forms: slotForms,
-    get currentKey() {
-      return activeKey.value === "" ? void 0 : activeKey.value;
-    }
-  };
   for (let i = 0; i < rawSteps.length; i++) {
     const slot = rawSteps[i];
     if (isLazyMarker(slot)) {
@@ -5680,18 +6388,17 @@ function useWizard(options) {
         idx,
         vue.computed(() => {
           void lazyEpoch.value;
-          return marker.resolve(lazyCtx);
+          return marker.resolve(slotCtx);
         })
       );
     }
   }
   const compiledSteps = vue.computed(() => {
-    const ctx = slotCtx.value;
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < rawSteps.length; i++) {
       const slot = rawSteps[i];
-      const form = resolveSlot(slot, i, ctx);
+      const form = resolveSlot(slot, i, slotCtx);
       if (form === void 0) continue;
       if (seen.has(form.key)) {
         if (paths.__DEV__) {
@@ -5717,9 +6424,12 @@ function useWizard(options) {
     return -1;
   });
   const currentStep = vue.computed(() => {
-    const key = activeKey.value;
-    if (key !== "") return key;
-    const first = compiledSteps.value[0];
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    if (idx >= 0 && idx < list.length) {
+      return list[idx].key;
+    }
+    const first = list[0];
     return first === void 0 ? void 0 : first.key;
   });
   const activeForm = vue.computed(() => {
@@ -5742,36 +6452,94 @@ function useWizard(options) {
     for (const step of compiledSteps.value) out[step.key] = step.form;
     return out;
   });
-  const allValues = vue.computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      out[step.key] = source.values;
+  function isFormReady(key) {
+    const store = registry.forms.get(key);
+    return store?.defaultsResolved.value === true;
+  }
+  function toWizardAggregateError(err, fallbackKey) {
+    const entry = {
+      formKey: err.formKey ?? fallbackKey,
+      path: err.path,
+      message: err.message
+    };
+    if (err.code !== void 0) entry.code = err.code;
+    return entry;
+  }
+  const valuesCache = /* @__PURE__ */ new Map();
+  function valuesFor(form) {
+    const cached = valuesCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedValues = vue.computed(() => source.values);
+    valuesCache.set(form.key, computedValues);
+    return computedValues;
+  }
+  const errorsCache = /* @__PURE__ */ new Map();
+  function errorsFor(form) {
+    const cached = errorsCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedErrors = vue.computed(() => {
+      if (!isFormReady(form.key)) return [];
+      const errors = source.meta?.errors ?? [];
+      const list = [];
+      for (const err of errors) list.push(toWizardAggregateError(err, form.key));
+      return list;
+    });
+    errorsCache.set(form.key, computedErrors);
+    return computedErrors;
+  }
+  const allValues = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return valuesFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: valuesFor(form).value
+      };
     }
-    return out;
   });
-  const allErrors = vue.computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      const list = [];
-      const store = registry.forms.get(step.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
-        const errors = source.meta?.errors ?? [];
-        for (const err of errors) {
-          const entry = {
-            formKey: step.key,
-            path: err.path,
-            message: err.message
-          };
-          if (err.code !== void 0) entry.code = err.code;
-          list.push(entry);
-        }
-      }
-      out[step.key] = list;
+  const allErrors = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return errorsFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: errorsFor(form).value
+      };
     }
-    return out;
   });
   const seedRef = vue.ref(void 0);
   const seedInput = options.defaultStatuses;
@@ -5794,11 +6562,9 @@ function useWizard(options) {
   function statusFor(form) {
     const cached = statusCache.get(form.key);
     if (cached !== void 0) return cached;
-    const source = form;
+    const source = asStatusSource(form);
     const computedStatus = vue.computed(() => {
-      const store = registry.forms.get(form.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
+      if (isFormReady(form.key)) {
         const meta = source.meta;
         if (meta !== void 0 && meta !== null) {
           return {
@@ -5941,7 +6707,7 @@ function useWizard(options) {
   }
   if (!registry.ssr) {
     for (const step of compiledSteps.value) {
-      const source = step.form;
+      const source = asSubmissionSource(step.form);
       if (typeof source.activate === "function") void source.activate();
     }
   }
@@ -5985,7 +6751,7 @@ function useWizard(options) {
   const submissionAttempts = vue.ref(0);
   const done = vue.ref(false);
   function activateForm(form) {
-    const source = form;
+    const source = asSubmissionSource(form);
     if (typeof source.activate === "function") {
       void source.activate();
     }
@@ -6085,7 +6851,7 @@ function useWizard(options) {
     };
   }
   async function processOne(form) {
-    const full = form;
+    const full = asSubmissionSource(form);
     let activationFailure;
     try {
       if (typeof full.activate === "function") await full.activate();
@@ -6117,15 +6883,7 @@ function useWizard(options) {
     for (const step of compiledSteps.value) {
       const processed = results.get(step.key);
       if (processed === void 0 || processed.success === true) continue;
-      for (const err of processed.errors) {
-        const entry = {
-          formKey: err.formKey,
-          path: err.path,
-          message: err.message
-        };
-        if (err.code !== void 0) entry.code = err.code;
-        out.push(entry);
-      }
+      for (const err of processed.errors) out.push(toWizardAggregateError(err, step.key));
     }
     return out;
   }
@@ -6179,8 +6937,7 @@ function useWizard(options) {
             if (processed !== void 0 && processed.success === true) {
               valuesMap[step.key] = processed.data;
             } else {
-              const source = step.form;
-              valuesMap[step.key] = source.values;
+              valuesMap[step.key] = asStatusSource(step.form).values;
             }
           }
           const ctx = buildSubmitContext(valuesMap, currentKey, final);
@@ -6201,8 +6958,11 @@ function useWizard(options) {
               moveTo(firstFailedKey);
               await vue.nextTick();
               const failedForm = formsRecord.value[firstFailedKey];
-              if (failedForm !== void 0 && typeof failedForm.applyInvalidSubmitPolicy === "function") {
-                failedForm.applyInvalidSubmitPolicy();
+              if (failedForm !== void 0) {
+                const failedSource = asSubmissionSource(failedForm);
+                if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
+                  failedSource.applyInvalidSubmitPolicy();
+                }
               }
             }
           }
@@ -6217,7 +6977,7 @@ function useWizard(options) {
     done.value = false;
     lazyEpoch.value += 1;
     for (const step of compiledSteps.value) {
-      const full = step.form;
+      const full = asSubmissionSource(step.form);
       if (typeof full.reset === "function") full.reset();
     }
     const firstStep = compiledSteps.value[0];
@@ -6267,12 +7027,8 @@ function useWizard(options) {
       return count.value;
     },
     statuses,
-    get allValues() {
-      return allValues.value;
-    },
-    get allErrors() {
-      return allErrors.value;
-    },
+    allValues,
+    allErrors,
     get progress() {
       return progress.value;
     },
@@ -6405,7 +7161,7 @@ function warnIfAmbientWizardProviderHadDuplicates() {
 
 exports.AttaformErrorCode = AttaformErrorCode;
 exports.defaultCoercionRules = defaultCoercionRules;
-exports.defaultShouldShowErrors = defaultShouldShowErrors;
+exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
@@ -6420,4 +7176,4 @@ exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.II89Pcf4.cjs.map
+//# sourceMappingURL=attaform.DL4CQ-oW.cjs.map