attaform 0.18.2 → 0.20.0

package/dist/shared/{attaform.CZ-XtZt_.mjs → attaform.CKFbKFb6.mjs}

@@ -1,5 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
-import { i as canonicalizePath, H as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, _ as __DEV__, E as pathKeyToDotted, g as SubmitErrorHandlerError, A as AnonPersistError, j as captureUserCallSite, R as ROOT_PATH, q as enforceSensitiveCheck, F as FORM_ERRORS_PATH, k as coerceToPathKey, G as segmentMatchesSensitive, v as isSensitivePath, n as createPersistOptInRegistry, c as InvalidUseFormConfigError, r as ensureAttaformInstalled, K as useRegistry, z as kFormContext, B as kFormInstanceId, f as ReservedFormKeyError, m as createIsSensitivePath, p as createSegmentMatchesSensitive, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.CDmaxrt2.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, toRaw, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
+import { _ as __DEV__, j as canonicalizePath, E as segmentsForPathKey, s as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, u as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, H as useRegistry, y as kFormContext, z as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, x as kAttaformWizardActiveStepResolver, v as kAttaformAncestorWizard } from './attaform.BKozEdTr.mjs';
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -62,7 +62,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;
 }
@@ -163,7 +163,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];
@@ -427,13 +427,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 (__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,
@@ -454,6 +522,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);
@@ -467,21 +536,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 } = canonicalizePath(pathInput);
     const cached = cache.get(key);
     if (cached !== void 0) return cached;
     const c = computed(
-      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key, getFormMetaBase, 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;
@@ -511,6 +580,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,
@@ -519,6 +590,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,
@@ -526,31 +599,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(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 (!isPathPrefix(segments, entry.segments)) continue;
     if (segments.length === entry.segments.length) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
-    const leafKey = canonicalizePath(entry.segments).key;
     const leafRecord = state.fields.get(leafKey);
-    if (!state.isPristineAtPath(entry.segments)) {
+    if (!state.isPristineAtPathByKey(leafKey, entry.segments)) {
       pristine = false;
       dirty = true;
     }
@@ -558,14 +632,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;
@@ -581,6 +661,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     focused,
     blurred,
     touched,
+    interacted,
+    blurredAfterInteraction,
     connected,
     element: null,
     elements: EMPTY_ELEMENTS,
@@ -589,6 +671,8 @@ function buildContainerFieldStateBase(state, segments, _key) {
     validating,
     valid,
     path: segments,
+    ...computeFieldIdentity(formInstanceId, state.formKey, key),
+    key: state.arrayElementKey(segments),
     blank,
     label,
     description: resolved.description,
@@ -596,15 +680,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 (__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;
@@ -630,6 +735,41 @@ function aggregateErrorsAt(state, prefix) {
 }
 const EMPTY_ELEMENTS = Object.freeze([]);
 
+function liveKeysAtPath(state, segments) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    const keys = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
+    return keys;
+  }
+  if (typeof value === "object") return Object.keys(value);
+  return [];
+}
+function isArrayPath(state, segments) {
+  if (segments.length === 0) return false;
+  return Array.isArray(getAtPath(state.form.value, segments));
+}
+
+function warnReadOnly(surface, action, key) {
+  if (!__DEV__) return;
+  const phrase = action === "write" ? `write to "${String(key)}"` : `${action} of "${String(key)}"`;
+  console.warn(
+    `[attaform] ${surface} is read-only \u2014 ${phrase} was ignored. Mutate the form via setValue / the directive / field-array helpers instead.`
+  );
+}
+function makeReadonlyCoercion(snapshot) {
+  const toString = () => JSON.stringify(snapshot());
+  return {
+    toString,
+    valueOf() {
+      return this;
+    },
+    toJSON: snapshot,
+    toPrimitive: (hint) => hint === "number" ? NaN : toString()
+  };
+}
+
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
@@ -661,12 +801,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, {
@@ -691,6 +831,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;
@@ -735,10 +878,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;
@@ -760,11 +918,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, {
@@ -782,7 +941,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);
@@ -809,9 +968,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;
@@ -875,33 +1047,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 === FORM_ERRORS_PATH_KEY) {
+        if (segments.length === 0) keys.add("");
+        continue;
+      }
+      const decoded = segmentsForPathKey(pathKey);
+      if (decoded === null) continue;
+      if (decoded.length <= segments.length) continue;
+      if (!isPathPrefix(segments, decoded)) continue;
+      if (applyActivePathFilter && !hasAtPath(formValue, decoded)) continue;
+      const nextSeg = decoded[segments.length];
+      keys.add(typeof nextSeg === "number" ? String(nextSeg) : nextSeg);
+    }
+  };
+  walk(state.schemaErrors, true);
+  walk(state.derivedBlankErrors.value, true);
+  walk(state.userErrors, false);
+  return [...keys];
 }
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
-  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;
@@ -951,7 +1143,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;
@@ -986,19 +1178,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);
@@ -1016,11 +1209,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);
@@ -1039,6 +1228,8 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "focused",
   "blurred",
   "touched",
+  "interacted",
+  "blurredAfterInteraction",
   "connected",
   "element",
   "elements",
