attaform 0.20.2 → 0.21.0

package/dist/shared/{attaform.CwLjUqmQ.cjs → attaform.BUszFoKq.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.z5j3LwJz.cjs');
+const paths = require('./attaform.BA3vRDos.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -460,17 +460,51 @@ function structuralSnapshot(value) {
   return out;
 }
 
-const defaultDisplayState = (field, formMeta) => {
-  const gateOpen = formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
-  if (!gateOpen) return "idle";
-  if (field.validating === true) return "pending";
+function isGateOpen(field, formMeta) {
+  return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
+}
+function computeVerdict(field, formMeta) {
+  if (!isGateOpen(field, formMeta)) return "idle";
   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";
-};
+}
+const DEFAULT_TIMINGS = { showDelay: 100, minVisible: 120 };
+const FOCUS_OUT_GRACE = 16;
+const defaultFamily = /* @__PURE__ */ new WeakSet();
+function isDefaultDisplayState(fn) {
+  return defaultFamily.has(fn);
+}
+function makeDefaultDisplayState({
+  showDelay,
+  minVisible
+}) {
+  const reducer = (prev, { field, formMeta, validatingSince, now }) => {
+    const verdict = computeVerdict(field, formMeta);
+    if (!isGateOpen(field, formMeta)) return { display: verdict };
+    if (validatingSince === null) {
+      if (prev.display === "pending") {
+        const shownAt = prev.pendingShownAt ?? now;
+        if (now < shownAt + minVisible)
+          return { display: "pending", pendingShownAt: shownAt, reviewAt: shownAt + minVisible };
+      }
+      return { display: verdict };
+    }
+    if (prev.display === "pending")
+      return { display: "pending", pendingShownAt: prev.pendingShownAt ?? now };
+    const window = field.focused === false ? Math.min(showDelay, FOCUS_OUT_GRACE) : showDelay;
+    if (now - validatingSince < window) {
+      return { display: prev.display, reviewAt: validatingSince + window };
+    }
+    return { display: "pending", pendingShownAt: now, reviewAt: now + minVisible };
+  };
+  defaultFamily.add(reducer);
+  return reducer;
+}
+const defaultDisplayState = makeDefaultDisplayState(DEFAULT_TIMINGS);
 function resolveGetDisplayState(config) {
   return config ?? defaultDisplayState;
 }
@@ -627,7 +661,19 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
 }
 function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
   const base = buildLeafFieldStateBase(state, segments, key, formInstanceId);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
+  const validatingSince = state.fieldValidatingSince.get(key) ?? null;
+  return decorateWithDerivedProps(
+    base,
+    state,
+    getFormMetaBase,
+    key,
+    validatingSince,
+    false,
+    // revealedDescendantError: leaves have no descendants
+    false,
+    // isRoot: a leaf is never the form root
+    getDisplayState
+  );
 }
 function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
@@ -643,8 +689,11 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let blurredAfterInteraction = false;
   let connected = false;
   let validating = false;
+  let validatingSince = null;
   let updatedAt = null;
   let asyncPending = false;
+  const submissionAttempts = state.submissionAttempts.value;
+  const blurredLeafSegments = [];
   for (const [leafKey, entry] of state.originals) {
     if (!paths.isPathPrefix(segments, entry.segments)) continue;
     if (segments.length === entry.segments.length) continue;
@@ -659,9 +708,18 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     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?.blurredAfterInteraction === true) {
+      blurredAfterInteraction = true;
+      blurredLeafSegments.push(entry.segments);
+    }
     if (leafRecord?.connected === true) connected = true;
-    if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) validating = true;
+    if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) {
+      validating = true;
+      const leafGateOpen = submissionAttempts > 0 || leafRecord?.blurredAfterInteraction === true;
+      const since = state.fieldValidatingSince.get(leafKey);
+      if (leafGateOpen && since !== void 0 && (validatingSince === null || since < validatingSince))
+        validatingSince = since;
+    }
     if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
@@ -673,6 +731,13 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     dirty = true;
   }
   const errors = aggregateErrorsAt(state, segments);
+  const revealedDescendantError = errors.length > 0 && errors.some((e) => {
+    const ePath = e.path;
+    if (ePath.length === segments.length && ePath.every((s, i) => s === segments[i])) return false;
+    if (submissionAttempts > 0) return true;
+    if (ePath.length === 1 && ePath[0] === "") return blurredAfterInteraction;
+    return blurredLeafSegments.some((s) => paths.isPathPrefix(ePath, s));
+  });
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
   const gated = asyncPending && !state.firstValidationDone.value;
   const valid = !gated && errors.length === 0 && !validating;
@@ -680,43 +745,70 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
   const label = resolved.label || humanize(lastSegment);
   return {
-    value,
-    original,
-    pristine,
-    dirty,
-    focused,
-    blurred,
-    touched,
-    interacted,
-    blurredAfterInteraction,
-    connected,
-    element: null,
-    elements: EMPTY_ELEMENTS,
-    updatedAt,
-    errors,
-    validating,
-    valid,
-    path: segments,
-    ...computeFieldIdentity(formInstanceId, state.formKey, key),
-    key: state.arrayElementKey(segments),
-    blank,
-    label,
-    description: resolved.description,
-    placeholder: resolved.placeholder,
-    meta: resolved.meta
+    base: {
+      value,
+      original,
+      pristine,
+      dirty,
+      focused,
+      blurred,
+      touched,
+      interacted,
+      blurredAfterInteraction,
+      connected,
+      element: null,
+      elements: EMPTY_ELEMENTS,
+      updatedAt,
+      errors,
+      validating,
+      valid,
+      path: segments,
+      ...computeFieldIdentity(formInstanceId, state.formKey, key),
+      key: state.arrayElementKey(segments),
+      blank,
+      label,
+      description: resolved.description,
+      placeholder: resolved.placeholder,
+      meta: resolved.meta
+    },
+    validatingSince,
+    revealedDescendantError
   };
 }
 function buildContainerFieldState(state, segments, key, formInstanceId, getFormMetaBase, getDisplayState) {
-  const base = buildContainerFieldStateBase(state, segments, key, formInstanceId);
-  return decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState);
+  const { base, validatingSince, revealedDescendantError } = buildContainerFieldStateBase(
+    state,
+    segments,
+    key,
+    formInstanceId
+  );
+  return decorateWithDerivedProps(
+    base,
+    state,
+    getFormMetaBase,
+    key,
+    validatingSince,
+    revealedDescendantError,
+    segments.length === 0,
+    getDisplayState
+  );
 }
