attaform 0.20.2 → 0.21.0

package/dist/shared/{attaform.tiWEVznj.mjs → attaform.DSqO6Db7.mjs}

@@ -1,5 +1,5 @@
 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, G as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, v as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, J as useRegistry, z as kFormContext, B as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.QG5TG8lB.mjs';
+import { _ as __DEV__, j as canonicalizePath, G as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, v as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, J as useRegistry, z as kFormContext, B as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.Y_Mgg0Yp.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -458,17 +458,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;
 }
@@ -625,7 +659,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;
@@ -641,8 +687,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 (!isPathPrefix(segments, entry.segments)) continue;
     if (segments.length === entry.segments.length) continue;
@@ -657,9 +706,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) {
@@ -671,6 +729,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) => isPathPrefix(ePath, s));
+  });
   if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
   const gated = asyncPending && !state.firstValidationDone.value;
   const valid = !gated && errors.length === 0 && !validating;
@@ -678,43 +743,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 (__DEV__ && !warnedDisplayStatePredicates.has(predicate)) {
       warnedDisplayStatePredicates.add(predicate);
@@ -723,8 +815,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,
@@ -1417,90 +1512,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 = __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}`;
 }
@@ -1547,47 +1558,6 @@ async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
     }
   }
 }
-function pluckPaths(form, pathKeys) {
-  let sparse = void 0;
-  for (const pathKey of pathKeys) {
-    const segments = 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 = 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 = {};
-    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);
 }
@@ -1825,6 +1795,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);
@@ -2641,7 +2612,12 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
   const getFormMetaBase = () => {
-    const rootBase = buildContainerFieldStateBase(state, ROOT_PATH, ROOT_PATH_KEY, formInstanceId);
+    const { base: rootBase } = buildContainerFieldStateBase(
+      state,
+      ROOT_PATH,
+      ROOT_PATH_KEY,
+      formInstanceId
+    );
     return {
       ...rootBase,
       submitting: state.submitting.value,
@@ -2976,7 +2952,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();
@@ -2991,15 +2967,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 = 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) {
@@ -3017,10 +2993,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();
@@ -3203,6 +3183,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 = 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);
@@ -3541,6 +3608,7 @@ function createArrayBookkeeping(deps) {
     blankPaths,
     originalBlankPaths,
     fieldValidationCounts,
+    fieldValidatingSince,
     fieldValidationState,
     schemaErrors,
     activeValidations,
@@ -3566,6 +3634,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);
   }
@@ -3625,6 +3694,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) {
@@ -3752,6 +3833,9 @@ function createFormStore(options) {
   const resolvedIsSensitivePath = options.isSensitivePath ?? isSensitivePath;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
+  const fieldValidatingSince = 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,
@@ -3880,12 +3964,18 @@ function createFormStore(options) {
   }
   const fieldValidationCounts = 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) => {
@@ -3973,6 +4063,7 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     fieldValidationCounts,
+    fieldValidatingSince,
     fieldValidationState,
     schemaErrors,
     activeValidations,
@@ -4240,7 +4331,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 = () => {
@@ -4278,8 +4369,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;
       });
     };
@@ -4301,6 +4394,22 @@ function createFormStore(options) {
     }
     fieldValidationState.clear();
   }
+  function cancelFieldValidationUnder(prefix) {
+    for (const [key, entry] of [...fieldValidationState]) {
+      const segs = segmentsForPathKey(key);
+      if (segs === null) continue;
+      if (!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 () => {
@@ -4351,6 +4460,7 @@ function createFormStore(options) {
     drainHooks.length = 0;
     modules.clear();
     cancelFieldValidation();
+    fieldValidatingSince.clear();
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
@@ -4697,16 +4807,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;
@@ -4716,6 +4817,8 @@ function createFormStore(options) {
     submitError.value = null;
     departAttempts.value = 0;
     cancelFieldValidation();
+    displayEngine.clear();
+    fieldValidatingSince.clear();
     pathSnapshots.clear();
     scheduleEpoch = 0;
     lastCommittedEpoch = 0;
@@ -4731,6 +4834,12 @@ function createFormStore(options) {
   function resetField(path) {
     const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
     variantMemory.clearUnderPath(targetSegments);
+    cancelFieldValidationUnder(targetSegments);
+    for (const [snapKey] of [...pathSnapshots]) {
+      const segs = segmentsForPathKey(snapKey);
+      if (segs === null) continue;
+      if (isPathPrefix(targetSegments, segs)) pathSnapshots.delete(snapKey);
+    }
     const leafEntry = originals.get(targetKey);
     if (leafEntry !== void 0) {
       const wrote = setValueAtPath(targetSegments, leafEntry.value);
@@ -4780,16 +4889,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 } = canonicalizePath(path);
@@ -4869,6 +4969,8 @@ function createFormStore(options) {
     pathHasAsyncValidation,
     pathHasAsyncValidationByKey,
     fieldValidationCounts,
+    fieldValidatingSince,
+    displayEngine,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
@@ -4953,7 +5055,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);
@@ -5041,7 +5143,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,
@@ -5108,643 +5210,6 @@ function createHistoryModule(state, config) {
   };
 }
 
-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.`
-      );
-    }
-    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 = 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(
-        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(toRaw(state.form.value), path);
-    const nextForm = setAtPath(existing?.data.form ?? {}, 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 (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 } = 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(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 } = 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 = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankAdded.push(k);
-    }
-    const safeBlankRemoved = [];
-    for (const k of msg.blankPathsRemoved) {
-      const segs = canonicalizePath(k).segments;
-      if (isPathLocallySuppressed(segs)) continue;
-      safeBlankRemoved.push(k);
-    }
-    if (safePatches.length === 0 && safeBlankAdded.length === 0 && safeBlankRemoved.length === 0) {
-      return;
-    }
-    const candidate = applyPatchesForward(state.form.value, safePatches);
-    try {
-      options.validateForm(state.form.value);
-      try {
-        options.validateForm(candidate);
-      } catch {
-        return;
-      }
-    } catch {
-    }
-    const nextBlankPaths = new Set(state.blankPaths);
-    for (const k of safeBlankRemoved) nextBlankPaths.delete(k);
-    for (const k of safeBlankAdded) nextBlankPaths.add(k);
-    applyIncomingForm(candidate, [...nextBlankPaths]);
-  }
-  function handleSnapshot(msg) {
-    if (lifecycle !== "joining") return;
-    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 (!__DEV__) return;
@@ -5804,8 +5269,10 @@ function useAbstractForm(configuration, options) {
   }
   const existing = registry.forms.get(key);
   if (__DEV__ && existing !== void 0) {
-    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
-    warnOnPersistDivergence(key, existing, configuration.persist);
+    void import('../chunks/dev-key-collision-warnings.mjs').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);
@@ -5846,10 +5313,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.mjs'),
+              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}`);
@@ -5859,27 +5349,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.mjs'), 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");
     }
@@ -6040,55 +5534,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 (__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) {
@@ -6256,7 +5712,7 @@ function buildNoopWizardSchema(formKey) {
     formKey
   };
   return {
-    fingerprint: () => NOOP_FINGERPRINT,
+    fingerprint: () => Promise.resolve(NOOP_FINGERPRINT),
     getDefaultValues: () => defaultsResponse,
     getDefaultAtPath: () => void 0,
     getEmptyValueAtPath: () => void 0,
@@ -6973,7 +6429,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);
@@ -7206,5 +6666,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-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, safeOwnRead as j, setAtPath as k, lazy as l, slimKindOf as m, normalizeNumericOption as n, useAbstractForm as o, useWizard as p, safeAssign as s, unset as u };
-//# sourceMappingURL=attaform.tiWEVznj.mjs.map
+export { AttaformErrorCode as A, useAbstractForm as B, useWizard as C, DEFAULT_PERSISTENCE_DEBOUNCE_MS as D, PERSISTENCE_MODULE_KEY as P, DEFAULT_TIMINGS as a, applyPatchesForward as b, cleanupOrphanKeys as c, defaultCoercionRules as d, defaultDisplayState as e, defineCoercion as f, deleteAtPath as g, diffAndApply as h, getAtPath as i, humanize as j, injectForm as k, injectWizard as l, isPlainRecord as m, isUnset as n, lazy as o, makeDefaultDisplayState as p, mergeSparseHydration as q, normalizeNumericOption as r, normalizePersistConfig as s, resolveStorageKeyBase as t, safeAssign as u, safeOwnRead as v, setAtPath as w, slimKindOf as x, structuralSnapshot as y, unset as z };
+//# sourceMappingURL=attaform.DSqO6Db7.mjs.map