@@ -1046,20 +1237,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;
@@ -1108,9 +1307,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 (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
+          );
+        }
+        return true;
+      },
+      deleteProperty: (_, key) => {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 delete of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      },
+      defineProperty: (_, key) => {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] form.fields(path) is read-only \u2014 define of "${String(key)}" was ignored.`
+          );
+        }
+        return true;
+      }
     });
     terminalCache.set(cacheKey, proxy);
     return proxy;
@@ -1126,21 +1350,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);
@@ -1166,29 +1375,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 (__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;
@@ -1207,7 +1393,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;
@@ -1231,12 +1417,7 @@ function warnVersionMismatch(observedVersion) {
 function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
   let transientList;
   if (blankPaths !== void 0 && blankPaths.size > 0) {
-    const dotted = [];
-    for (const key of blankPaths) {
-      const d = pathKeyToDotted(key);
-      if (d !== null) dotted.push(d);
-    }
-    transientList = dotted.length > 0 ? dotted : void 0;
+    transientList = [...blankPaths];
   }
   if (include === "form") {
     if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
@@ -1258,30 +1439,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) {
@@ -1294,7 +1480,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);
@@ -1302,12 +1488,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 };
@@ -1318,12 +1507,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 {
     }
   }
@@ -1334,12 +1518,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 {
     }
   }
@@ -1355,6 +1534,29 @@ function pluckPaths(form, pathKeys) {
   }
   return sparse ?? {};
 }
+function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
+  const acknowledgedSensitive = [];
+  for (const key of optedInPaths) {
+    const segs = segmentsForPathKey(key);
+    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
+  }
+  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => isPathPrefix(prefix, path));
+  const walk = (path, value) => {
+    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {
+      return void 0;
+    }
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
+    if (!isPlainRecord(value)) return value;
+    const out = /* @__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) {
@@ -1381,7 +1583,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);
@@ -1393,7 +1595,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);
   }
@@ -1496,39 +1698,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 {
@@ -1966,7 +2173,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;
@@ -1994,6 +2200,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 };
@@ -2015,7 +2223,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);
@@ -2048,6 +2260,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         callSite: captureUserCallSite()
       });
     }
+    const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
+    const isRequired = state.schema.isRequiredAtPath(segments);
+    const ariaEnabled = options?.autoAria ?? formAutoAria;
+    const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
     const internalRv = {
       innerRef,
       displayValue,
@@ -2062,6 +2278,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
           })
         );
       },
+      markInteracted: () => {
+        state.markInteracted(segments);
+      },
       registerElement: (element) => {
         if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
         const added = state.registerElement(segments, element, formInstanceId);
@@ -2106,7 +2325,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 shallowReadonly(internalRv);
   };
@@ -2157,7 +2381,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];
@@ -2186,7 +2410,7 @@ function walkUnspecified(slim, segments, paths) {
   }
   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);
     }
@@ -2219,7 +2443,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);
@@ -2271,70 +2495,86 @@ function expandUnsetAt(segments, schema, paths) {
   return result;
 }
 
-function buildValuesProxy(form) {
-  const inner = computed(() => readonly(form.value));
+function buildCallableReadonlySnapshotProxy(opts) {
   const target = (() => {
   });
-  const valuesToString = () => JSON.stringify(inner.value);
-  const valuesToPrimitive = (hint) => hint === "number" ? NaN : valuesToString();
+  const { toString, valueOf, toJSON, toPrimitive } = makeReadonlyCoercion(opts.snapshot);
+  const callResolve = opts.resolveCall ?? ((arg) => opts.resolveKey(String(arg)));
   return new Proxy(target, {
     apply(_, __, args) {
       const arg = args[0];
-      if (arg === void 0) return inner.value;
-      const { segments } = canonicalizePath(arg);
-      let cursor = inner.value;
-      for (const seg of segments) {
-        if (cursor === null || cursor === void 0) return void 0;
-        cursor = cursor[seg];
-      }
-      return cursor;
+      if (arg === void 0) return opts.snapshot();
+      return callResolve(arg);
     },
     get(_, key) {
       if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return valuesToPrimitive;
+        if (key === Symbol.toPrimitive) return toPrimitive;
         return Reflect.get(target, key);
       }
-      if (key === "toJSON") return () => inner.value;
-      if (key === "toString") return valuesToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      return inner.value[key];
+      if (key === "toJSON") return toJSON;
+      if (key === "toString") return toString;
+      if (key === "valueOf") return valueOf;
+      return opts.resolveKey(key);
     },
     has(_, key) {
       if (typeof key === "symbol") return Reflect.has(target, key);
-      return Reflect.has(inner.value, key);
-    },
-    ownKeys() {
-      return Reflect.ownKeys(inner.value);
+      return opts.hasKey(key);
     },
+    ownKeys: () => opts.ownKeys(),
     getOwnPropertyDescriptor(_, key) {
-      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
-      if (desc !== void 0) desc.configurable = true;
-      return desc;
+      if (typeof key !== "string") return void 0;
+      if (opts.describeKey !== void 0) return opts.describeKey(key);
+      if (!opts.hasKey(key)) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: opts.resolveKey(key)
+      };
     },
-    // Match Vue's `readonly()` semantics: writes warn (in dev) and
-    // silently noop (return true). Returning false would throw
-    // TypeError in strict-mode consumers, surprising users who
-    // assigned through the proxy and expected it to be ignored.
-    set(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
-        );
-      }
+    set: (_, key) => {
+      warnReadOnly(opts.surface, "write", key);
       return true;
     },
-    deleteProperty(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] form.values is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
+    deleteProperty: (_, key) => {
+      warnReadOnly(opts.surface, "delete", key);
       return true;
     },
-    defineProperty: () => true
+    defineProperty: (_, key) => {
+      warnReadOnly(opts.surface, "define", key);
+      return true;
+    }
+  });
+}
+
+function buildValuesProxy(form) {
+  const inner = computed(() => readonly(form.value));
+  return buildCallableReadonlySnapshotProxy({
+    surface: "form.values",
+    snapshot: () => inner.value,
+    // Read through the readonly proxy at access time so Vue's
+    // dependency tracking lands inside the consumer's active effect
+    // — `inner.value[key]` is what triggers per-key tracking.
+    resolveKey: (key) => inner.value[key],
+    // Dynamic path: walk segments through the readonly proxy. Each
+    // step reads through the proxy's own get traps so dependency
+    // tracking propagates at every level.
+    resolveCall: (arg) => {
+      const { segments } = canonicalizePath(arg);
+      let cursor = inner.value;
+      for (const seg of segments) {
+        if (cursor === null || cursor === void 0) return void 0;
+        cursor = cursor[seg];
+      }
+      return cursor;
+    },
+    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;
+    }
   });
 }
 
@@ -2350,15 +2590,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, ROOT_PATH, 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 {
@@ -2381,10 +2640,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
         next,
         state.schema
       );
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      if (!ok2) return false;
       for (const pathKey of walked2.paths) {
-        state.blankPaths.add(pathKey);
+        const blankSegments = segmentsForPathKey(pathKey);
+        if (blankSegments === null) continue;
+        state.setValueAtPath(
+          blankSegments,
+          state.getValueAtPath(blankSegments),
+          withInstanceMeta({ blank: true })
+        );
       }
-      return state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      return true;
     }
     const segments = canonicalizePath(pathOrValue).segments;
     const writeUnsetAt = () => {
@@ -2530,43 +2797,48 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const metaErrors = computed(
     () => aggregateErrorsAt(state, [])
   );
-  const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, 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 = readonly(
     reactive({
-      // FieldState fields — read through one shared root computed. Each
-      // property accesses `rootFieldState.value[X]`, so any descendant
-      // change re-evaluates the root computed once (Vue's reactive
-      // graph dedupes the dependent re-renders).
-      value: computed(() => rootFieldState.value.value),
-      original: computed(() => rootFieldState.value.original),
-      pristine: computed(() => rootFieldState.value.pristine),
-      dirty: computed(() => rootFieldState.value.dirty),
-      focused: computed(() => rootFieldState.value.focused),
-      blurred: computed(() => rootFieldState.value.blurred),
-      touched: computed(() => rootFieldState.value.touched),
-      connected: computed(() => rootFieldState.value.connected),
-      element: computed(() => rootFieldState.value.element),
-      elements: computed(() => rootFieldState.value.elements),
-      updatedAt: computed(() => rootFieldState.value.updatedAt),
+      get value() {
+        return rootFieldState.value.value;
+      },
+      get original() {
+        return rootFieldState.value.original;
+      },
+      get pristine() {
+        return rootFieldState.value.pristine;
+      },
+      get dirty() {
+        return rootFieldState.value.dirty;
+      },
+      get focused() {
+        return rootFieldState.value.focused;
+      },
+      get blurred() {
+        return rootFieldState.value.blurred;
+      },
+      get touched() {
+        return rootFieldState.value.touched;
+      },
+      get interacted() {
+        return rootFieldState.value.interacted;
+      },
+      get blurredAfterInteraction() {
+        return rootFieldState.value.blurredAfterInteraction;
+      },
+      get connected() {
+        return rootFieldState.value.connected;
+      },
+      get element() {
+        return rootFieldState.value.element;
+      },
+      get elements() {
+        return rootFieldState.value.elements;
+      },
+      get updatedAt() {
+        return rootFieldState.value.updatedAt;
+      },
       // Whole-form validating mirrors the LIFECYCLE counter
       // (`state.activeValidations`) ORed with any per-leaf validation
       // in flight (via `rootFieldState.validating`). A submit-time
@@ -2584,19 +2856,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: computed(() => rootFieldState.value.showErrors),
-      firstError: computed(() => rootFieldState.value.firstError),
-      path: computed(() => rootFieldState.value.path),
-      blank: computed(() => rootFieldState.value.blank),
-      label: computed(() => rootFieldState.value.label),
-      description: computed(() => rootFieldState.value.description),
-      placeholder: computed(() => rootFieldState.value.placeholder),
-      meta: computed(() => rootFieldState.value.meta),
+      // `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,
@@ -2605,7 +2914,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // Scalar mirror over the array — meta is a single sticky surface
       // for both templates and `useWizard`'s `FormStatus`, so the
       // projection lives here.