-function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState) {
+function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, revealedDescendantError, isRoot, getDisplayState) {
   const firstError = base.errors[0];
   const predicate = getDisplayState ?? state.getDisplayState;
   const formMeta = getFormMetaBase();
-  let displayState;
+  const ctx = {
+    field: base,
+    formMeta,
+    validatingSince,
+    // The engine's clock. Frozen to 0 under SSR (no clock, nothing in
+    // flight) so the reducer returns the plain verdict and hydration matches.
+    now: state.ssr ? 0 : Date.now()
+  };
+  let machine;
+  let rollupApplies = isDefaultDisplayState(predicate);
   try {
-    displayState = predicate(base, formMeta);
+    machine = state.displayEngine.resolve(key, ctx, predicate);
   } catch (err) {
     if (paths.__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
       warnedDisplayStatePredicates.add(predicate);
@@ -725,8 +817,11 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, getDisplayState)
         err
       );
     }
-    displayState = defaultDisplayState(base, formMeta);
+    machine = state.displayEngine.resolve(key, ctx, defaultDisplayState);
+    rollupApplies = true;
   }
+  const submitValidating = rollupApplies && isRoot && state.submitting.value && state.activeValidations.value > 0;
+  const displayState = machine.display === "pending" || submitValidating ? "pending" : rollupApplies && revealedDescendantError ? "error" : machine.display;
   return {
     ...base,
     displayState,
@@ -1419,90 +1514,6 @@ async function getStorageAdapter(storage) {
     }
   }
 }
-const PERSISTED_ENVELOPE_VERSION = 6;
-function readPersistedPayload(value) {
-  if (value === null || value === void 0 || typeof value !== "object") return null;
-  const envelope = value;
-  if (typeof envelope.v !== "number") return null;
-  if (envelope.v !== PERSISTED_ENVELOPE_VERSION) {
-    warnVersionMismatch(envelope.v);
-    return null;
-  }
-  if (envelope.data === void 0 || typeof envelope.data !== "object") return null;
-  return envelope;
-}
-const warnedVersions = paths.__DEV__ ? /* @__PURE__ */ new Set() : null;
-function warnVersionMismatch(observedVersion) {
-  if (warnedVersions === null) return;
-  if (warnedVersions.has(observedVersion)) return;
-  warnedVersions.add(observedVersion);
-  console.warn(
-    `[attaform] Dropping persisted draft \u2014 envelope v=${observedVersion}, but this version of the library expects v=${PERSISTED_ENVELOPE_VERSION}. The persisted shape changed across releases; older drafts can't be restored. New drafts saved this session will use the current envelope.`
-  );
-}
-function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
-  let transientList;
-  if (blankPaths !== void 0 && blankPaths.size > 0) {
-    transientList = [...blankPaths];
-  }
-  if (include === "form") {
-    if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
-    return {
-      v: PERSISTED_ENVELOPE_VERSION,
-      data: { form, blankPaths: transientList }
-    };
-  }
-  return {
-    v: PERSISTED_ENVELOPE_VERSION,
-    data: {
-      form,
-      schemaErrors: [...schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
-      userErrors: [...userErrors.entries()].map(([k, v]) => [k, [...v]]),
-      ...transientList !== void 0 ? { blankPaths: transientList } : {}
-    }
-  };
-}
-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) {
-      runWrite();
-      return;
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      runWrite();
-    }, debounceMs);
-  }
-  async function flush() {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-      runWrite();
-    }
-    while (pending !== null) {
-      const awaited = pending;
-      await awaited;
-      if (pending === awaited) break;
-    }
-  }
-  function cancel() {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  }
-  return { schedule, flush, cancel };
-}
 function resolveStorageKeyBase(config, formKey) {
   return config.key ?? `${PERSISTENCE_KEY_PREFIX}${formKey}`;
 }
@@ -1549,47 +1560,6 @@ async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
     }
   }
 }
-function pluckPaths(form, pathKeys) {
-  let sparse = void 0;
-  for (const pathKey of pathKeys) {
-    const segments = paths.segmentsForPathKey(pathKey);
-    if (segments === null) continue;
-    const value = getAtPath(form, segments);
-    if (value === void 0) continue;
-    sparse = setAtPath(sparse ?? {}, segments, value);
-  }
-  return sparse ?? {};
-}
-function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
-  const acknowledgedSensitive = [];
-  for (const key of optedInPaths) {
-    const segs = paths.segmentsForPathKey(key);
-    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
-  }
-  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => paths.isPathPrefix(prefix, path));
-  const walk = (path, value) => {
-    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {
-      return void 0;
-    }
-    if (value === null || typeof value !== "object") return value;
-    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
-    if (!isPlainRecord(value)) return value;
-    const out = {};
-    for (const key of Object.keys(value)) {
-      const walked = walk([...path, key], value[key]);
-      if (walked !== void 0) safeAssign(out, key, walked);
-    }
-    return out;
-  };
-  return walk([], form);
-}
-function filterErrorsByPaths(errors, pathKeys) {
-  const out = /* @__PURE__ */ new Map();
-  for (const [key, value] of errors) {
-    if (pathKeys.has(key)) out.set(key, value);
-  }
-  return out;
-}
 function mergeSparseHydration(schemaDefaults, sparse, schema) {
   return mergeDeep(schemaDefaults, sparse, [], schema);
 }
@@ -1827,6 +1797,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.submitting.value = true;
         state.submitError.value = null;
         state.cancelFieldValidation();
+        state.displayEngine.clear();
         state.activeValidations.value += 1;
         const refinement = await runRefinementValidation(state.form.value, void 0);
         const merged = composeWithDerivedBlank(refinement, void 0);
@@ -2643,7 +2614,12 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
   const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, paths.ROOT_PATH, paths.ROOT_PATH_KEY, formInstanceId);
+    const { base: rootBase } = buildContainerFieldStateBase(
+      state,
+      paths.ROOT_PATH,
+      paths.ROOT_PATH_KEY,
+      formInstanceId
+    );
     return {
       ...rootBase,
       submitting: state.submitting.value,
@@ -2978,7 +2954,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       instanceId: formInstanceId
     })
   );
-  const persistence = state.modules.get(PERSISTENCE_MODULE_KEY);
+  const persistenceHandle = state.modules.get(PERSISTENCE_MODULE_KEY);
   const reset = (nextDefaultValues) => {
     if (nextDefaultValues === void 0) {
       state.reset();
@@ -2993,15 +2969,15 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.originalBlankPaths.add(pathKey);
       }
     }
-    if (persistence !== void 0) {
-      void persistence.clearPersistedDraft().catch(() => void 0);
+    if (persistenceHandle !== void 0) {
+      void persistenceHandle.ready.then((m) => m?.clearPersistedDraft()).catch(() => void 0);
     }
   };
   const resetField = (pathInput) => {
     const segments = paths.canonicalizePath(pathInput).segments;
     state.resetField(segments);
-    if (persistence !== void 0) {
-      void persistence.clearPersistedDraft(segments).catch(() => void 0);
+    if (persistenceHandle !== void 0) {
+      void persistenceHandle.ready.then((m) => m?.clearPersistedDraft(segments)).catch(() => void 0);
     }
   };
   function clear(pathInput) {
@@ -3019,10 +2995,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
     )) {
       return;
     }
+    if (persistenceHandle === void 0) return;
+    const persistence = await persistenceHandle.ready;
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
   const clearPersistedDraft = async (pathInput) => {
+    if (persistenceHandle === void 0) return;
+    const persistence = await persistenceHandle.ready;
     if (persistence === void 0) return;
     if (pathInput === void 0) {
       await persistence.clearPersistedDraft();
@@ -3205,6 +3185,93 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
 }
 
+const IDLE = Object.freeze({ display: "idle" });
+const MAX_DELAY = 2147483647;
+function createDisplayEngine(ssr) {
+  const machines = /* @__PURE__ */ new Map();
+  const tick = vue.ref(0);
+  let timer = null;
+  let timerTarget = null;
+  let lastFiredTarget = null;
+  function clearTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+      timerTarget = null;
+    }
+  }
+  function nearestReviewAt() {
+    let min = null;
+    for (const m of machines.values()) {
+      if (m.reviewAt === void 0 || !Number.isFinite(m.reviewAt)) continue;
+      if (min === null || m.reviewAt < min) min = m.reviewAt;
+    }
+    return min;
+  }
+  function rearm(now) {
+    const target = nearestReviewAt();
+    if (target === null) {
+      clearTimer();
+      return;
+    }
+    if (timer !== null && timerTarget === target) return;
+    if (target === lastFiredTarget) {
+      clearTimer();
+      return;
+    }
+    clearTimer();
+    timerTarget = target;
+    timer = setTimeout(
+      () => {
+        timer = null;
+        timerTarget = null;
+        lastFiredTarget = target;
+        tick.value++;
+      },
+      Math.min(MAX_DELAY, Math.max(0, target - now))
+    );
+  }
+  function resolve(key, ctx, reducer) {
+    void tick.value;
+    const prev = machines.get(key) ?? IDLE;
+    const machine = reducer(prev, ctx);
+    if (ssr) return machine;
+    const active = machine.display !== "idle" || machine.reviewAt !== void 0 && Number.isFinite(machine.reviewAt);
+    if (active) machines.set(key, machine);
+    else machines.delete(key);
+    rearm(ctx.now);
+    return machine;
+  }
+  function clear() {
+    machines.clear();
+    clearTimer();
+    lastFiredTarget = null;
+  }
+  let detachVisibility = null;
+  if (!ssr && typeof document !== "undefined") {
+    const onVisible = () => {
+      if (document.visibilityState === "visible" && machines.size > 0) tick.value++;
+    };
+    document.addEventListener("visibilitychange", onVisible);
+    detachVisibility = () => document.removeEventListener("visibilitychange", onVisible);
+  }
+  function dispose() {
+    clear();
+    if (detachVisibility !== null) {
+      detachVisibility();
+      detachVisibility = null;
+    }
+  }
+  return {
+    resolve,
+    clear,
+    dispose,
+    size: () => machines.size,
+    has: (key) => machines.has(key),
+    hasTimer: () => timer !== null
+  };
+}
+
 function applyDuStubs(schema, data, options = {}) {
   const warned = options.warn === true ? /* @__PURE__ */ new Set() : void 0;
   return walkDuStubs(schema, data, options.basePath ?? [], warned);
@@ -3543,6 +3610,7 @@ function createArrayBookkeeping(deps) {
     blankPaths,
     originalBlankPaths,
     fieldValidationCounts,
+    fieldValidatingSince,
     fieldValidationState,
     schemaErrors,
     activeValidations,
@@ -3568,6 +3636,7 @@ function createArrayBookkeeping(deps) {
     }));
     migrateSetSubtree(blankPaths, arrayPath, remap);
     migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateMapSubtree(fieldValidatingSince, arrayPath, remap, (since) => since);
     migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
     arrayIdentity.applyRemap(arrayPath, remap);
   }