-      errorCount: computed(() => metaErrors.value.length),
+      get errorCount() {
+        return metaErrors.value.length;
+      },
       submitted,
       // Per-`useForm()`-call identity. Stable for one mount; new on
       // re-mount; orthogonal to `form.key` (which is the user-supplied
@@ -2642,12 +2953,20 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
   };
   function clear(pathInput) {
-    const segments = pathInput === void 0 ? ROOT_PATH : canonicalizePath(pathInput).segments;
-    return state.clear(segments);
+    if (pathInput === void 0) {
+      return setValueImpl(unset);
+    }
+    return setValueImpl(pathInput, unset);
   }
   const persist = async (pathInput, options2) => {
     const segments = canonicalizePath(pathInput).segments;
-    enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
+    if (!allowSensitivePersist(
+      segments,
+      options2?.acknowledgeSensitive === true,
+      state.isSensitivePath
+    )) {
+      return;
+    }
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2707,13 +3026,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 } = 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 } = 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
@@ -2795,6 +3144,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;
@@ -2802,47 +3153,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 (!__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);
@@ -2871,49 +3181,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 = 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 = segmentsForPathKey(memKey);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= arrayPath.length) continue;
+      const idxSeg = segs[arrayPath.length];
+      if (typeof idxSeg !== "number") continue;
+      if (indexFilter(idxSeg)) memory.delete(memKey);
     }
-    return 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 = segmentsForPathKey(memKey);
+        if (segs === null) continue;
+        if (isPathPrefix(parentPath, segs)) memory.delete(memKey);
+      }
+    },
+    applyArrayOp(arrayPath, op) {
+      switch (op.kind) {
+        case "insert":
+        case "remove":
+          clearAtArrayIndices(arrayPath, (i) => i >= op.index);
+          return;
+        case "move": {
+          const lo = Math.min(op.from, op.to);
+          const hi = Math.max(op.from, op.to);
+          clearAtArrayIndices(arrayPath, (i) => i >= lo && i <= hi);
+          return;
+        }
+        case "swap":
+          clearAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
+          return;
+        case "replace-at":
+          clearAtArrayIndices(arrayPath, (i) => i === op.index);
+          return;
+      }
+    },
+    recordOutgoing(unionKey, discValue, snapshot) {
+      let perUnion = memory.get(unionKey);
+      if (perUnion === void 0) {
+        perUnion = /* @__PURE__ */ new Map();
+        memory.set(unionKey, perUnion);
+      }
+      perUnion.set(discValue, snapshot);
+    },
+    lookupIncoming(unionKey, discValue) {
+      return memory.get(unionKey)?.get(discValue);
+    }
+  };
 }
 function cloneVariantSnapshot(value) {
   if (value === null || typeof value !== "object") return value;
@@ -2936,50 +3271,403 @@ 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(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(canonicalizePath(arraySegs).key, len);
+      return ids[index] ?? "";
+    },
+    applyOp(arraySegs, op) {
+      const arrayKey = 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 = segmentsForPathKey(key);
+          if (segments === null) continue;
+          if (!isPathPrefix(arrayPath, segments)) continue;
+          if (segments.length <= idxPos) continue;
+          const idxSeg = segments[idxPos];
+          if (typeof idxSeg !== "number") continue;
+          if (!remap.moved.has(idxSeg) && !remap.vacated.has(idxSeg) && !remap.fresh.has(idxSeg)) {
+            continue;
+          }
+          snapshots.push({ segments: [...segments], index: idxSeg, value });
+        }
+        if (snapshots.length === 0) return;
+        for (const snap of snapshots) store.delete(canonicalizePath(snap.segments).key);
+        for (const snap of snapshots) {
+          const target = remap.moved.get(snap.index);
+          if (target === void 0) continue;
+          const relocated = snap.segments.slice();
+          relocated[idxPos] = target;
+          store.set(canonicalizePath(relocated).key, snap.value);
+        }
+      };
+      relocate(tokens);
+      relocate(baselines);
+    },
+    realign(arraySegs) {
+      ensure(canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
+    },
+    hasStructuralChangeUnder(prefix) {
+      for (const arrayKey of tokens.keys()) {
+        if (orderPristineForKey(arrayKey)) continue;
+        const segs = segmentsForPathKey(arrayKey);
+        if (segs === null) continue;
+        if (isPathPrefix(prefix, segs)) return true;
+      }
+      return false;
+    },
+    rebaselineAll() {
+      for (const arrayKey of [...tokens.keys()]) {
+        const segs = 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(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 = segmentsForPathKey(key);
+  if (segments === null) return null;
+  if (!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: [...segmentsForPathKey(key)], index, value });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) map.delete(canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    map.set(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: [...segmentsForPathKey(key)], index });
+  }
+  if (snapshots.length === 0) return;
+  for (const snap of snapshots) set.delete(canonicalizePath(snap.segments).key);
+  for (const snap of snapshots) {
+    const target = remap.moved.get(snap.index);
+    if (target === void 0) continue;
+    const relocated = snap.segments.slice();
+    relocated[idxPos] = target;
+    set.add(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;
+
+function createArrayBookkeeping(deps) {
+  const {
+    form,
+    fields,
+    userErrors,
+    originals,
+    blankPaths,
+    originalBlankPaths,
+    fieldValidationCounts,
+    fieldValidationState,
+    schemaErrors,
+    activeValidations,
+    arrayIdentity,
+    touchFieldRecord,
+    decFieldValidation
+  } = deps;
+  function migrateElementState(arrayPath, remap) {
+    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
+    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
+      ...record,
+      path: segments
+    }));
+    migrateMapSubtree(
+      userErrors,
+      arrayPath,
+      remap,
+      (errors, segments) => errors.map((error) => ({ ...error, path: [...segments] }))
+    );
+    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
+      segments,
+      value: record.value
+    }));
+    migrateSetSubtree(blankPaths, arrayPath, remap);
+    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
+    arrayIdentity.applyRemap(arrayPath, remap);
+  }
+  function seedFreshElement(arrayPath, freshIndex) {
+    const elementPath = [...arrayPath, freshIndex];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = canonicalizePath(patch.path);
+      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
+      touchFieldRecord(key, patch.path, { updatedAt: now });
+    });
+  }
+  function dropSchemaErrorsAtChangedIndices(arrayPath, remap) {
+    const changed = changedIndices(remap);
+    if (changed.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const key of [...schemaErrors.keys()]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx === "number" && changed.has(idx)) schemaErrors.delete(key);
+    }
+  }
+  function abortValidationAtVacatedIndices(arrayPath, remap) {
+    if (remap.vacated.size === 0) return;
+    const idxPos = arrayPath.length;
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!isPathPrefix(arrayPath, segs)) continue;
+      if (segs.length <= idxPos) continue;
+      const idx = segs[idxPos];
+      if (typeof idx !== "number" || !remap.vacated.has(idx)) continue;
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
+      }
+      entry.controller.abort();
+      fieldValidationState.delete(key);
+    }
+  }
+  return {
+    migrateElementState,
+    seedFreshElement,
+    dropSchemaErrorsAtChangedIndices,
+    abortValidationAtVacatedIndices
+  };
+}
+
+function isHydratedFieldRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const r = value;
+  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 (!__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 = 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(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(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,
@@ -3010,11 +3698,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 ?? isSensitivePath;
-  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -3052,6 +3737,16 @@ function createFormStore(options) {
     warn: true
   });
   const form = 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 = reactive(/* @__PURE__ */ new Map());
   const elements = reactive(/* @__PURE__ */ new Map());
   const elementToFormInstance = /* @__PURE__ */ new WeakMap();
@@ -3067,41 +3762,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 = segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (isPathPrefix(arrayPath, segs)) variantMemory.delete(memKey);
-    }
-  }
-  function clearVariantMemoryAtArrayIndices(arrayPath, indexFilter) {
-    for (const memKey of [...variantMemory.keys()]) {
-      const segs = segmentsForPathKey(memKey);
-      if (segs === null) continue;
-      if (!isPathPrefix(arrayPath, segs)) continue;
-      if (segs.length <= arrayPath.length) continue;
-      const idxSeg = segs[arrayPath.length];
-      if (typeof idxSeg !== "number") continue;
-      if (indexFilter(idxSeg)) variantMemory.delete(memKey);
-    }
-  }
-  function applyArrayOpToMemory(arrayPath, op) {
-    switch (op.kind) {
-      case "shift-from":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.index);
-        return;
-      case "shift-range":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i >= op.fromIndex && i <= op.toIndex);
-        return;
-      case "swap":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.a || i === op.b);
-        return;
-      case "replace-at":
-        clearVariantMemoryAtArrayIndices(arrayPath, (i) => i === op.index);
-        return;
-    }
-  }
+  const variantMemory = createVariantMemory();
   const pathOrdinals = /* @__PURE__ */ new Map();
   let nextOrdinal = 0;
   function ensurePathOrdinal(key) {
@@ -3139,6 +3800,9 @@ function createFormStore(options) {
   const departAttempts = ref(0);
   const submissionGeneration = ref(0);
   const activeValidations = ref(0);
+  const pathSnapshots = /* @__PURE__ */ new Map();
+  let scheduleEpoch = 0;
+  let lastCommittedEpoch = 0;
   const hydrating = ref(false);
   const hydrateError = ref(null);
   const defaultValuesFactory = ref(void 0);
@@ -3154,9 +3818,12 @@ function createFormStore(options) {
   const pathAsyncCache = /* @__PURE__ */ new Map();
   function pathHasAsyncValidation(path) {
     const { key } = canonicalizePath(path);
+    return pathHasAsyncValidationByKey(key, path);
+  }
+  function pathHasAsyncValidationByKey(key, segments) {
     const cached = pathAsyncCache.get(key);
     if (cached !== void 0) return cached;
-    const candidates = schema.getSchemasAtPath(path);
+    const candidates = schema.getSchemasAtPath(segments);
     const hasAsync = candidates.some((sub) => sub.needsAsyncValidation?.() === true);
     pathAsyncCache.set(key, hasAsync);
     return hasAsync;
@@ -3209,7 +3876,9 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -3238,9 +3907,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;
@@ -3364,8 +4053,13 @@ function createFormStore(options) {
     const pathKey = canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
-    } else if (blankPaths.has(pathKey)) {
-      blankPaths.delete(pathKey);
+    } else {
+      if (blankPaths.has(pathKey)) blankPaths.delete(pathKey);
+      if (meta?.arrayOp === void 0) {
+        for (const existingKey of [...blankPaths]) {
+          if (isPathKeyUnder(existingKey, path)) blankPaths.delete(existingKey);
+        }
+      }
     }
     const wasAuthoredBefore = authoredPaths.has(pathKey);
     walkAuthoredFromConstraints(value, path, authoredPaths);
@@ -3384,12 +4078,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") {
@@ -3413,18 +4115,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];
@@ -3496,6 +4192,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;
@@ -3510,11 +4207,25 @@ function createFormStore(options) {
         }
         throw err;
       }
-      void Promise.resolve().then(() => schema.validateAtPath(form.value, void 0)).then((response) => {
+      const subtreeScope = path.length > 0 && schema.hasContainerOrRootRefine?.() === false;
+      const scopePath = subtreeScope ? path : void 0;
+      const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
+      const scopeKey = subtreeScope ? canonicalizePath(path).key : ROOT_PATH_KEY;
+      void Promise.resolve().then(() => schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
         if (controller.signal.aborted) return;
+        if (myEpoch <= lastCommittedEpoch) return;
+        lastCommittedEpoch = myEpoch;
+        if (effectiveMode === "blur") {
+          const snapshotSource = scopePath !== void 0 ? getAtPath(form.value, scopePath) : form.value;
+          pathSnapshots.set(scopeKey, structuralSnapshot(snapshotSource));
+        }
         const errors = response.success ? [] : response.errors;
         const filtered = filterAuthoredErrors(errors);
-        applySchemaErrorsForSubtree([], filtered);
+        const restamped = subtreeScope ? filtered.map((err) => ({
+          ...err,
+          path: [...path, ...err.path]
+        })) : filtered;
+        applySchemaErrorsForSubtree(scopePath ?? [], restamped);
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
@@ -3741,24 +4452,55 @@ function createFormStore(options) {
   }
   function markFocused(path, focused, meta) {
     const { key } = 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 = 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 } = 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;
@@ -3778,9 +4520,6 @@ function createFormStore(options) {
       );
     }
   }
-  function clear(path) {
-    return setValueAtPath(path, schema.getEmptyValueAtPath(path));
-  }
   function rehydrate() {
     const factory = defaultValuesFactory.value;
     if (factory === void 0) {
@@ -3870,6 +4609,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;
@@ -3913,7 +4653,9 @@ function createFormStore(options) {
         connected: record.connected,
         focused: record.focused,
         blurred: record.blurred,
-        touched: false
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
       });
     }
     submissionGeneration.value += 1;
@@ -3924,6 +4666,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 {
@@ -3935,13 +4680,7 @@ function createFormStore(options) {
   }
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
-    for (const memKey of [...variantMemory.keys()]) {
-      const memSegments = segmentsForPathKey(memKey);
-      if (memSegments === null) continue;
-      if (isPathPrefix(targetSegments, memSegments)) {
-        variantMemory.delete(memKey);
-      }
-    }
+    variantMemory.clearUnderPath(targetSegments);
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
       const wrote = setValueAtPath(targetSegments, leafEntry.value);
@@ -3997,23 +4736,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 } = 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 } = canonicalizePath(path);
     return fields.get(key);
@@ -4057,7 +4797,7 @@ function createFormStore(options) {
     originals,
     schema,
     ssr,
-    shouldShowErrors: resolvedShouldShowErrors,
+    getDisplayState: resolvedGetDisplayState,
     submitting,
     activeSubmissions,
     submissionAttempts,
@@ -4067,6 +4807,7 @@ function createFormStore(options) {
     hydrating,
     hydrateError,
     defaultValuesFactory,
+    hasSsrPrefetch: ssrPrefetch !== void 0,
     defaultsResolved,
     activated,
     activationPromise,
@@ -4076,13 +4817,14 @@ function createFormStore(options) {
     activeValidations,
     firstValidationDone,
     pathHasAsyncValidation,
+    pathHasAsyncValidationByKey,
     fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
+    arrayElementKey,
     reset,
     resetField,
-    clear,
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
@@ -4095,10 +4837,12 @@ function createFormStore(options) {
     registerElement,
     deregisterElement,
     markFocused,
-    markTouched,
+    markInteracted,
     touchAtPath,
     markConnectedOptimistically,
     isPristineAtPath,
+    isPristineAtPathByKey,
+    hasStructuralChangeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -4114,7 +4858,6 @@ function createFormStore(options) {
     modules,
     persistOptIns,
     isSensitivePath: resolvedIsSensitivePath,
-    segmentMatchesSensitive: resolvedSegmentMatchesSensitive,
     noSyncPaths,
     incrementNoSyncOptOut,
     decrementNoSyncOptOut,
@@ -4315,939 +5058,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 (__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 } = 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 = 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 = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
-    }
-    const safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
-    }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
-      return;
-    }
-    const candidate = applyPatchesForward(state.form.value, safePatches);
+  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(
+        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(toRaw(state.form.value), path);
+    const nextForm = setAtPath(baseForm, path, value);
+    const { key: pathKey } = canonicalizePath(path);
+    const transientSet = new Set(
+      (existing?.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    for (const liveKey of state.blankPaths) {
+      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
+        transientSet.add(liveKey);
+      }
     }
-    if (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 } = 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 (!__DEV__) return;
-  if (warned.has(feature)) return;
-  warned.add(feature);
-  const message = featureMessage(feature);
-  console.warn(`[attaform] ${message}`);
+function isEmptyContainer(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainRecord(value)) return Object.keys(value).length === 0;
+  return false;
 }
-function featureMessage(feature) {
-  switch (feature) {
-    case "multiTab":
-      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
-    case "persist:local":
-      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
-    case "persist:session":
-      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+function collectPersistedLeafPaths(form) {
+  const out = [];
+  walk(form, []);
+  return out;
+  function walk(node, prefix) {
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        walk(node[i], [...prefix, i]);
+      }
+      return;
+    }
+    if (isPlainRecord(node)) {
+      for (const key of Object.keys(node)) {
+        walk(node[key], [...prefix, key]);
+      }
+      return;
+    }
+    if (prefix.length === 0) return;
+    out.push(canonicalizePath(prefix).key);
   }
 }
-function isSecureContext() {
-  return typeof window !== "undefined" && window.isSecureContext === true;
+function isDescendantPathKey(candidate, ancestor) {
+  if (candidate.length <= ancestor.length) return false;
+  if (!ancestor.endsWith("]")) return false;
+  const childPrefix = `${ancestor.slice(0, -1)},`;
+  return candidate.startsWith(childPrefix);
 }
 
-function resolveTrichotomy(input) {
-  if (typeof input === "function") {
-    return { kind: "async", factory: input };
-  }
-  return { kind: "sync", value: input };
+const PROTOCOL_VERSION = 1;
+const JOIN_COLLECTION_WINDOW_MS = 50;
+const SNAPSHOT_TIMEOUT_MS = 200;
+const MAX_LEADER_ATTEMPTS = 3;
+const SNAPSHOT_RESPONSE_MIN_INTERVAL_MS = 500;
+function isFileLikeValue(value) {
+  if (typeof File !== "undefined" && value instanceof File) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return false;
 }
-
-function useAbstractForm(configuration, options) {
-  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new InvalidUseFormConfigError();
+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 = getCurrentInstance();
-  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
-  const registry = options?.registry ?? useRegistry();
-  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
-  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
-  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
-  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
-  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
-  const maxRecursionDepth = normalizeNumericOption({
-    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
-    source: "useForm.maxRecursionDepth",
-    allowInfinity: true,
-    min: 0,
-    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
-  });
-  const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
-  if (configuration.persist !== void 0 && configuration.key === void 0) {
-    throw new AnonPersistError({
-      cause: "no-key",
-      schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: captureUserCallSite()
-    });
-  }
-  const existing = registry.forms.get(key);
-  if (__DEV__ && existing !== void 0) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
-  }
-  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);
-      }
-      onServerPrefetch(() => {
-        if (!registry.shouldPrefetch(key)) return;
-        return state.activate();
-      });
-    }
-  }
-  if (getCurrentScope() !== void 0) {
-    const releaseConsumer = registry.trackConsumer(key);
-    onScopeDispose(releaseConsumer);
-  }
-  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
-  if (existing === void 0 && !registry.ssr) {
-    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
-      const resolvedPersist = normalizePersistConfig(merged.persist);
-      const storageKind = resolvedPersist.storage;
-      const isBuiltinStorage = typeof storageKind === "string";
-      const secureContextOk = !isBuiltinStorage || isSecureContext();
-      if (!secureContextOk) {
-        const feature = storageKind === "session" ? "persist:session" : "persist:local";
-        warnOnceInsecureContext(feature);
-        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
-      } else {
-        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
-        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
-        const persistenceModule = wirePersistence(state, resolvedPersist);
-        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
-        state.registerDrain(() => persistenceModule.awaitPendingWrites());
-        state.registerCleanup(() => persistenceModule.dispose());
-      }
-    } 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);
-    provide(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 = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
-  if (getCurrentInstance() !== null) {
-    provide(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 } = 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 : createIsSensitivePath(resolvedSensitiveNames);
-  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : createSegmentMatchesSensitive(resolvedSensitiveNames);
-  const createOptions = {
-    formKey: key,
-    schema,
-    defaultValues: walked.cleanedValues,
-    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
-    hydration: pending,
-    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
-    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
-    ssr: registry.ssr,
-    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
-    // records intent on every `state.activate()` so a wizard skip-list
-    // override or a future transform mark has a consistent set to diff
-    // against; `shouldFire` lets the activate path bail when the
-    // wizard explicitly skipped this key — even an explicit
-    // `form.activate()` defers to the wizard's render-efficiency
-    // skip-list on the server.
-    ...registry.ssr ? {
-      ssrPrefetch: {
-        enqueue: () => {
-          registry.enqueuePrefetch(key);
-        },
-        shouldFire: () => registry.shouldPrefetch(key)
+  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 = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(ssr) {
-  if (!__DEV__ || ssr || ambientProvideHistory === null) return;
-  const instance = getCurrentInstance();
-  if (instance === null) return;
-  const instanceKey = instance;
-  const entry = {
-    source: captureUserCallSite()
-  };
-  const existing = ambientProvideHistory.get(instanceKey);
-  if (existing === void 0) {
-    ambientProvideHistory.set(instanceKey, [entry]);
-    return;
-  }
-  existing.push(entry);
-}
-function resolveFormKey(key) {
-  if (key !== void 0 && key !== null && key !== "") {
-    if (key.startsWith(RESERVED_KEY_PREFIX)) {
-      throw new ReservedFormKeyError(key);
+      safePatches.push(p);
     }
-    return key;
+    const safeBlankAdded = [];
+    for (const k of msg.blankPathsAdded) {
+      const segs = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankAdded.push(k);
+    }
+    const safeBlankRemoved = [];
+    for (const k of msg.blankPathsRemoved) {
+      const segs = canonicalizePath(k).segments;
+      if (isPathLocallySuppressed(segs)) continue;
+      safeBlankRemoved.push(k);
+    }
+    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
+      return;
+    }
+    const candidate = applyPatchesForward(state.form.value, safePatches);
+    try {
+      options.validateForm(state.form.value);
+      try {
+        options.validateForm(candidate);
+      } catch {
+        return;
+      }
+    } catch {
+    }
+    const nextBlankPaths = new Set(state.blankPaths);
+    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
+    for (const k of safeBlankAdded) nextBlankPaths.add(k);
+    applyIncomingForm(candidate, [...nextBlankPaths]);
   }
-  if (getCurrentInstance() !== null) {
-    return `${ANONYMOUS_FORM_KEY_PREFIX}${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 = 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(
-        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 = 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(toRaw(state.form.value), path);
-    const nextForm = setAtPath(baseForm, path, value);
-    const { key: pathKey } = canonicalizePath(path);
-    const transientSet = new Set(
-      (existing?.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    for (const liveKey of state.blankPaths) {
-      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
-        transientSet.add(liveKey);
+    },
+    lifecycle: () => lifecycle,
+    senderId,
+    channelName
+  };
+}
+const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
+
+const warned = /* @__PURE__ */ new Set();
+function warnOnceInsecureContext(feature) {
+  if (!__DEV__) return;
+  if (warned.has(feature)) return;
+  warned.add(feature);
+  const message = featureMessage(feature);
+  console.warn(`[attaform] ${message}`);
+}
+function featureMessage(feature) {
+  switch (feature) {
+    case "multiTab":
+      return "Multi-tab sync requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is interceptable by network observers, so the sync module is disabled. Serve over HTTPS in production (or develop on `localhost`) to enable cross-tab synchronisation. Use `multiTab: false` on `useForm` to silence this warning.";
+    case "persist:local":
+      return "Built-in `persist: 'local'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable localStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+    case "persist:session":
+      return "Built-in `persist: 'session'` storage requires a secure context (HTTPS or localhost). Plain HTTP on a real hostname is MITM-interceptable, so the persistence layer is disabled. Serve over HTTPS to enable sessionStorage persistence, or pass a custom storage adapter to opt out of the secure-context gate.";
+  }
+}
+function isSecureContext() {
+  return typeof window !== "undefined" && window.isSecureContext === true;
+}
+
+function 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 InvalidUseFormConfigError();
+  }
+  const key = resolveFormKey(configuration.key);
+  const instance = getCurrentInstance();
+  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? useRegistry();
+  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
+  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
+  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
+  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
+  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
+  const maxRecursionDepth = normalizeNumericOption({
+    value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
+    source: "useForm.maxRecursionDepth",
+    allowInfinity: true,
+    min: 0,
+    defaultValue: DEFAULT_MAX_RECURSION_DEPTH
+  });
+  const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
+  if (configuration.persist !== void 0 && configuration.key === void 0) {
+    throw new AnonPersistError({
+      cause: "no-key",
+      schemaFields: extractSchemaFields(resolvedSchema),
+      callSite: captureUserCallSite()
+    });
+  }
+  const existing = registry.forms.get(key);
+  if (__DEV__ && existing !== void 0) {
+    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+    warnOnPersistDivergence(key, existing, configuration.persist);
+  }
+  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);
       }
+      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 (getCurrentScope() !== void 0) {
+    const releaseConsumer = registry.trackConsumer(key);
+    onScopeDispose(releaseConsumer);
+  }
+  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
+  if (existing === void 0 && !registry.ssr) {
+    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
+      const resolvedPersist = normalizePersistConfig(merged.persist);
+      const storageKind = resolvedPersist.storage;
+      const isBuiltinStorage = typeof storageKind === "string";
+      const secureContextOk = !isBuiltinStorage || isSecureContext();
+      if (!secureContextOk) {
+        const feature = storageKind === "session" ? "persist:session" : "persist:local";
+        warnOnceInsecureContext(feature);
+        void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+      } else {
+        const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
+        void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
+        const persistenceModule = wirePersistence(state, resolvedPersist);
+        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
+        state.registerDrain(() => persistenceModule.awaitPendingWrites());
+        state.registerCleanup(() => persistenceModule.dispose());
+      }
     } else {
-      userMap.delete(pathKey);
+      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
     }
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
   }
-  async function clearPersistedDraft(path) {
-    if (disposed) return;
-    await writer.flush();
-    if (disposed) return;
-    const adapter = await adapterPromise;
-    if (disposed) return;
-    if (path === void 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    if (existing === null) return;
-    const nextForm = deleteAtPath(existing.data.form, path);
-    if (isEmptyContainer(nextForm)) {
-      await adapter.removeItem(key);
-      return;
+  if (existing === void 0 && merged.multiTab === true && configuration.key !== void 0 && !registry.ssr) {
+    const hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
+    const secureContext = isSecureContext();
+    if (hasBroadcastChannel && secureContext) {
+      let channelName;
+      try {
+        channelName = `attaform:sync:${state.formKey}:${hashStableString(state.schema.fingerprint())}`;
+      } catch {
+        channelName = null;
+      }
+      if (channelName !== null) {
+        const syncModule = createMultiTabSyncModule(state, channelName, {
+          isSensitivePath: state.isSensitivePath,
+          noSyncPaths: state.noSyncPaths,
+          validateForm: (form) => {
+            const result = state.schema.validateAtPath(form, void 0, { sync: true });
+            if (result instanceof Promise) return;
+            if (!result.success) {
+              throw new Error("attaform multi-tab sync: post-apply schema validation failed");
+            }
+          }
+        });
+        state.modules.set(MULTI_TAB_SYNC_MODULE_KEY, syncModule);
+        state.registerCleanup(() => syncModule.dispose());
+      }
+    } else if (hasBroadcastChannel && !secureContext) {
+      warnOnceInsecureContext("multiTab");
     }
-    const { key: pathKey } = canonicalizePath(path);
-    const transientSet = new Set(
-      (existing.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
+  }
+  if (existing === void 0 && merged.history !== void 0) {
+    const historyModule = createHistoryModule(state, merged.history);
+    state.modules.set(HISTORY_MODULE_KEY, historyModule);
+    state.registerCleanup(() => historyModule.dispose());
+  }
+  if (configuration.key === void 0) {
+    recordAmbientProvide(registry.ssr);
+    provide(kFormContext, state);
+  }
+  const formInstanceId = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
+  if (getCurrentInstance() !== null) {
+    provide(kFormInstanceId, formInstanceId);
+  }
+  const apiOptions = {};
+  if (merged.onInvalidSubmit !== void 0) {
+    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  }
+  const history = state.modules.get(HISTORY_MODULE_KEY);
+  if (history !== void 0) {
+    apiOptions.history = history;
+  }
+  if (merged.validateOn !== void 0) {
+    apiOptions.validateOn = merged.validateOn;
+  }
+  const mergedDebounceMs = merged.debounceMs;
+  if (mergedDebounceMs !== void 0) {
+    apiOptions.debounceMs = mergedDebounceMs;
+  }
+  if (merged.getDisplayState !== void 0) {
+    apiOptions.getDisplayState = merged.getDisplayState;
+  }
+  if (merged.coerce !== void 0) {
+    apiOptions.coerce = merged.coerce;
+  }
+  if (merged.rememberVariants !== void 0) {
+    apiOptions.rememberVariants = merged.rememberVariants;
+  }
+  if (merged.autoAria !== void 0) {
+    apiOptions.autoAria = merged.autoAria;
+  }
+  return buildFormApi(
+    state,
+    formInstanceId,
+    apiOptions
+  );
+}
+function mergeWithDefaults(defaults, configuration) {
+  const strict = configuration.strict ?? defaults.strict;
+  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
+  const history = configuration.history ?? defaults.history;
+  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
+  const coerce = configuration.coerce ?? defaults.coerce;
+  const validateOn = configuration.validateOn ?? defaults.validateOn;
+  const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
+  const getDisplayState = configuration.getDisplayState ?? defaults.getDisplayState;
+  const maxRecursionDepth = configuration.maxRecursionDepth ?? defaults.maxRecursionDepth;
+  const sensitiveNames = configuration.sensitiveNames ?? defaults.sensitiveNames;
+  const multiTab = configuration.multiTab ?? defaults.multiTab;
+  const autoAria = configuration.autoAria ?? defaults.autoAria;
+  return {
+    ...configuration,
+    ...strict === void 0 ? {} : { strict },
+    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
+    ...history === void 0 ? {} : { history },
+    ...rememberVariants === void 0 ? {} : { rememberVariants },
+    ...coerce === void 0 ? {} : { coerce },
+    ...validateOn === void 0 ? {} : { validateOn },
+    ...debounceMs === void 0 ? {} : { debounceMs },
+    ...getDisplayState === void 0 ? {} : { getDisplayState },
+    ...maxRecursionDepth === void 0 ? {} : { maxRecursionDepth },
+    ...sensitiveNames === void 0 ? {} : { sensitiveNames },
+    ...multiTab === void 0 ? {} : { multiTab },
+    ...autoAria === void 0 ? {} : { autoAria }
+  };
+}
+const HISTORY_MODULE_KEY = "history";
+function buildFreshState(key, schema, configuration, registry) {
+  const pending = registry.pendingHydration.get(key);
+  if (pending !== void 0) registry.pendingHydration.delete(key);
+  const walked = walkUnsetSentinels(
+    configuration.defaultValues,
+    schema
+  );
+  let initialBlankPaths;
+  if (pending === void 0) {
+    initialBlankPaths = walked.paths;
+  }
+  const resolvedSensitiveNames = configuration.sensitiveNames;
+  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : createIsSensitivePath(resolvedSensitiveNames);
+  const createOptions = {
+    formKey: key,
+    schema,
+    defaultValues: walked.cleanedValues,
+    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
+    hydration: pending,
+    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
+    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
+    ssr: registry.ssr,
+    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
+    // records intent on every `state.activate()` so a wizard skip-list
+    // override or a future transform mark has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail when the
+    // wizard explicitly skipped this key — even an explicit
+    // `form.activate()` defers to the wizard's render-efficiency
+    // skip-list on the server.
+    ...registry.ssr ? {
+      ssrPrefetch: {
+        enqueue: () => {
+          registry.enqueuePrefetch(key);
+        },
+        shouldFire: () => registry.shouldPrefetch(key)
+      }
+    } : {},
+    ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
+    ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
+    ...configuration.getDisplayState !== void 0 ? { getDisplayState: configuration.getDisplayState } : {},
+    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {},
+    ...resolvedIsSensitivePath !== void 0 ? { isSensitivePath: resolvedIsSensitivePath } : {}
+  };
+  const state = createFormStore(createOptions);
+  registry.forms.set(
+    key,
+    state
+  );
+  return state;
+}
+let anonCounter = 0;
+let formInstanceCounter = 0;
+const ambientProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientProvide(ssr) {
+  if (!__DEV__ || ssr || ambientProvideHistory === null) return;
+  const instance = getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: captureUserCallSite()
+  };
+  const existing = ambientProvideHistory.get(instanceKey);
+  if (existing === void 0) {
+    ambientProvideHistory.set(instanceKey, [entry]);
+    return;
+  }
+  existing.push(entry);
+}
+function resolveFormKey(key) {
+  if (key !== void 0 && key !== null && key !== "") {
+    if (key.startsWith(RESERVED_KEY_PREFIX)) {
+      throw new ReservedFormKeyError(key);
     }
-    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
-    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
-    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
-    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
+    return key;
   }
-  function awaitPendingWrites() {
-    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
-    if (disposed) return Promise.resolve();
-    return writer.flush().catch(() => void 0);
+  if (getCurrentInstance() !== null) {
+    return `${ANONYMOUS_FORM_KEY_PREFIX}${useId()}`;
   }
-  function dispose() {
-    if (disposed || inFlightFinalFlush !== null) return;
-    unsubscribeChange();
-    unsubscribeSuccess();
-    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
-      disposed = true;
-      inFlightFinalFlush = null;
-    });
+  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
+}
+function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
+  let existingFp;
+  let incomingFp;
+  try {
+    existingFp = existing.fingerprint();
+    incomingFp = incoming.fingerprint();
+  } catch (error) {
+    console.error(
+      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
+      error
+    );
+    return;
   }
-  return {
-    wiredConfig: config,
-    writePathImmediately,
-    clearPersistedDraft,
-    awaitPendingWrites,
-    dispose
-  };
+  if (existingFp === incomingFp) return;
+  console.warn(
+    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
+  existing: ${existingFp}
+  incoming: ${incomingFp}`
+  );
 }
-function isEmptyContainer(value) {
-  if (value === void 0 || value === null) return true;
-  if (Array.isArray(value)) return value.length === 0;
-  if (isPlainRecord(value)) return Object.keys(value).length === 0;
-  return false;
+function warnOnPersistDivergence(key, existing, incomingPersist) {
+  if (incomingPersist === void 0) return;
+  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
+  const incomingNormalized = normalizePersistConfig(incomingPersist);
+  if (wired === void 0) {
+    console.warn(
+      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
+    );
+    return;
+  }
+  if (persistConfigsEquivalent(wired.wiredConfig, incomingNormalized)) return;
+  console.warn(
+    `[attaform] useForm({ key: "${key}" }) passed a persist config that differs from the first useForm({ key }) call's; first wins, this one is ignored.
+  wired:    ${describePersist(wired.wiredConfig)}
+  incoming: ${describePersist(incomingNormalized)}`
+  );
+}
+function persistConfigsEquivalent(a, b) {
+  if (a.storage !== b.storage) return false;
+  if ((a.key ?? void 0) !== (b.key ?? void 0)) return false;
+  if ((a.debounceMs ?? void 0) !== (b.debounceMs ?? void 0)) return false;
+  return true;
+}
+function describePersist(config) {
+  const storage = typeof config.storage === "string" ? config.storage : "custom-adapter";
+  const parts = [`storage=${storage}`];
+  if (config.key !== void 0) parts.push(`key=${config.key}`);
+  if (config.debounceMs !== void 0) parts.push(`debounceMs=${config.debounceMs}`);
+  return `{ ${parts.join(", ")} }`;
 }
 const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
 function enforceAnonPersistRule(formKey, ssr) {
@@ -5265,33 +6057,6 @@ function enforceAnonPersistRule(formKey, ssr) {
   }
   return true;
 }
-function collectPersistedLeafPaths(form) {
-  const out = [];
-  walk(form, []);
-  return out;
-  function walk(node, prefix) {
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) {
-        walk(node[i], [...prefix, i]);
-      }
-      return;
-    }
-    if (isPlainRecord(node)) {
-      for (const key of Object.keys(node)) {
-        walk(node[key], [...prefix, key]);
-      }
-      return;
-    }
-    if (prefix.length === 0) return;
-    out.push(canonicalizePath(prefix).key);
-  }
-}
-function isDescendantPathKey(candidate, ancestor) {
-  if (candidate.length <= ancestor.length) return false;
-  if (!ancestor.endsWith("]")) return false;
-  const childPrefix = `${ancestor.slice(0, -1)},`;
-  return candidate.startsWith(childPrefix);
-}
 
 let injectedInstanceCounter = 0;
 function injectForm(input) {
@@ -5371,8 +6136,6 @@ function isLazyMarker(value) {
 }
 
 const NOOP_WIZARD_HISTORY = {
-  push() {
-  },
   replace() {
   },
   read() {
@@ -5399,21 +6162,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);
@@ -5472,68 +6230,16 @@ function buildWizardStatusesProxy(statuses) {
     }
     return result;
   });
-  const target = (() => {
-  });
-  const proxyToString = () => JSON.stringify(snapshot.value);
-  const proxyToPrimitive = (hint) => hint === "number" ? NaN : proxyToString();
-  return new Proxy(target, {
-    apply(_, __, args) {
-      const key = args[0];
-      if (key === void 0) return snapshot.value;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    get(_, key) {
-      if (typeof key === "symbol") {
-        if (key === Symbol.toPrimitive) return proxyToPrimitive;
-        return Reflect.get(target, key);
-      }
-      if (key === "toJSON") return () => snapshot.value;
-      if (key === "toString") return proxyToString;
-      if (key === "valueOf")
-        return function() {
-          return this;
-        };
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return computedEntry.value;
-    },
-    has(_, key) {
-      if (typeof key === "symbol") return Reflect.has(target, key);
-      return Object.hasOwn(statuses, key);
-    },
-    ownKeys() {
-      return Object.keys(statuses);
-    },
-    getOwnPropertyDescriptor(_, key) {
-      if (typeof key === "symbol") return void 0;
-      const computedEntry = statuses[key];
-      if (computedEntry === void 0) return void 0;
-      return {
-        configurable: true,
-        enumerable: true,
-        writable: false,
-        value: computedEntry.value
-      };
-    },
-    set(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 write to "${String(key)}" was ignored. Statuses derive from each form's meta; mutate the underlying form instead.`
-        );
-      }
-      return true;
-    },
-    deleteProperty(_, key) {
-      if (__DEV__) {
-        console.warn(
-          `[attaform] wizard.statuses is read-only \u2014 delete of "${String(key)}" was ignored.`
-        );
-      }
-      return true;
-    },
-    defineProperty: () => true
+  return buildCallableReadonlySnapshotProxy({
+    surface: "wizard.statuses",
+    snapshot: () => snapshot.value,
+    resolveKey: (key) => statuses[key]?.value,
+    // Single-key callable form. Strings stringify naturally; non-
+    // string args coerce via `String(arg)` and miss the lookup, which
+    // resolves to `undefined` (consistent with property-access).
+    resolveCall: (arg) => statuses[String(arg)]?.value,
+    ownKeys: () => Object.keys(statuses),
+    hasKey: (key) => Object.hasOwn(statuses, key)
   });
 }
 
@@ -5550,6 +6256,12 @@ const NOOP_VALID_STATUS = {
   submitted: false,
   errorCount: 0
 };
+function asStatusSource(form) {
+  return form;
+}
+function asSubmissionSource(form) {
+  return form;
+}
 function useWizard(options) {
   const rawSteps = Array.isArray(options.steps) ? options.steps : [];
   if (rawSteps.length === 0 && __DEV__) {
@@ -5637,10 +6349,12 @@ function useWizard(options) {
       return { configurable: true, enumerable: true, writable: false, value: form };
     }
   });
-  const slotCtx = computed(() => ({
+  const slotCtx = {
     forms: slotForms,
-    currentKey: activeKey.value === "" ? void 0 : activeKey.value
-  }));
+    get currentKey() {
+      return activeKey.value === "" ? void 0 : activeKey.value;
+    }
+  };
   function resolveSlot(slot, index, ctx) {
     if (typeof slot === "string") {
       return getOrBuildNoop(slot);
@@ -5663,12 +6377,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)) {
@@ -5678,18 +6386,17 @@ function useWizard(options) {
         idx,
         computed(() => {
           void lazyEpoch.value;
-          return marker.resolve(lazyCtx);
+          return marker.resolve(slotCtx);
         })
       );
     }
   }
   const compiledSteps = computed(() => {
-    const ctx = slotCtx.value;
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < rawSteps.length; i++) {
       const slot = rawSteps[i];
-      const form = resolveSlot(slot, i, ctx);
+      const form = resolveSlot(slot, i, slotCtx);
       if (form === void 0) continue;
       if (seen.has(form.key)) {
         if (__DEV__) {
@@ -5715,9 +6422,12 @@ function useWizard(options) {
     return -1;
   });
   const currentStep = computed(() => {
-    const key = activeKey.value;
-    if (key !== "") return key;
-    const first = compiledSteps.value[0];
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    if (idx >= 0 && idx < list.length) {
+      return list[idx].key;
+    }
+    const first = list[0];
     return first === void 0 ? void 0 : first.key;
   });
   const activeForm = computed(() => {
@@ -5740,36 +6450,94 @@ function useWizard(options) {
     for (const step of compiledSteps.value) out[step.key] = step.form;
     return out;
   });
-  const allValues = computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      out[step.key] = source.values;
+  function isFormReady(key) {
+    const store = registry.forms.get(key);
+    return store?.defaultsResolved.value === true;
+  }
+  function toWizardAggregateError(err, fallbackKey) {
+    const entry = {
+      formKey: err.formKey ?? fallbackKey,
+      path: err.path,
+      message: err.message
+    };
+    if (err.code !== void 0) entry.code = err.code;
+    return entry;
+  }
+  const valuesCache = /* @__PURE__ */ new Map();
+  function valuesFor(form) {
+    const cached = valuesCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedValues = computed(() => source.values);
+    valuesCache.set(form.key, computedValues);
+    return computedValues;
+  }
+  const errorsCache = /* @__PURE__ */ new Map();
+  function errorsFor(form) {
+    const cached = errorsCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = asStatusSource(form);
+    const computedErrors = computed(() => {
+      if (!isFormReady(form.key)) return [];
+      const errors = source.meta?.errors ?? [];
+      const list = [];
+      for (const err of errors) list.push(toWizardAggregateError(err, form.key));
+      return list;
+    });
+    errorsCache.set(form.key, computedErrors);
+    return computedErrors;
+  }
+  const allValues = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return valuesFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: valuesFor(form).value
+      };
     }
-    return out;
   });
-  const allErrors = computed(() => {
-    const out = {};
-    for (const step of compiledSteps.value) {
-      const source = step.form;
-      const list = [];
-      const store = registry.forms.get(step.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
-        const errors = source.meta?.errors ?? [];
-        for (const err of errors) {
-          const entry = {
-            formKey: step.key,
-            path: err.path,
-            message: err.message
-          };
-          if (err.code !== void 0) entry.code = err.code;
-          list.push(entry);
-        }
-      }
-      out[step.key] = list;
+  const allErrors = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return errorsFor(form).value;
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: errorsFor(form).value
+      };
     }
-    return out;
   });
   const seedRef = ref(void 0);
   const seedInput = options.defaultStatuses;