@@ -3627,6 +3696,18 @@ function isHydratedFieldRecord(value) {
   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 withClearedHistoryFlags(record, now) {
+  return {
+    path: record.path,
+    updatedAt: now,
+    connected: record.connected,
+    focused: record.focused,
+    blurred: record.blurred,
+    touched: false,
+    interacted: false,
+    blurredAfterInteraction: false
+  };
+}
 function isHydratedValidationErrorArray(value) {
   if (!Array.isArray(value)) return false;
   for (const entry of value) {
@@ -3754,6 +3835,9 @@ function createFormStore(options) {
   const resolvedIsSensitivePath = options.isSensitivePath ?? paths.isSensitivePath;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
+  const fieldValidatingSince = vue.reactive(/* @__PURE__ */ new Map());
+  const displayEngine = createDisplayEngine(ssr);
+  registerCleanup(() => displayEngine.dispose());
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
   const schemaResponse = schema.getDefaultValues({
     useDefaultSchemaValues: true,
@@ -3882,12 +3966,18 @@ function createFormStore(options) {
   }
   const fieldValidationCounts = vue.reactive(/* @__PURE__ */ new Map());
   function incFieldValidation(key) {
-    fieldValidationCounts.set(key, (fieldValidationCounts.get(key) ?? 0) + 1);
+    fieldValidatingSince.set(key, ssr ? 0 : Date.now());
+    const prevCount = fieldValidationCounts.get(key) ?? 0;
+    fieldValidationCounts.set(key, prevCount + 1);
   }
   function decFieldValidation(key) {
     const next = (fieldValidationCounts.get(key) ?? 0) - 1;
-    if (next <= 0) fieldValidationCounts.delete(key);
-    else fieldValidationCounts.set(key, next);
+    if (next <= 0) {
+      fieldValidationCounts.delete(key);
+      fieldValidatingSince.delete(key);
+    } else {
+      fieldValidationCounts.set(key, next);
+    }
   }
   const initStamp = (/* @__PURE__ */ new Date()).toISOString();
   diffAndApply({}, schemaInitialData, [], (patch) => {
@@ -3975,6 +4065,7 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     fieldValidationCounts,
+    fieldValidatingSince,
     fieldValidationState,
     schemaErrors,
     activeValidations,
@@ -4242,7 +4333,7 @@ function createFormStore(options) {
       prev.controller.abort();
     }
     const controller = new AbortController();
-    const fresh = { controller, timer: null, settled: false };
+    const fresh = { controller, timer: null, settled: false, released: false };
     fieldValidationState.set(key, fresh);
     const myEpoch = ++scheduleEpoch;
     const run = () => {
@@ -4280,8 +4371,10 @@ function createFormStore(options) {
         applySchemaErrorsForSubtree(scopePath ?? [], restamped);
       }).catch(() => {
       }).finally(() => {
-        activeValidations.value = Math.max(0, activeValidations.value - 1);
-        decFieldValidation(key);
+        if (!fresh.released) {
+          activeValidations.value = Math.max(0, activeValidations.value - 1);
+          decFieldValidation(key);
+        }
         fresh.settled = true;
       });
     };
@@ -4303,6 +4396,22 @@ function createFormStore(options) {
     }
     fieldValidationState.clear();
   }
+  function cancelFieldValidationUnder(prefix) {
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = paths.segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!paths.isPathPrefix(prefix, segs)) continue;
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled && !entry.released) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
+        entry.released = true;
+      }
+      entry.controller.abort();
+      fieldValidationState.delete(key);
+    }
+  }
   function onFormChange(listener) {
     formChangeListeners.add(listener);
     return () => {
@@ -4353,6 +4462,7 @@ function createFormStore(options) {
     drainHooks.length = 0;
     modules.clear();
     cancelFieldValidation();
+    fieldValidatingSince.clear();
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
@@ -4699,16 +4809,7 @@ function createFormStore(options) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const [pathKey, record] of fields) {
-      fields.set(pathKey, {
-        path: record.path,
-        updatedAt: now,
-        connected: record.connected,
-        focused: record.focused,
-        blurred: record.blurred,
-        touched: false,
-        interacted: false,
-        blurredAfterInteraction: false
-      });
+      fields.set(pathKey, withClearedHistoryFlags(record, now));
     }
     submissionGeneration.value += 1;
     submitting.value = false;
@@ -4718,6 +4819,8 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    displayEngine.clear();
+    fieldValidatingSince.clear();
     pathSnapshots.clear();
     scheduleEpoch = 0;
     lastCommittedEpoch = 0;
@@ -4733,6 +4836,12 @@ function createFormStore(options) {
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = paths.canonicalizePath(path);
     variantMemory.clearUnderPath(targetSegments);
+    cancelFieldValidationUnder(targetSegments);
+    for (const [snapKey] of [...pathSnapshots]) {
+      const segs = paths.segmentsForPathKey(snapKey);
+      if (segs === null) continue;
+      if (paths.isPathPrefix(targetSegments, segs)) pathSnapshots.delete(snapKey);
+    }
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
       const wrote = setValueAtPath(targetSegments, leafEntry.value);
@@ -4782,16 +4891,7 @@ function createFormStore(options) {
   function clearFieldRecordFlags(pathKey) {
     const record = fields.get(pathKey);
     if (record === void 0) return;
-    fields.set(pathKey, {
-      path: record.path,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      connected: record.connected,
-      focused: record.focused,
-      blurred: record.blurred,
-      touched: false,
-      interacted: false,
-      blurredAfterInteraction: false
-    });
+    fields.set(pathKey, withClearedHistoryFlags(record, (/* @__PURE__ */ new Date()).toISOString()));
   }
   function isPristineAtPath(path) {
     const { key, segments } = paths.canonicalizePath(path);
@@ -4871,6 +4971,8 @@ function createFormStore(options) {
     pathHasAsyncValidation,
     pathHasAsyncValidationByKey,
     fieldValidationCounts,
+    fieldValidatingSince,
+    displayEngine,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
@@ -4955,7 +5057,7 @@ function errorsEqual(a, b) {
   }
   return true;
 }
-function diffBlankPaths$1(prev, curr) {
+function diffBlankPaths(prev, curr) {
   const added = [];
   const removed = [];
   for (const k of curr) if (!prev.has(k)) added.push(k);
@@ -5043,7 +5145,7 @@ function createHistoryModule(state, config) {
     diffAndApply(prevSnap.form, newSnap.form, [], (p) => formPatches.push(p));
     const prevBlankSet = new Set(prevSnap.blankPaths);
     const currBlankSet = new Set(newSnap.blankPaths);
-    const blankDiff = diffBlankPaths$1(prevBlankSet, currBlankSet);
+    const blankDiff = diffBlankPaths(prevBlankSet, currBlankSet);
     const delta = {
       formPatches,
       blankPathsAdded: blankDiff.added,
@@ -5110,643 +5212,6 @@ function createHistoryModule(state, config) {
   };
 }
 
-function wirePersistence(state, config) {
-  let fingerprint;
-  try {
-    fingerprint = hashStableString(state.schema.fingerprint());
-  } catch (err) {
-    if (paths.__DEV__) {
-      console.warn(
-        `[attaform] Could not fingerprint the schema for form '${state.formKey}': ${err instanceof Error ? err.message : String(err)}. Persistence falls back to a fingerprint-free key, so a schema change won't auto-invalidate a saved draft.`
-      );
-    }
-    fingerprint = "unfingerprinted";
-  }
-  const base = resolveStorageKeyBase(config, state.formKey);
-  const key = `${base}:${fingerprint}`;
-  const debounceMs = normalizeNumericOption({
-    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,
-    source: "useForm.persist.debounceMs",
-    allowInfinity: false,
-    min: 0,
-    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS
-  });
-  const include = config.include ?? "form";
-  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
-  const adapterPromise = getStorageAdapter(config.storage);
-  let disposed = false;
-  const isDisposed = () => disposed;
-  let inFlightFinalFlush = null;
-  let pendingOptedInPaths = null;
-  const writer = createDebouncedWriter(async () => {
-    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
-    pendingOptedInPaths = null;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    if (optedInPaths.size === 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const rawForm = vue.toRaw(state.form.value);
-    const filteredForm = stripUnacknowledgedSensitiveLeaves(
-      pluckPaths(rawForm, optedInPaths),
-      optedInPaths,
-      state.isSensitivePath
-    );
-    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
-    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
-    const filteredTransientEmpty = /* @__PURE__ */ new Set();
-    for (const tk of state.blankPaths) {
-      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
-    }
-    const payload = buildPersistedPayload(
-      filteredForm,
-      include,
-      filteredSchemaErrors,
-      filteredUserErrors,
-      filteredTransientEmpty
-    );
-    await adapter.setItem(key, payload);
-  }, debounceMs);
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (isDisposed() || inFlightFinalFlush !== null) return;
-    if (meta?.crossTab === true) return;
-    if (meta?.persist !== true) return;
-    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
-    writer.schedule();
-  });
-  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
-    if (isDisposed()) return;
-    void (async () => {
-      await writer.flush();
-      if (isDisposed()) return;
-      const adapter = await adapterPromise;
-      if (isDisposed()) return;
-      await adapter.removeItem(key);
-    })();
-  }) : () => void 0;
-  const handlePageHide = () => {
-    if (isDisposed()) return;
-    void writer.flush();
-  };
-  if (typeof window !== "undefined") {
-    window.addEventListener("pagehide", handlePageHide);
-  }
-  void (async () => {
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    void cleanupOrphanKeys(adapter, base, key);
-    try {
-      const raw = await adapter.getItem(key);
-      const payload = readPersistedPayload(raw);
-      if (payload === null) {
-        if (raw !== null && raw !== void 0) {
-          await adapter.removeItem(key);
-        }
-        return;
-      }
-      if (isDisposed()) return;
-      const merged = mergeSparseHydration(
-        vue.toRaw(state.form.value),
-        payload.data.form,
-        state.schema
-      );
-      state.applyFormReplacement(merged, { hydration: true });
-      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
-      for (const k of persistedLeafPaths) {
-        state.blankPaths.delete(k);
-        state.originalBlankPaths.delete(k);
-      }
-      for (const k of payload.data.blankPaths ?? []) {
-        state.blankPaths.add(k);
-        state.originalBlankPaths.add(k);
-      }
-      if (include === "form+errors") {
-        if (payload.data.schemaErrors !== void 0) {
-          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
-          state.setAllSchemaErrors(flat);
-        }
-        if (payload.data.userErrors !== void 0) {
-          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
-          state.setAllUserErrors(flat);
-        }
-      }
-      state.scheduleFieldValidation(
-        [],
-        true
-        /* immediate */
-      );
-    } catch {
-    }
-  })();
-  async function writePathImmediately(path) {
-    if (isDisposed()) return;
-    await writer.flush();
-    if (isDisposed()) return;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    const value = getAtPath(vue.toRaw(state.form.value), path);
-    const nextForm = setAtPath(existing?.data.form ?? {}, path, value);
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing?.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    for (const liveKey of state.blankPaths) {
-      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
-        transientSet.add(liveKey);
-      }
-    }
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
-    const userMap = new Map(existing?.data.userErrors ?? []);
-    const currentSchema = state.schemaErrors.get(pathKey);
-    const currentUser = state.userErrors.get(pathKey);
-    if (currentSchema !== void 0 && currentSchema.length > 0) {
-      schemaMap.set(pathKey, [...currentSchema]);
-    } else {
-      schemaMap.delete(pathKey);
-    }
-    if (currentUser !== void 0 && currentUser.length > 0) {
-      userMap.set(pathKey, [...currentUser]);
-    } else {
-      userMap.delete(pathKey);
-    }
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
-  }
-  async function clearPersistedDraft(path) {
-    if (isDisposed()) return;
-    await writer.flush();
-    if (isDisposed()) return;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    if (path === void 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    if (existing === null) return;
-    const nextForm = deleteAtPath(existing.data.form, path);
-    if (isEmptyContainer(nextForm)) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    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 awaitPendingWrites() {
-    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
-    if (isDisposed()) return Promise.resolve();
-    return writer.flush().catch(() => void 0);
-  }
-  function dispose() {
-    if (isDisposed() || inFlightFinalFlush !== null) return;
-    unsubscribeChange();
-    unsubscribeSuccess();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("pagehide", handlePageHide);
-    }
-    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
-      disposed = true;
-      inFlightFinalFlush = null;
-    });
-  }
-  return {
-    wiredConfig: config,
-    writePathImmediately,
-    clearPersistedDraft,
-    awaitPendingWrites,
-    dispose
-  };
-}
-function isEmptyContainer(value) {
-  if (value === void 0 || value === null) return true;
-  if (Array.isArray(value)) return value.length === 0;
-  if (isPlainRecord(value)) return Object.keys(value).length === 0;
-  return false;
-}
-function collectPersistedLeafPaths(form) {
-  const out = [];
-  walk(form, []);
-  return out;
-  function walk(node, prefix) {
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) {
-        walk(node[i], [...prefix, i]);
-      }
-      return;
-    }
-    if (isPlainRecord(node)) {
-      for (const key of Object.keys(node)) {
-        walk(node[key], [...prefix, key]);
-      }
-      return;
-    }
-    if (prefix.length === 0) return;
-    out.push(paths.canonicalizePath(prefix).key);
-  }
-}
-function isDescendantPathKey(candidate, ancestor) {
-  if (candidate.length <= ancestor.length) return false;
-  if (!ancestor.endsWith("]")) return false;
-  const childPrefix = `${ancestor.slice(0, -1)},`;
-  return candidate.startsWith(childPrefix);
-}
-
-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 isInboundShapeAcceptable(schema, path, value) {
-  if (isFileLikeValue(value)) return false;
-  let kind;
-  if (Array.isArray(value)) {
-    kind = "array";
-  } else if (value !== null && typeof value === "object" && isPlainRecord(value)) {
-    kind = "object";
-  } else {
-    kind = slimKindOf(value);
-  }
-  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
-  if (!accepted.has(kind)) return false;
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      if (!isInboundShapeAcceptable(schema, [...path, i], value[i])) return false;
-    }
-    return true;
-  }
-  if (isPlainRecord(value)) {
-    for (const key of Object.keys(value)) {
-      if (!isInboundShapeAcceptable(schema, [...path, key], value[key])) return false;
-    }
-    return true;
-  }
-  return true;
-}
-function 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)) {
-      safeAssign(out, key, void 0);
-      continue;
-    }
-    safeAssign(out, key, stripSensitivePathsDeep(src[key], childPath, isSensitivePath));
-  }
-  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;
-  }
-}
-function generateSenderId() {
-  try {
-    return globalThis.crypto.randomUUID();
-  } catch {
-    return `atta-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
-  }
-}
-function createMultiTabSyncModule(state, channelName, options) {
-  if (typeof BroadcastChannel === "undefined") {
-    return {
-      dispose: () => void 0,
-      lifecycle: () => "established",
-      senderId: "",
-      channelName
-    };
-  }
-  let channel;
-  try {
-    channel = new BroadcastChannel(channelName);
-  } catch {
-    return {
-      dispose: () => void 0,
-      lifecycle: () => "established",
-      senderId: "",
-      channelName
-    };
-  }
-  const senderId = generateSenderId();
-  let lifecycle = "joining";
-  let disposed = false;
-  const peerIds = /* @__PURE__ */ new Set();
-  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 {
-    }
-  }
-  function refreshPrior() {
-    prior = {
-      form: snapshotForm(state.form.value),
-      blankPathsSnapshot: [...state.blankPaths]
-    };
-  }
-  function isPathLocallySuppressed(path) {
-    if (options.isSensitivePath(path)) return true;
-    const { key } = paths.canonicalizePath([...path]);
-    if (options.noSyncPaths.has(key)) return true;
-    return false;
-  }
-  function postPatches() {
-    if (lifecycle !== "established") return;
-    const next = snapshotForm(state.form.value);
-    const rawPatches = [];
-    diffAndApply(prior.form, next, [], (p) => rawPatches.push(p));
-    const safePatches = [];
-    for (const p of rawPatches) {
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && isFileLikeValue(p.value)) continue;
-      safePatches.push(p);
-    }
-    const { added, removed } = diffBlankPaths(prior.blankPathsSnapshot, state.blankPaths);
-    if (safePatches.length === 0 && added.length === 0 && removed.length === 0) {
-      prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
-      return;
-    }
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "patches",
-      senderId,
-      formPatches: safePatches,
-      blankPathsAdded: added,
-      blankPathsRemoved: removed
-    });
-    prior = { form: next, blankPathsSnapshot: [...state.blankPaths] };
-  }
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (disposed) return;
-    if (lifecycle !== "established") return;
-    if (meta?.crossTab === true) return;
-    if (meta?.hydration === true) {
-      refreshPrior();
-      return;
-    }
-    postPatches();
-  });
-  function applyIncomingForm(form, blankPaths) {
-    state.blankPaths.clear();
-    for (const k of blankPaths) state.blankPaths.add(k);
-    state.applyFormReplacement(form, { crossTab: true, persist: false });
-    refreshPrior();
-  }
-  function handlePatches(msg) {
-    if (lifecycle !== "established") return;
-    const safePatches = [];
-    for (const p of msg.formPatches) {
-      if (!Array.isArray(p.path)) continue;
-      if (isPathLocallySuppressed(p.path)) continue;
-      if ("value" in p && !isInboundShapeAcceptable(state.schema, p.path, p.value)) {
-        continue;
-      }
-      safePatches.push(p);
-    }
-    const safeBlankAdded = [];
-    for (const k of msg.blankPathsAdded) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
-    }
-    const safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = paths.canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
-    }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
-      return;
-    }
-    const candidate = applyPatchesForward(state.form.value, safePatches);
-    try {
-      options.validateForm(state.form.value);
-      try {
-        options.validateForm(candidate);
-      } catch {
-        return;
-      }
-    } catch {
-    }
-    const nextBlankPaths = new Set(state.blankPaths);
-    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
-    for (const k of safeBlankAdded) nextBlankPaths.add(k);
-    applyIncomingForm(candidate, [...nextBlankPaths]);
-  }
-  function handleSnapshot(msg) {
-    if (lifecycle !== "joining") return;
-    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
-    if (snapshotTimeoutTimer !== null) {
-      clearTimeout(snapshotTimeoutTimer);
-      snapshotTimeoutTimer = null;
-    }
-    if (joinCollectionTimer !== null) {
-      clearTimeout(joinCollectionTimer);
-      joinCollectionTimer = null;
-    }
-    applyIncomingForm(msg.form, msg.blankPaths);
-    lifecycle = "established";
-    peerIds.clear();
-  }
-  function respondToHello() {
-    safePost({ v: PROTOCOL_VERSION, kind: "announce", senderId });
-  }
-  function respondToSnapshotRequest(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]
-    });
-  }
-  channel.onmessage = (event) => {
-    if (disposed) return;
-    try {
-      const data = event.data;
-      if (!isValidSyncMessage(data)) return;
-      const msg = data;
-      if (msg.senderId === senderId) return;
-      switch (msg.kind) {
-        case "hello":
-          if (lifecycle !== "established") return;
-          respondToHello();
-          break;
-        case "announce":
-          if (lifecycle === "joining") peerIds.add(msg.senderId);
-          break;
-        case "requestSnapshot":
-          if (lifecycle !== "established") return;
-          if (msg.targetId !== senderId) return;
-          respondToSnapshotRequest(msg.senderId);
-          break;
-        case "snapshot":
-          handleSnapshot(msg);
-          break;
-        case "patches":
-          handlePatches(msg);
-          break;
-      }
-    } catch {
-    }
-  };
-  function electLeaderAndRequest() {
-    if (disposed) return;
-    if (peerIds.size === 0) {
-      lifecycle = "established";
-      refreshPrior();
-      return;
-    }
-    const sorted = [...peerIds].sort();
-    const leaderId = sorted[0];
-    peerIds.delete(leaderId);
-    leaderAttempts++;
-    safePost({
-      v: PROTOCOL_VERSION,
-      kind: "requestSnapshot",
-      senderId,
-      targetId: leaderId
-    });
-    snapshotTimeoutTimer = setTimeout(() => {
-      snapshotTimeoutTimer = null;
-      if (disposed) return;
-      if (lifecycle === "established") return;
-      if (leaderAttempts >= MAX_LEADER_ATTEMPTS || peerIds.size === 0) {
-        lifecycle = "established";
-        refreshPrior();
-        return;
-      }
-      electLeaderAndRequest();
-    }, SNAPSHOT_TIMEOUT_MS);
-  }
-  function joinFlow() {
-    safePost({ v: PROTOCOL_VERSION, kind: "hello", senderId });
-    joinCollectionTimer = setTimeout(() => {
-      joinCollectionTimer = null;
-      if (disposed) return;
-      if (lifecycle === "established") return;
-      electLeaderAndRequest();
-    }, JOIN_COLLECTION_WINDOW_MS);
-  }
-  joinFlow();
-  return {
-    dispose: () => {
-      if (disposed) return;
-      disposed = true;
-      if (joinCollectionTimer !== null) {
-        clearTimeout(joinCollectionTimer);
-        joinCollectionTimer = null;
-      }
-      if (snapshotTimeoutTimer !== null) {
-        clearTimeout(snapshotTimeoutTimer);
-        snapshotTimeoutTimer = null;
-      }
-      unsubscribeChange();
-      try {
-        channel.close();
-      } catch {
-      }
-    },
-    lifecycle: () => lifecycle,
-    senderId,
-    channelName
-  };
-}
-const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
-
 const warned = /* @__PURE__ */ new Set();
 function warnOnceInsecureContext(feature) {
   if (!paths.__DEV__) return;
@@ -5806,8 +5271,10 @@ function useAbstractForm(configuration, options) {
   }
   const existing = registry.forms.get(key);
   if (paths.__DEV__ && existing !== void 0) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
+    void import('../chunks/dev-key-collision-warnings.cjs').then((m) => {
+      void m.warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+      m.warnOnPersistDivergence(key, existing, configuration.persist);
+    });
   }
   const hadPendingHydration = registry.pendingHydration.has(key);
   const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
@@ -5848,10 +5315,33 @@ function useAbstractForm(configuration, options) {
       } 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());
+        const adapterPromise = getStorageAdapter(resolvedPersist.storage);
+        let persistDisposed = false;
+        state.registerCleanup(() => {
+          persistDisposed = true;
+        });
+        const ready = (async () => {
+          try {
+            const [{ wirePersistence }, fingerprintToken] = await Promise.all([
+              import('../chunks/wire-persistence.cjs'),
+              resolvePersistFingerprintToken(state)
+            ]);
+            if (persistDisposed) return void 0;
+            const persistenceModule = wirePersistence(
+              state,
+              resolvedPersist,
+              adapterPromise,
+              fingerprintToken
+            );
+            state.registerDrain(() => persistenceModule.awaitPendingWrites());
+            state.registerCleanup(() => persistenceModule.dispose());
+            return persistenceModule;
+          } catch {
+            return void 0;
+          }
+        })();
+        const persistenceHandle = { config: resolvedPersist, ready };
+        state.modules.set(PERSISTENCE_MODULE_KEY, persistenceHandle);
       }
     } else {
       void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
@@ -5861,27 +5351,31 @@ function useAbstractForm(configuration, options) {
     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");
+      let formDisposed = false;
+      state.registerCleanup(() => {
+        formDisposed = true;
+      });
+      void (async () => {
+        try {
+          const [{ createMultiTabSyncModule, MULTI_TAB_SYNC_MODULE_KEY }, fingerprint] = await Promise.all([import('../chunks/multi-tab-sync.cjs'), state.schema.fingerprint()]);
+          if (formDisposed) return;
+          const channelName = `attaform:sync:${state.formKey}:${hashStableString(fingerprint)}`;
+          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());
-      }
+          });
+          state.modules.set(MULTI_TAB_SYNC_MODULE_KEY, syncModule);
+          state.registerCleanup(() => syncModule.dispose());
+        } catch {
+        }
+      })();
     } else if (hasBroadcastChannel && !secureContext) {
       warnOnceInsecureContext("multiTab");
     }
@@ -6042,55 +5536,17 @@ function resolveFormKey(key) {
   }
   return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
 }
-function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
-  let existingFp;
-  let incomingFp;
+async function resolvePersistFingerprintToken(state) {
   try {
-    existingFp = existing.fingerprint();
-    incomingFp = incoming.fingerprint();
-  } catch (error) {
-    console.error(
-      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
-      error
-    );
-    return;
-  }
-  if (existingFp === incomingFp) return;
-  console.warn(
-    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
-  existing: ${existingFp}
-  incoming: ${incomingFp}`
-  );
-}
-function warnOnPersistDivergence(key, existing, incomingPersist) {
-  if (incomingPersist === void 0) return;
-  const wired = existing.modules.get(PERSISTENCE_MODULE_KEY);
-  const incomingNormalized = normalizePersistConfig(incomingPersist);
-  if (wired === void 0) {
-    console.warn(
-      `[attaform] useForm({ key: "${key}" }) passed a persist config but the first useForm({ key }) call didn't wire persistence; the new config is silently dropped. Pass persist on the first call, or remove persist here to make the inheritance explicit.`
-    );
-    return;
+    return hashStableString(await state.schema.fingerprint());
+  } catch (err) {
+    if (paths.__DEV__) {
+      console.warn(
+        `[attaform] Could not fingerprint the schema for form '${state.formKey}': ${err instanceof Error ? err.message : String(err)}. Persistence falls back to a fingerprint-free key, so a schema change won't auto-invalidate a saved draft.`
+      );
+    }
+    return "unfingerprinted";
   }
-  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) {
@@ -6258,7 +5714,7 @@ function buildNoopWizardSchema(formKey) {
     formKey
   };
   return {
-    fingerprint: () => NOOP_FINGERPRINT,
+    fingerprint: () => Promise.resolve(NOOP_FINGERPRINT),
     getDefaultValues: () => defaultsResponse,
     getDefaultAtPath: () => void 0,
     getEmptyValueAtPath: () => void 0,
@@ -6975,7 +6431,11 @@ function useWizard(options) {
         }
         for (const key of results.keys()) {
           const store = registry.forms.get(key);
-          if (store !== void 0) store.submissionAttempts.value += 1;
+          if (store !== void 0) {
+            store.submissionAttempts.value += 1;
+            store.cancelFieldValidation();
+            store.displayEngine.clear();
+          }
         }
         submissionAttempts.value += 1;
         const errors = collectErrors(results);
@@ -7209,9 +6669,16 @@ function warnIfAmbientWizardProviderHadDuplicates() {
 }
 
 exports.AttaformErrorCode = AttaformErrorCode;
+exports.DEFAULT_PERSISTENCE_DEBOUNCE_MS = DEFAULT_PERSISTENCE_DEBOUNCE_MS;
+exports.DEFAULT_TIMINGS = DEFAULT_TIMINGS;
+exports.PERSISTENCE_MODULE_KEY = PERSISTENCE_MODULE_KEY;
+exports.applyPatchesForward = applyPatchesForward;
+exports.cleanupOrphanKeys = cleanupOrphanKeys;
 exports.defaultCoercionRules = defaultCoercionRules;
 exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
+exports.deleteAtPath = deleteAtPath;
+exports.diffAndApply = diffAndApply;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
 exports.injectForm = injectForm;
@@ -7219,12 +6686,17 @@ exports.injectWizard = injectWizard;
 exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
 exports.lazy = lazy;
+exports.makeDefaultDisplayState = makeDefaultDisplayState;
+exports.mergeSparseHydration = mergeSparseHydration;
 exports.normalizeNumericOption = normalizeNumericOption;
+exports.normalizePersistConfig = normalizePersistConfig;
+exports.resolveStorageKeyBase = resolveStorageKeyBase;
 exports.safeAssign = safeAssign;
 exports.safeOwnRead = safeOwnRead;
 exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
+exports.structuralSnapshot = structuralSnapshot;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.CwLjUqmQ.cjs.map
+//# sourceMappingURL=attaform.BUszFoKq.cjs.map