@@ -5792,11 +6560,9 @@ function useWizard(options) {
   function statusFor(form) {
     const cached = statusCache.get(form.key);
     if (cached !== void 0) return cached;
-    const source = form;
+    const source = asStatusSource(form);
     const computedStatus = computed(() => {
-      const store = registry.forms.get(form.key);
-      const resolved = store?.defaultsResolved.value === true;
-      if (resolved) {
+      if (isFormReady(form.key)) {
         const meta = source.meta;
         if (meta !== void 0 && meta !== null) {
           return {
@@ -5939,7 +6705,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();
     }
   }
@@ -5983,7 +6749,7 @@ function useWizard(options) {
   const submissionAttempts = ref(0);
   const done = ref(false);
   function activateForm(form) {
-    const source = form;
+    const source = asSubmissionSource(form);
     if (typeof source.activate === "function") {
       void source.activate();
     }
@@ -6083,7 +6849,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();
@@ -6115,15 +6881,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;
   }
@@ -6177,8 +6935,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);
@@ -6199,8 +6956,11 @@ function useWizard(options) {
               moveTo(firstFailedKey);
               await nextTick();
               const failedForm = formsRecord.value[firstFailedKey];
-              if (failedForm !== void 0 && typeof failedForm.applyInvalidSubmitPolicy === "function") {
-                failedForm.applyInvalidSubmitPolicy();
+              if (failedForm !== void 0) {
+                const failedSource = asSubmissionSource(failedForm);
+                if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
+                  failedSource.applyInvalidSubmitPolicy();
+                }
               }
             }
           }
@@ -6215,7 +6975,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];
@@ -6265,12 +7025,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;
     },
@@ -6401,5 +7157,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, defaultShouldShowErrors as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
-//# sourceMappingURL=attaform.CZ-XtZt_.mjs.map
+export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
+//# sourceMappingURL=attaform.CKFbKFb6.mjs.map