attaform 0.17.2 → 0.18.1

package/dist/shared/{attaform.B3ZaPIzS.mjs → attaform.DsC3rZHG.mjs}

@@ -1,6 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, provide, useId, inject } from 'vue';
-import { _ as __DEV__, e as SubmitErrorHandlerError, A as AnonPersistError, l as captureUserCallSite, m as enforceSensitiveCheck, s as segmentMatchesSensitive, n as isSensitivePath, o as createPersistOptInRegistry, b as InvalidUseFormConfigError, p as ensureAttaformInstalled, j as useRegistry, q as kFormContext, r as kFormInstanceId, d as ReservedFormKeyError, t as createIsSensitivePath, w as createSegmentMatchesSensitive } from './attaform.CIEQgJnM.mjs';
-import { c as canonicalizePath, s as segmentsForPathKey, i as isPathPrefix, F as FORM_ERRORS_PATH_KEY, R as ROOT_PATH, b as FORM_ERRORS_PATH } from './attaform.h1sq3BFu.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, toRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
+import { a as canonicalizePath, s as segmentsForPathKey, m as isPathPrefix, F as FORM_ERRORS_PATH_KEY, _ as __DEV__, r as pathKeyToDotted, i as SubmitErrorHandlerError, A as AnonPersistError, t as captureUserCallSite, R as ROOT_PATH, w as enforceSensitiveCheck, x as FORM_ERRORS_PATH, y as coerceToPathKey, z as segmentMatchesSensitive, B as isSensitivePath, C as createPersistOptInRegistry, d as InvalidUseFormConfigError, E as ensureAttaformInstalled, q as useRegistry, G as kFormContext, H as kFormInstanceId, h as ReservedFormKeyError, J as createIsSensitivePath, K as createSegmentMatchesSensitive, k as kAttaformWizardActiveStepResolver, L as kAttaformAncestorWizard } from './attaform.Xhg0AYNa.mjs';
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -121,7 +120,12 @@ function mergeStructural(schema, path, consumer, defaultValue = schema.getDefaul
   return mergeStructuralImpl(schema, scratch, consumer, defaultValue);
 }
 function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
-  if (consumer === void 0) return defaultValue;
+  if (consumer === void 0) {
+    if (schema.getSlimPrimitiveTypesAtPath?.(scratch).has("undefined") === true) {
+      return void 0;
+    }
+    return defaultValue;
+  }
   if (consumer === null) return null;
   if (Array.isArray(consumer)) {
     const shape = resolveArrayShape(schema, scratch);
@@ -161,7 +165,7 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
     let mutated = false;
     const out = { ...consumer };
     for (const key of Object.keys(defaultValue)) {
-      if (!(key in consumer) || consumer[key] === void 0) {
+      if (!(key in consumer)) {
         const defAtKey = defaultValue[key];
         scratch.push(key);
         const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
@@ -173,10 +177,12 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
       }
     }
     for (const key of Object.keys(consumer)) {
+      const cVal = consumer[key];
+      if (cVal === void 0) continue;
       scratch.push(key);
-      const merged = mergeStructuralImpl(schema, scratch, consumer[key], defaultValue[key]);
+      const merged = mergeStructuralImpl(schema, scratch, cVal, defaultValue[key]);
       scratch.pop();
-      if (merged !== consumer[key]) {
+      if (merged !== cVal) {
         out[key] = merged;
         mutated = true;
       }
@@ -504,7 +510,7 @@ function buildLeafFieldStateBase(state, segments, key) {
     dirty: !pristine,
     focused: record?.focused ?? null,
     blurred: record?.blurred ?? null,
-    touched: record?.touched ?? null,
+    touched: record?.touched ?? false,
     connected: record?.connected ?? false,
     element: firstElement,
     elements: elementsArr,
@@ -646,10 +652,12 @@ function buildSurfaceProxy(opts) {
       if (opts.leafKeys !== void 0) return leafViewProxyAt(segs);
       return opts.resolveLeaf(segs);
     }
+    if (opts.isTerminalAt?.(segs) === true) return opts.resolveLeaf(segs);
     return containerProxyAt(segs);
   }
   function containerProxyAt(segments) {
-    const cacheKey = JSON.stringify(segments);
+    const isArrayLike = opts.isArrayContainer?.(segments) === true;
+    const cacheKey = `${JSON.stringify(segments)}+${isArrayLike ? "A" : "O"}`;
     const existing = containerCache.get(cacheKey);
     if (existing !== void 0) return existing;
     const snapshotContainer = () => opts.materializeContainer === void 0 ? {} : opts.materializeContainer(segments);
@@ -659,7 +667,7 @@ function buildSurfaceProxy(opts) {
       return this;
     }
     const containerToPrimitive = (hint) => hint === "number" ? NaN : containerToString();
-    const target = (() => {
+    const target = isArrayLike ? [] : (() => {
     });
     const proxy = new Proxy(target, {
       apply(_, __, args) {
@@ -674,7 +682,14 @@ function buildSurfaceProxy(opts) {
           return Reflect.get(target, key);
         }
         if (typeof key !== "string") return void 0;
+        if (key === "__v_skip") return true;
+        if (key === "__v_isReactive" || key === "__v_isReadonly" || key === "__v_isShallow" || key === "__v_isRef" || key === "__v_raw") {
+          return void 0;
+        }
         if (key === "toJSON") return containerToJSON;
+        if (key === "length" && (isArrayLike || opts.isArrayContainer?.(segments) === true)) {
+          return opts.containerOwnKeys === void 0 ? 0 : opts.containerOwnKeys(segments).length;
+        }
         const childSegs = [...segments, keyToSegment(key)];
         if (key === "toString" || key === "valueOf") {
           if (!schemaHasPath(childSegs)) {
@@ -687,11 +702,38 @@ function buildSurfaceProxy(opts) {
         if (typeof key === "symbol") return Reflect.has(target, key);
         return true;
       },
-      // Containers are descend-only — `JSON.stringify(form.fields.address)`
-      // returns `{}` (no leaf keys to enumerate). Consumers who want
-      // structural data use `form.values.<container>` instead.
-      ownKeys: () => [],
-      getOwnPropertyDescriptor: () => void 0,
+      // Live enumeration. When the surface provides `containerOwnKeys`,
+      // `Object.keys(proxy)` / `Object.entries(proxy)` /
+      // `v-for="(child, key) in proxy"` reflect whichever keys the
+      // underlying form data currently holds at this path: array
+      // indices (`'0'`, `'1'`, …) when the live value is an array,
+      // object keys when it's a record. `getOwnPropertyDescriptor`
+      // descends to the per-key sub-proxy so iteration yields the
+      // same objects dot-access would. Without `containerOwnKeys`,
+      // the container stays non-enumerable for callers that don't
+      // need iteration — `JSON.stringify` still serialises through
+      // the `toJSON` trap above either way.
+      ownKeys: () => {
+        const liveKeys = opts.containerOwnKeys === void 0 ? [] : opts.containerOwnKeys(segments);
+        if (isArrayLike) return ["length", ...liveKeys];
+        return [...liveKeys];
+      },
+      getOwnPropertyDescriptor(_, key) {
+        if (typeof key !== "string") return void 0;
+        if (isArrayLike && key === "length") {
+          const length = opts.containerOwnKeys === void 0 ? 0 : opts.containerOwnKeys(segments).length;
+          return { configurable: false, enumerable: false, value: length, writable: true };
+        }
+        if (opts.containerOwnKeys === void 0) return void 0;
+        const liveKeys = opts.containerOwnKeys(segments);
+        if (!liveKeys.includes(key)) return void 0;
+        return {
+          configurable: true,
+          enumerable: true,
+          value: descendOrTerminate([...segments, keyToSegment(key)]),
+          writable: false
+        };
+      },
       // Block writes at the proxy boundary. Mutations go through
       // `setValue`, the directive, or the field-array helpers.
       set: () => false,
@@ -782,22 +824,47 @@ function buildErrorsProxy(state) {
   return buildSurfaceProxy({
     schema: state.schema,
     resolveLeaf: (path) => {
-      const { key } = canonicalizePath(path);
-      const userForKey = state.userErrors.get(key);
-      const isActive = hasAtPath(state.form.value, path);
+      const isContainerSelfAccess = path.length > 1 && path[path.length - 1] === "";
+      const collectAtKey = (key2, active2, into) => {
+        if (active2) {
+          const s = state.schemaErrors.get(key2);
+          const b = state.derivedBlankErrors.value.get(key2);
+          if (s !== void 0) into.push(...s);
+          if (b !== void 0) into.push(...b);
+        }
+        const u = state.userErrors.get(key2);
+        if (u !== void 0) into.push(...u);
+      };
       const merged = [];
-      if (isActive) {
-        const schemaForKey = state.schemaErrors.get(key);
-        const blankForKey = state.derivedBlankErrors.value.get(key);
-        if (schemaForKey !== void 0) merged.push(...schemaForKey);
-        if (blankForKey !== void 0) merged.push(...blankForKey);
+      if (isContainerSelfAccess) {
+        const containerPath = path.slice(0, -1);
+        const containerKey = canonicalizePath(containerPath).key;
+        const literalKey = canonicalizePath(path).key;
+        const active2 = hasAtPath(state.form.value, containerPath);
+        collectAtKey(containerKey, active2, merged);
+        if (literalKey !== containerKey) collectAtKey(literalKey, active2, merged);
+        return merged;
       }
-      if (userForKey !== void 0) merged.push(...userForKey);
-      return merged.length === 0 ? void 0 : merged;
+      const { key } = canonicalizePath(path);
+      const isFormLevel = key === FORM_ERRORS_PATH_KEY;
+      const active = isFormLevel || hasAtPath(state.form.value, path);
+      collectAtKey(key, active, merged);
+      return merged;
     },
     // No leafKeys — at a leaf, the resolved value (the merged array or
     // undefined) IS the terminal.
     materializeContainer: (segments) => materializeErrors(state, segments),
+    // Any path ending in `''` is a meaningful terminal at the proxy
+    // layer: at root it's the form-level bucket; at depth >= 1 it's
+    // the container-self sentinel that surfaces cross-field refines
+    // and container-targeted marks. `resolveLeaf` translates `[...,
+    // '']` lookups to the parent container path before querying the
+    // stores. When a schema legitimately owns a `''` field, the
+    // literal leaf and any container-self errors share the slot
+    // (errors concatenate) — vanishingly rare, accepted as the
+    // ergonomic cost of one unified sentinel convention at every
+    // depth.
+    isTerminalAt: (segs) => segs.length >= 1 && segs[segs.length - 1] === "",
     // Call-form aggregates: `form.errors(path)` returns a single
     // `ValidationError[]` for any depth (leaf or container) — same
     // shared `aggregateErrorsAt` helper that `form.meta.errors` and
@@ -807,12 +874,31 @@ function buildErrorsProxy(state) {
     // when valid) so consumer code that branches on truthiness keeps
     // working — the call-form just extends that semantic to
     // containers and dynamic paths.
-    resolveCallTarget: (path) => {
-      const errs = aggregateErrorsAt(state, path);
-      return errs.length === 0 ? void 0 : errs;
-    }
+    resolveCallTarget: (path) => aggregateErrorsAt(state, path),
+    // Mirror `form.fields` enumeration: `Object.keys(form.errors.items)`
+    // and `v-for="(errs, idx) in form.errors.items"` walk the live
+    // array indices / object keys at the path. Iteration yields the
+    // descended sub-proxies (one per live key), so consumers can
+    // `form.errors.items[idx]` straight from the entry.
+    containerOwnKeys: (segments) => liveKeysAtPath$1(state, segments),
+    isArrayContainer: (segments) => isArrayPath$1(state, segments)
   });
 }
+function liveKeysAtPath$1(state, segments) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    const keys = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
+    return keys;
+  }
+  if (typeof value === "object") return Object.keys(value);
+  return [];
+}
+function isArrayPath$1(state, segments) {
+  if (segments.length === 0) return false;
+  return Array.isArray(getAtPath(state.form.value, segments));
+}
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
   const tree = Array.isArray(liveContainer) ? [] : {};
@@ -821,12 +907,33 @@ function materializeErrors(state, containerSegments) {
       if (errors.length === 0) continue;
       const fullPath = segmentsForPathKey(pathKey);
       if (fullPath === null) continue;
-      if (fullPath.length <= containerSegments.length) continue;
-      for (let i = 0; i < containerSegments.length; i++) {
-        if (fullPath[i] !== containerSegments[i]) continue entries;
+      const isSyntheticFormLevel = fullPath.length === 1 && fullPath[0] === "";
+      if (!isSyntheticFormLevel) {
+        if (fullPath.length < containerSegments.length) continue;
+        for (let i = 0; i < containerSegments.length; i++) {
+          if (fullPath[i] !== containerSegments[i]) continue entries;
+        }
+      } else if (containerSegments.length !== 0) {
+        continue;
+      }
+      if (applyActivePathFilter && !isSyntheticFormLevel && !hasAtPath(state.form.value, fullPath))
+        continue;
+      let placePath;
+      if (isSyntheticFormLevel) {
+        placePath = [""];
+      } else {
+        const relativePath = fullPath.slice(containerSegments.length);
+        if (relativePath.length === 0) {
+          placePath = [""];
+        } else if (state.schema.isLeafAtPath(fullPath)) {
+          placePath = relativePath;
+        } else if (state.schema.getSlimPrimitiveTypesAtPath(fullPath).size > 0) {
+          placePath = [...relativePath, ""];
+        } else {
+          placePath = relativePath;
+        }
       }
-      if (applyActivePathFilter && !hasAtPath(state.form.value, fullPath)) continue;
-      placeAt(tree, fullPath.slice(containerSegments.length), errors);
+      placeAt(tree, placePath, errors);
     }
   };
   collect(state.schemaErrors, true);
@@ -1014,9 +1121,26 @@ function buildFieldStateProxy(state, getFormMetaBase, options) {
     leafKeys: FIELD_STATE_KEYS,
     readLeafKey: (computed, key) => computed.value[key],
     materializeContainer: (segments) => materializeFields(state, segments, snapshotFieldStateAt),
-    resolveCallTarget: (path) => fieldStateTerminalAt(path)
+    resolveCallTarget: (path) => fieldStateTerminalAt(path),
+    containerOwnKeys: (segments) => liveKeysAtPath(state, segments),
+    isArrayContainer: (segments) => isArrayPath(state, segments)
   });
 }
+function liveKeysAtPath(state, segments) {
+  const value = getAtPath(state.form.value, segments);
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    const keys = new Array(value.length);
+    for (let i = 0; i < value.length; i += 1) keys[i] = String(i);
+    return keys;
+  }
+  if (typeof value === "object") return Object.keys(value);
+  return [];
+}
+function isArrayPath(state, segments) {
+  if (segments.length === 0) return false;
+  return Array.isArray(getAtPath(state.form.value, segments));
+}
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
   const liveValue = getAtPath(state.form.value, containerSegments);
   return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
@@ -1048,6 +1172,7 @@ const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
 const PERSISTENCE_KEY_PREFIX = "attaform:";
 const RESERVED_KEY_PREFIX = "__atta:";
 const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
 const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
   const { value, source, allowInfinity, min, defaultValue } = config;
@@ -1082,7 +1207,7 @@ async function getStorageAdapter(storage) {
     }
   }
 }
-const PERSISTED_ENVELOPE_VERSION = 4;
+const PERSISTED_ENVELOPE_VERSION = 5;
 function readPersistedPayload(value) {
   if (value === null || value === void 0 || typeof value !== "object") return null;
   const envelope = value;
@@ -1104,7 +1229,15 @@ function warnVersionMismatch(observedVersion) {
   );
 }
 function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
-  const transientList = blankPaths !== void 0 && blankPaths.size > 0 ? [...blankPaths] : void 0;
+  let transientList;
+  if (blankPaths !== void 0 && blankPaths.size > 0) {
+    const dotted = [];
+    for (const key of blankPaths) {
+      const d = pathKeyToDotted(key);
+      if (d !== null) dotted.push(d);
+    }
+    transientList = dotted.length > 0 ? dotted : void 0;
+  }
   if (include === "form") {
     if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
     return {
@@ -1272,13 +1405,40 @@ const AttaformErrorCode = {
   NoValueSupplied: "atta:no-value-supplied",
   /** The schema adapter's `validateAtPath` threw synchronously. */
   AdapterThrew: "atta:adapter-threw",
+  /**
+   * User code inside a `z.preprocess`, `.refine`, or `.transform`
+   * threw (sync or async). The adapter caught the throw and surfaced
+   * it as a `ValidationError` at the field path so the form's normal
+   * error pipeline handles it instead of leaking as an unhandled
+   * rejection or routing through `submitError`.
+   */
+  ValidatorThrew: "atta:validator-threw",
+  /**
+   * A function-form `defaultValues` factory threw or its promise
+   * rejected. The runtime captures the raw error on `form.hydrateError`
+   * and ALSO surfaces a form-level `ValidationError` (path `[]`) so
+   * the standard error pipeline carries the signal. Critical for the
+   * SSR round-trip: `hydrateError` itself does not ride the wire
+   * payload, but `schemaErrors` does, so the client sees the failure
+   * after rehydration without an extra channel.
+   */
+  HydrationFailed: "atta:hydration-failed",
   /** The supplied path didn't resolve to any node in the schema. */
-  PathNotFound: "atta:path-not-found"
+  PathNotFound: "atta:path-not-found",
+  /**
+   * A walked form's `activate()` (async `defaultValues` factory) threw
+   * during `wizard.handleSubmit`'s path walk. Surfaced as a synthetic
+   * `ValidationError` at the form-level path (`[]`) so the wizard's
+   * aggregate error pipeline can carry the failure alongside ordinary
+   * validation errors. The raw factory error remains on
+   * `form.hydrateError` for retry UX.
+   */
+  ActivationFailed: "atta:activation-failed"
 };
 
 const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
-  const invalidPolicy = options.onInvalidSubmit ?? "none";
+  const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
   function validate(pathInput) {
     const result = ref({
       pending: true,
@@ -1341,7 +1501,15 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
     try {
       state.activeValidations.value += 1;
+      state.cancelFieldValidation();
       const refinement = await runRefinementValidation(dataAtPath, segments);
+      const scopePath = segments ?? [];
+      const errors = refinement.success ? [] : refinement.errors;
+      const reStamped = segments === void 0 ? errors : errors.map((err) => ({
+        ...err,
+        path: [...segments, ...err.path]
+      }));
+      state.applySchemaErrorsForSubtree(scopePath, reStamped);
       return stripData(composeWithDerivedBlank(refinement, segments));
     } catch (err) {
       return adapterThrowResponse(err);
@@ -1438,6 +1606,9 @@ function buildProcessForm(state, formInstanceId, options = {}) {
           state.clearSchemaErrors();
         }
         await onSubmit(merged.data);
+        if (state.submissionGeneration.value === genAtEntry) {
+          state.submitted.value = true;
+        }
         state.emitSubmitSuccess();
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
@@ -1451,7 +1622,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         state.activeSubmissions.value = Math.max(0, state.activeSubmissions.value - 1);
         if (state.submissionGeneration.value === genAtEntry) {
           state.submitting.value = state.activeSubmissions.value > 0;
-          state.submitCount.value += 1;
+          state.submissionAttempts.value += 1;
         }
       }
     };
@@ -1545,6 +1716,7 @@ function slimKindOf(value) {
   if (value instanceof Date) return "date";
   if (value instanceof Map) return "map";
   if (value instanceof Set) return "set";
+  if (typeof File !== "undefined" && value instanceof File) return "file";
   const t = typeof value;
   switch (t) {
     case "string":
@@ -1575,6 +1747,7 @@ function isSlimPrimitiveValid(schema, store, path, value) {
   return walk$1(schema, store, path, value);
 }
 function walk$1(schema, store, path, value) {
+  if (schema.isPreprocessOrCoerceLeaf(path)) return true;
   const accepted = schema.getSlimPrimitiveTypesAtPath(path);
   const kind = isLeafValue(value) ? slimKindOf(value) : Array.isArray(value) ? "array" : "object";
   if (!accepted.has(kind)) {
@@ -1804,6 +1977,11 @@ function attachFocusListeners(state, segments, element, instanceMeta) {
   element.addEventListener("focus", handleFocus);
   element.addEventListener("blur", handleBlur);
   target[attaformListenersSymbol] = { handleFocus, handleBlur };
+  const rootNode = element.getRootNode();
+  const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
+  if (activeElement === element) {
+    state.markFocused(segments, true, focusMeta);
+  }
 }
 function detachFocusListeners(element) {
   const target = element;
@@ -1840,6 +2018,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       return String(raw);
     });
     const slimDefault = state.schema.getDefaultAtPath(segments);
+    const slimTypes = state.schema.getSlimPrimitiveTypesAtPath(segments);
+    const acceptsUndefined = slimTypes.has("undefined");
+    const acceptsString = slimTypes.has("string");
     const persist = options?.persist === true;
     const acknowledgeSensitive = options?.acknowledgeSensitive === true;
     const multiTab = options?.multiTab !== false;
@@ -1923,7 +2104,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       ...unmarkNoSync !== void 0 ? { unmarkNoSync } : {},
       transforms,
       coerce,
-      ...coerceElement !== void 0 ? { coerceElement } : {}
+      ...coerceElement !== void 0 ? { coerceElement } : {},
+      acceptsUndefined,
+      acceptsString
     };
     return shallowReadonly(internalRv);
   };
@@ -1946,13 +2129,7 @@ function walkUnsetSentinels(values, schema) {
 }
 function walk(input, segments, schema, paths) {
   if (isUnset(input)) {
-    const slim = schema.getDefaultAtPath(segments);
-    if (!isPrimitiveOrEmpty(slim)) {
-      warnNonPrimitiveLeaf(segments, slim);
-      return walkUnspecified(slim, segments, paths);
-    }
-    paths.push(canonicalizePath(segments).key);
-    return slim;
+    return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
     const slim = schema.getDefaultAtPath(segments);
@@ -1975,6 +2152,7 @@ function walk(input, segments, schema, paths) {
   if (typeof input === "object") {
     const slim = schema.getDefaultAtPath(segments);
     const inputKeys = Object.keys(input);
+    const inputKeysSet = new Set(inputKeys);
     const allKeys = new Set(inputKeys);
     if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !(slim instanceof Date) && !(slim instanceof RegExp) && !(slim instanceof Map) && !(slim instanceof Set)) {
       for (const k of Object.keys(slim)) allKeys.add(k);
@@ -1983,6 +2161,11 @@ function walk(input, segments, schema, paths) {
     let mutated = allKeys.size !== inputKeys.length;
     for (const key of allKeys) {
       const orig = input[key];
+      if (orig === void 0 && inputKeysSet.has(key)) {
+        out[key] = void 0;
+        mutated = true;
+        continue;
+      }
       const walked = walk(orig, [...segments, key], schema, paths);
       out[key] = walked;
       if (walked !== orig) mutated = true;
@@ -1993,7 +2176,7 @@ function walk(input, segments, schema, paths) {
 }
 function walkUnspecified(slim, segments, paths) {
   if (isPrimitiveOrEmpty(slim)) {
-    if (isNumericPrimitive(slim)) {
+    if (isSlimNumericPrimitive(slim)) {
       paths.push(canonicalizePath(segments).key);
     }
     return slim;
@@ -2018,13 +2201,7 @@ function substituteUnsetSentinels(value, prefix, schema) {
 }
 function substitute(input, segments, schema, paths) {
   if (isUnset(input)) {
-    const slim = schema.getDefaultAtPath(segments);
-    if (!isPrimitiveOrEmpty(slim)) {
-      warnNonPrimitiveLeaf(segments, slim);
-      return slim;
-    }
-    paths.push(canonicalizePath(segments).key);
-    return slim;
+    return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0 || input === null) return input;
   if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
@@ -2058,20 +2235,40 @@ function isPrimitiveOrEmpty(value) {
   const t = typeof value;
   return t === "string" || t === "number" || t === "boolean" || t === "bigint";
 }
-function isNumericPrimitive(value) {
-  const t = typeof value;
-  return t === "number" || t === "bigint";
-}
-const warnedNonPrimitivePaths = __DEV__ ? /* @__PURE__ */ new Set() : null;
-function warnNonPrimitiveLeaf(segments, slim) {
-  if (warnedNonPrimitivePaths === null) return;
-  const dotted = segments.map(String).join(".");
-  if (warnedNonPrimitivePaths.has(dotted)) return;
-  warnedNonPrimitivePaths.add(dotted);
-  const slimType = slim === null ? "null" : slim instanceof Date ? "Date" : typeof slim;
-  console.warn(
-    `[attaform] \`unset\` at "${dotted || "<root>"}" is a no-op \u2014 unset only works at primitive leaves (string / number / boolean / bigint, plus their optional / nullable variants), got "${slimType}". The slim default was written but the path is NOT marked blank. (TypeScript catches this at compile time; this warn covers plain-JS callers.)`
-  );
+function isSlimNumericPrimitive(value) {
+  return value === 0 || value === 0n;
+}
+function blankForKind(slimDefault) {
+  if (typeof slimDefault === "string") return "";
+  if (typeof slimDefault === "number") return 0;
+  if (typeof slimDefault === "bigint") return 0n;
+  if (typeof slimDefault === "boolean") return false;
+  if (slimDefault === null) return null;
+  return void 0;
+}
+function expandUnsetAt(segments, schema, paths) {
+  const du = schema.getUnionDiscriminatorAtPath(segments);
+  if (du !== void 0) {
+    const discPath = [...segments, du.discriminatorKey];
+    const discSlim = schema.getEmptyValueAtPath(discPath);
+    paths.push(canonicalizePath(discPath).key);
+    return { [du.discriminatorKey]: blankForKind(discSlim) };
+  }
+  const slim = schema.getEmptyValueAtPath(segments);
+  if (isPrimitiveOrEmpty(slim)) {
+    paths.push(canonicalizePath(segments).key);
+    return slim;
+  }
+  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+    paths.push(canonicalizePath(segments).key);
+    return slim;
+  }
+  if (Array.isArray(slim)) return slim;
+  const result = {};
+  for (const key of Object.keys(slim)) {
+    result[key] = expandUnsetAt([...segments, key], schema, paths);
+  }
+  return result;
 }
 
 function buildValuesProxy(form) {
@@ -2141,28 +2338,6 @@ function buildValuesProxy(form) {
   });
 }
 
-function blankForKind(slimDefault) {
-  if (typeof slimDefault === "string") return "";
-  if (typeof slimDefault === "number") return 0;
-  if (typeof slimDefault === "bigint") return 0n;
-  if (typeof slimDefault === "boolean") return false;
-  if (slimDefault === null) return null;
-  return void 0;
-}
-function readonlySetSnapshot(source) {
-  const snapshot = new Set(source);
-  return new Proxy(snapshot, {
-    get(target, prop) {
-      if (prop === "add" || prop === "delete" || prop === "clear") {
-        return () => {
-          throw new TypeError(`Cannot mutate readonly Set: '${String(prop)}' is not allowed.`);
-        };
-      }
-      const value = Reflect.get(target, prop, target);
-      return typeof value === "function" ? value.bind(target) : value;
-    }
-  });
-}
 function buildFormApi(state, formInstanceId, options = {}) {
   const instanceMeta = (() => {
     const bag = {};
@@ -2185,6 +2360,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     Object.keys(registerConfig).length > 0 ? registerConfig : void 0
   );
   const processOptions = options.onInvalidSubmit !== void 0 ? { onInvalidSubmit: options.onInvalidSubmit } : {};
+  const defaultInvalidSubmitPolicy = options.onInvalidSubmit ?? "focus-first-error";
   const {
     validate: validateBuilt,
     validateAsync: validateAsyncBuilt,
@@ -2205,49 +2381,53 @@ function buildFormApi(state, formInstanceId, options = {}) {
         next,
         state.schema
       );
-      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
-      if (!ok2) return false;
       for (const pathKey of walked2.paths) {
-        const segments2 = segmentsForPathKey(pathKey);
-        if (segments2 === null) continue;
-        state.setValueAtPath(
-          segments2,
-          state.schema.getDefaultAtPath(segments2),
-          withInstanceMeta({ blank: true })
-        );
+        state.blankPaths.add(pathKey);
       }
-      return true;
+      return state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
     }
     const segments = canonicalizePath(pathOrValue).segments;
-    if (isUnset(maybeValue)) {
+    const writeUnsetAt = () => {
       const last = segments.length > 0 ? segments[segments.length - 1] : void 0;
       if (typeof last === "string") {
         const parent = segments.slice(0, -1);
         const parentDU = state.schema.getUnionDiscriminatorAtPath(parent);
         if (parentDU?.discriminatorKey === last) {
-          const slimDefault = state.schema.getDefaultAtPath(segments);
+          const slimDefault = state.schema.getEmptyValueAtPath(segments);
           const blank = blankForKind(slimDefault);
           return state.setValueAtPath(segments, blank, withInstanceMeta({ blank: true }));
         }
       }
-      return state.setValueAtPath(
+      const blankPaths = [];
+      const expanded = expandUnsetAt(
         segments,
-        state.schema.getDefaultAtPath(segments),
-        withInstanceMeta({ blank: true })
+        state.schema,
+        blankPaths
       );
-    }
+      const segmentsKey = canonicalizePath(segments).key;
+      if (blankPaths.length === 1 && blankPaths[0] === segmentsKey) {
+        return state.setValueAtPath(segments, expanded, withInstanceMeta({ blank: true }));
+      }
+      const ok2 = state.setValueAtPath(segments, expanded, withInstanceMeta());
+      if (!ok2) return false;
+      for (const pathKey of blankPaths) {
+        const blankSegments = segmentsForPathKey(pathKey);
+        if (blankSegments === null) continue;
+        state.setValueAtPath(
+          blankSegments,
+          state.getValueAtPath(blankSegments),
+          withInstanceMeta({ blank: true })
+        );
+      }
+      return true;
+    };
+    if (isUnset(maybeValue)) return writeUnsetAt();
     let resolvedValue;
     if (typeof maybeValue === "function") {
       const current = state.getValueAtPath(segments);
       const prev = current === void 0 ? state.schema.getDefaultAtPath(segments) : current;
       resolvedValue = maybeValue(prev);
-      if (isUnset(resolvedValue)) {
-        return state.setValueAtPath(
-          segments,
-          state.schema.getDefaultAtPath(segments),
-          withInstanceMeta({ blank: true })
-        );
-      }
+      if (isUnset(resolvedValue)) return writeUnsetAt();
     } else {
       resolvedValue = maybeValue;
     }
@@ -2263,7 +2443,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       if (blankSegments === null) continue;
       state.setValueAtPath(
         blankSegments,
-        state.schema.getDefaultAtPath(blankSegments),
+        state.getValueAtPath(blankSegments),
         withInstanceMeta({ blank: true })
       );
     }
@@ -2327,8 +2507,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     state.userErrors.delete(FORM_ERRORS_PATH_KEY);
   }
   const submitting = computed(() => state.submitting.value);
-  const submitCount = computed(() => state.submitCount.value);
+  const submissionAttempts = computed(() => state.submissionAttempts.value);
+  const submitted = computed(() => state.submitted.value);
   const submitError = computed(() => state.submitError.value);
+  const departAttempts = computed(() => state.departAttempts.value);
   const validating = computed(() => state.activeValidations.value > 0);
   const valid = computed(
     () => state.firstValidationDone.value && state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
@@ -2353,8 +2535,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return {
       ...rootBase,
       submitting: state.submitting.value,
-      submitCount: state.submitCount.value,
+      submissionAttempts: state.submissionAttempts.value,
+      departAttempts: state.departAttempts.value,
       submitError: state.submitError.value,
+      errorCount: rootBase.errors.length,
+      submitted: state.submitted.value,
       instanceId: formInstanceId
     };
   };
@@ -2414,8 +2599,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
       meta: computed(() => rootFieldState.value.meta),
       // Lifecycle (form-level only — not on FieldState).
       submitting,
-      submitCount,
+      submissionAttempts,
+      departAttempts,
       submitError,
+      // Scalar mirror over the array — meta is a single sticky surface
+      // for both templates and `useWizard`'s `FormStatus`, so the
+      // projection lives here.
+      errorCount: computed(() => metaErrors.value.length),
+      submitted,
       // Per-`useForm()`-call identity. Stable for one mount; new on
       // re-mount; orthogonal to `form.key` (which is the user-supplied
       // shared identifier). Useful for devtools panels disambiguating
@@ -2435,13 +2626,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       state.reset(walked.cleanedValues);
       for (const pathKey of walked.paths) {
-        const segments = segmentsForPathKey(pathKey);
-        if (segments === null) continue;
-        state.setValueAtPath(
-          segments,
-          state.schema.getDefaultAtPath(segments),
-          withInstanceMeta({ blank: true })
-        );
+        state.blankPaths.add(pathKey);
         state.originalBlankPaths.add(pathKey);
       }
     }
@@ -2491,56 +2676,141 @@ function buildFormApi(state, formInstanceId, options = {}) {
     target.element.scrollIntoView(options2);
     return true;
   };
+  const applyInvalidSubmitPolicyPublic = (policy) => {
+    applyInvalidSubmitPolicy(state, formInstanceId, policy ?? defaultInvalidSubmitPolicy);
+  };
   const fieldArrays = buildFieldArrayApi(state);
   const blankPathsView = computed(() => {
-    return readonlySetSnapshot(state.blankPaths);
+    const keys = /* @__PURE__ */ new Set();
+    const paths = [];
+    for (const pk of state.blankPaths) {
+      keys.add(pk);
+      const segs = segmentsForPathKey(pk);
+      if (segs !== null) paths.push(segs);
+    }
+    Object.freeze(paths);
+    const view = {
+      get size() {
+        return keys.size;
+      },
+      has(input) {
+        const { key } = canonicalizePath(input);
+        return keys.has(key);
+      },
+      values() {
+        return paths;
+      },
+      [Symbol.iterator]() {
+        return paths[Symbol.iterator]();
+      }
+    };
+    return Object.freeze(view);
   });
   const valuesProxy = buildValuesProxy(state.form);
   const fieldStateProxy = buildFieldStateProxy(state, getFormMetaBase, fieldStateAccessorOptions);
+  function gated(fn) {
+    return ((...args) => {
+      void state.activate();
+      return fn(...args);
+    });
+  }
   return {
-    handleSubmit,
-    // `values` is the callable readonly Proxy. Each `get` trap reads
-    // through `inner.value` (a `computed(() => readonly(form.value))`)
-    // so reactivity tracking propagates at the call site. Identity-
-    // stable across whole-form swaps (the inner readonly proxy
-    // re-keys; the outer callable proxy stays the same instance).
-    values: valuesProxy,
-    fields: fieldStateProxy,
-    setValue: setValueImpl,
-    validate,
-    validateAsync,
-    process,
-    register,
+    handleSubmit: gated(handleSubmit),
+    // Callable readonly Proxies (`values`, `fields`, `errors`) and the
+    // reactive containers (`meta`, `history`, `blankPaths`) are exposed
+    // through getters so reading them activates the form on first
+    // touch. Each underlying object is identity-stable across reads.
+    get values() {
+      void state.activate();
+      return valuesProxy;
+    },
+    get fields() {
+      void state.activate();
+      return fieldStateProxy;
+    },
+    setValue: gated(setValueImpl),
+    validate: gated(validate),
+    validateAsync: gated(validateAsync),
+    process: gated(process),
+    register: gated(register),
     key: state.formKey,
-    errors: errorsProxy,
-    toRef: pathToRef,
-    setFieldErrors,
-    addFieldErrors,
-    clearFieldErrors,
-    setFormErrors,
-    clearFormErrors,
-    meta: formMeta,
-    reset,
-    resetField,
-    clear,
-    persist,
-    clearPersistedDraft,
-    focusFirstError,
-    scrollToFirstError,
-    touch,
-    history: formHistory,
-    append: fieldArrays.append,
-    prepend: fieldArrays.prepend,
-    insert: fieldArrays.insert,
-    remove: fieldArrays.remove,
-    swap: fieldArrays.swap,
-    move: fieldArrays.move,
-    replace: fieldArrays.replace,
-    blankPaths: blankPathsView
+    // Auto-unwrapping views over the per-store async-defaults lifecycle
+    // refs (see FormStore.hydrating / hydrateError). Reading either
+    // activates the form — observing factory state implies use.
+    get hydrating() {
+      void state.activate();
+      return state.hydrating.value;
+    },
+    get hydrateError() {
+      void state.activate();
+      return state.hydrateError.value;
+    },
+    // Orthogonal to `hydrating` and `hydrateError`: `ready` flips true
+    // once defaults are applied (sync at construction or async factory
+    // resolved successfully). One-way latch — stays true through later
+    // refetches even when those refetches fail, so stale-while-
+    // revalidate UIs keep rendering the prior values while
+    // `hydrateError` surfaces the refresh failure.
+    get ready() {
+      void state.activate();
+      return state.defaultsResolved.value;
+    },
+    // `rehydrate` and `activate` are themselves activation entry points
+    // — they fire the factory by design. Wrapping them with `gated`
+    // would double-fire (`state.activate()` plus the underlying call),
+    // so they call `state` directly.
+    rehydrate: () => state.rehydrate(),
+    activate: () => state.activate(),
+    get errors() {
+      void state.activate();
+      return errorsProxy;
+    },
+    toRef: gated(pathToRef),
+    setFieldErrors: gated(setFieldErrors),
+    addFieldErrors: gated(addFieldErrors),
+    clearFieldErrors: gated(clearFieldErrors),
+    setFormErrors: gated(setFormErrors),
+    clearFormErrors: gated(clearFormErrors),
+    get meta() {
+      void state.activate();
+      return formMeta;
+    },
+    reset: gated(reset),
+    resetField: gated(resetField),
+    clear: gated(clear),
+    persist: gated(persist),
+    clearPersistedDraft: gated(clearPersistedDraft),
+    focusFirstError: gated(focusFirstError),
+    scrollToFirstError: gated(scrollToFirstError),
+    applyInvalidSubmitPolicy: gated(applyInvalidSubmitPolicyPublic),
+    touch: gated(touch),
+    get history() {
+      void state.activate();
+      return formHistory;
+    },
+    append: gated(fieldArrays.append),
+    prepend: gated(fieldArrays.prepend),
+    insert: gated(fieldArrays.insert),
+    remove: gated(fieldArrays.remove),
+    swap: gated(fieldArrays.swap),
+    move: gated(fieldArrays.move),
+    replace: gated(fieldArrays.replace),
+    get blankPaths() {
+      void state.activate();
+      return blankPathsView;
+    }
   };
 }
 
-const defaultShouldShowErrors = (field, formMeta) => formMeta.submitCount > 0 || field.touched === true && field.dirty;
+const defaultShouldShowErrors = (field, formMeta) => {
+  const hasOwnError = field.errors.some(
+    (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
+  );
+  if (!hasOwnError) return false;
+  if (field.validating === true) return false;
+  if (formMeta.submissionAttempts > 0) return true;
+  return field.touched === true && field.focused !== true;
+};
 const SHOW_ALWAYS = () => true;
 const SHOW_NEVER = () => false;
 function resolveShouldShowErrors(config) {
@@ -2553,7 +2823,7 @@ function resolveShouldShowErrors(config) {
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
-  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && (typeof r.touched === "boolean" || r.touched === null);
+  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean";
 }
 function isHydratedValidationErrorArray(value) {
   if (!Array.isArray(value)) return false;
@@ -2590,7 +2860,8 @@ function walkDuStubs(schema, value, path, warned) {
   if (du !== void 0) {
     const discValue = rec[du.discriminatorKey];
     if (discValue !== void 0 && !du.isVariantSelected(discValue)) {
-      if (warned !== void 0 && __DEV__) {
+      const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
+      if (!isKindBlank && warned !== void 0 && __DEV__) {
         const dotted = path.map((s) => String(s)).join(".") || "(root)";
         const key = `${dotted}::${String(discValue)}`;
         if (!warned.has(key)) {
@@ -2669,9 +2940,45 @@ function cloneVariantSnapshot(value) {
   for (const k of Object.keys(src)) out[k] = cloneVariantSnapshot(src[k]);
   return out;
 }
+function walkAuthoredFromConstraints(value, prefix, out) {
+  if (prefix.length > 0) out.add(canonicalizePath(prefix).key);
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) {
+      walkAuthoredFromConstraints(value[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      walkAuthoredFromConstraints(value[i], [...prefix, i], out);
+    }
+  }
+}
+function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
+  if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
+    const left = withDefaults;
+    const right = withoutDefaults;
+    const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const k of keys) {
+      walkAuthoredFromSchemaDiff(left[k], right[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(withDefaults) && Array.isArray(withoutDefaults)) {
+    const len = Math.max(withDefaults.length, withoutDefaults.length);
+    for (let i = 0; i < len; i++) {
+      walkAuthoredFromSchemaDiff(withDefaults[i], withoutDefaults[i], [...prefix, i], out);
+    }
+    return;
+  }
+  if (!Object.is(withDefaults, withoutDefaults) && prefix.length > 0) {
+    out.add(canonicalizePath(prefix).key);
+  }
+}
 function createFormStore(options) {
   const { formKey, schema, defaultValues, strict = true, hydration } = options;
   const ssr = options.ssr === true;
+  const ssrPrefetch = options.ssrPrefetch;
   const rememberVariants = options.rememberVariants !== false;
   const fieldValidationMode = options.validateOn ?? "change";
   const fieldValidationDebounceMs = normalizeNumericOption({
@@ -2717,6 +3024,29 @@ function createFormStore(options) {
     strict
   });
   const schemaInitialData = schemaResponse.data;
+  const authoredPaths = /* @__PURE__ */ new Set();
+  function rebuildAuthoredPaths(constraints, schemaWithDefaultsData) {
+    authoredPaths.clear();
+    if (constraints !== void 0) {
+      walkAuthoredFromConstraints(constraints, [], authoredPaths);
+    }
+    const slimResponse = schema.getDefaultValues({
+      useDefaultSchemaValues: false,
+      strict
+    });
+    walkAuthoredFromSchemaDiff(schemaWithDefaultsData, slimResponse.data, [], authoredPaths);
+  }
+  rebuildAuthoredPaths(defaultValues, schemaInitialData);
+  function filterAuthoredErrors(errors) {
+    return errors.filter((err) => {
+      const pathSegments = err.path;
+      if (pathSegments.length === 0) return true;
+      const value = getAtPath(form.value, pathSegments);
+      if (value !== void 0) return true;
+      if (authoredPaths.has(canonicalizePath(pathSegments).key)) return true;
+      return !schema.isPreprocessOrCoerceLeaf(pathSegments);
+    });
+  }
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
   const stubbedInitialData = applyDuStubs(schema, initialData, {
     warn: true
@@ -2733,8 +3063,9 @@ function createFormStore(options) {
   const blankPaths = reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
   for (const raw of initialTransientList) {
-    blankPaths.add(raw);
-    originalBlankPaths.add(raw);
+    const key = coerceToPathKey(raw);
+    blankPaths.add(key);
+    originalBlankPaths.add(key);
   }
   const variantMemory = /* @__PURE__ */ new Map();
   function clearVariantMemoryUnderPath(arrayPath) {
@@ -2802,10 +3133,18 @@ function createFormStore(options) {
   });
   const submitting = ref(false);
   const activeSubmissions = ref(0);
-  const submitCount = ref(0);
+  const submissionAttempts = ref(0);
+  const submitted = ref(false);
   const submitError = ref(null);
+  const departAttempts = ref(0);
   const submissionGeneration = ref(0);
   const activeValidations = ref(0);
+  const hydrating = ref(false);
+  const hydrateError = ref(null);
+  const defaultValuesFactory = ref(void 0);
+  const defaultsResolved = ref(false);
+  const activated = ref(false);
+  const activationPromise = ref(void 0);
   const firstValidationDone = ref(!strict || schema.needsAsyncValidation?.() !== true);
   watch(activeValidations, (now, prev) => {
     if (prev > 0 && now === 0) {
@@ -2870,7 +3209,7 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: null
+        touched: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -2890,9 +3229,16 @@ function createFormStore(options) {
       path,
       updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
       connected: patch.connected ?? current?.connected ?? false,
-      focused: patch.focused ?? current?.focused ?? null,
-      blurred: patch.blurred ?? current?.blurred ?? null,
-      touched: patch.touched ?? current?.touched ?? null
+      // focused/blurred use an explicit-undefined guard because
+      // patches legitimately carry `null` to mark a disconnect — the
+      // `??` operator would short-circuit on null and fall through to
+      // `current`, losing the intent. `!== undefined` honours an
+      // explicit null and preserves current only on absence.
+      focused: patch.focused !== void 0 ? patch.focused : current?.focused ?? null,
+      blurred: patch.blurred !== void 0 ? patch.blurred : current?.blurred ?? null,
+      // touched is plain `boolean`; `??` is equivalent to the explicit
+      // guard here because `false` is not nullish.
+      touched: patch.touched ?? current?.touched ?? false
     });
   }
   function applyFormReplacement(next, meta) {
@@ -2923,7 +3269,6 @@ function createFormStore(options) {
   }
   function setValueAtPath(path, value, meta) {
     value = stripSymbolsDeep(value);
-    value = schema.normalizeWriteValueAtPath(value, path);
     if (!isSlimPrimitiveValid(schema, form, path, value)) {
       return false;
     }
@@ -3022,9 +3367,21 @@ function createFormStore(options) {
     } else if (blankPaths.has(pathKey)) {
       blankPaths.delete(pathKey);
     }
+    const wasAuthoredBefore = authoredPaths.has(pathKey);
+    walkAuthoredFromConstraints(value, path, authoredPaths);
+    const newlyAuthored = !wasAuthoredBefore && authoredPaths.has(pathKey);
     const completedValue = mergeStructural(schema, path, value);
     const currentValue = getAtPath(form.value, path);
     if (Object.is(currentValue, completedValue)) {
+      if (newlyAuthored && schema.isPreprocessOrCoerceLeaf(path)) {
+        const modeForAuthoringTransition = meta?.instance?.validateOn ?? fieldValidationMode;
+        if (modeForAuthoringTransition === "change") {
+          scheduleFieldValidation(path, false, {
+            ...meta?.instance?.validateOn !== void 0 ? { mode: meta.instance.validateOn } : {},
+            ...meta?.instance?.debounceMs !== void 0 ? { debounceMs: meta.instance.debounceMs } : {}
+          });
+        }
+      }
       return true;
     }
     const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
@@ -3137,12 +3494,11 @@ function createFormStore(options) {
       prev.controller.abort();
     }
     const controller = new AbortController();
-    const fresh = { controller, timer: null };
+    const fresh = { controller, timer: null, settled: false };
     fieldValidationState.set(key, fresh);
     const run = () => {
       fresh.timer = null;
       if (controller.signal.aborted) return;
-      const data = getAtPath(form.value, path);
       let activeIncremented = false;
       try {
         activeValidations.value += 1;
@@ -3154,17 +3510,16 @@ function createFormStore(options) {
         }
         throw err;
       }
-      void Promise.resolve().then(() => schema.validateAtPath(data, path)).then((response) => {
+      void Promise.resolve().then(() => schema.validateAtPath(form.value, void 0)).then((response) => {
         if (controller.signal.aborted) return;
-        const reStamped = response.success ? [] : response.errors.map((err) => ({
-          ...err,
-          path: [...path, ...err.path]
-        }));
-        applySchemaErrorsForSubtree(path, reStamped);
+        const errors = response.success ? [] : response.errors;
+        const filtered = filterAuthoredErrors(errors);
+        applySchemaErrorsForSubtree([], filtered);
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(key);
+        fresh.settled = true;
       });
     };
     if (immediate || effectiveDebounce === 0) {
@@ -3174,8 +3529,13 @@ function createFormStore(options) {
     }
   }
   function cancelFieldValidation() {
-    for (const entry of fieldValidationState.values()) {
-      if (entry.timer !== null) clearTimeout(entry.timer);
+    for (const [pkey, entry] of fieldValidationState) {
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      } else if (!entry.settled) {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(pkey);
+      }
       entry.controller.abort();
     }
     fieldValidationState.clear();
@@ -3344,7 +3704,12 @@ function createFormStore(options) {
     }
     elementToFormInstance.set(element, formInstanceId);
     sortedRegistrationsCache = null;
-    touchFieldRecord(key, path, { connected: true });
+    const current = fields.get(key);
+    touchFieldRecord(key, path, {
+      connected: true,
+      focused: current?.focused ?? false,
+      blurred: current?.blurred ?? true
+    });
     return true;
   }
   function deregisterElement(path, element) {
@@ -3359,7 +3724,7 @@ function createFormStore(options) {
     const remaining = record.elements.size;
     if (remaining === 0) {
       elements.delete(key);
-      touchFieldRecord(key, path, { connected: false });
+      touchFieldRecord(key, path, { connected: false, focused: null, blurred: null });
     }
     return remaining;
   }
@@ -3368,7 +3733,11 @@ function createFormStore(options) {
     const { key } = canonicalizePath(path);
     const current = fields.get(key);
     if (current?.connected === true) return;
-    touchFieldRecord(key, path, { connected: true });
+    touchFieldRecord(key, path, {
+      connected: true,
+      focused: current?.focused ?? false,
+      blurred: current?.blurred ?? true
+    });
   }
   function markFocused(path, focused, meta) {
     const { key } = canonicalizePath(path);
@@ -3377,7 +3746,7 @@ function createFormStore(options) {
       blurred: !focused,
       // `touched` flips to true on blur and stays true thereafter; while
       // a field is currently focused we keep whatever value it held.
-      touched: focused ? fields.get(key)?.touched ?? null : true
+      touched: focused ? fields.get(key)?.touched ?? false : true
     });
     const focusMode = meta?.instance?.validateOn ?? fieldValidationMode;
     if (!focused && focusMode === "blur") {
@@ -3412,6 +3781,84 @@ function createFormStore(options) {
   function clear(path) {
     return setValueAtPath(path, schema.getEmptyValueAtPath(path));
   }
+  function rehydrate() {
+    const factory = defaultValuesFactory.value;
+    if (factory === void 0) {
+      throw new Error(
+        "[attaform] form.rehydrate(): no defaultValues factory was captured. Configure useForm({ defaultValues: () => ... }) to enable rehydrate."
+      );
+    }
+    return fireFactory(factory);
+  }
+  function fireFactory(factory) {
+    activated.value = true;
+    const promise = runFactoryAndApply(factory);
+    activationPromise.value = promise;
+    void promise.finally(() => {
+      if (activationPromise.value === promise) activationPromise.value = void 0;
+    });
+    return promise;
+  }
+  function activate() {
+    if (ssrPrefetch !== void 0) {
+      ssrPrefetch.enqueue();
+      if (!ssrPrefetch.shouldFire()) return Promise.resolve();
+    }
+    if (defaultsResolved.value === true) return Promise.resolve();
+    if (activationPromise.value !== void 0) return activationPromise.value;
+    if (activated.value === true) return Promise.resolve();
+    const factory = defaultValuesFactory.value;
+    if (factory === void 0) return Promise.resolve();
+    return fireFactory(factory);
+  }
+  async function runFactoryAndApply(factory) {
+    hydrating.value = true;
+    try {
+      const value = await factory();
+      walkAuthoredFromConstraints(value, [], authoredPaths);
+      const full = mergeSparseHydration(
+        toRaw(form.value),
+        value,
+        schema
+      );
+      applyFormReplacement(full, { hydration: true });
+      scheduleFieldValidation(
+        [],
+        true
+        /* immediate */
+      );
+      clearHydrationFailedEntry();
+      hydrateError.value = null;
+      defaultsResolved.value = true;
+    } catch (error) {
+      clearHydrationFailedEntry();
+      hydrateError.value = appendHydrationFailedEntry(error);
+    } finally {
+      hydrating.value = false;
+    }
+  }
+  function clearHydrationFailedEntry() {
+    const existing = schemaErrors.get(FORM_ERRORS_PATH_KEY);
+    if (existing === void 0) return;
+    const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
+    if (filtered.length === 0) {
+      schemaErrors.delete(FORM_ERRORS_PATH_KEY);
+    } else {
+      schemaErrors.set(FORM_ERRORS_PATH_KEY, filtered);
+    }
+  }
+  function appendHydrationFailedEntry(error) {
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Hydration failed";
+    const entry = {
+      message,
+      path: [...FORM_ERRORS_PATH],
+      formKey,
+      code: AttaformErrorCode.HydrationFailed
+    };
+    const existing = schemaErrors.get(FORM_ERRORS_PATH_KEY) ?? [];
+    schemaErrors.set(FORM_ERRORS_PATH_KEY, [...existing, entry]);
+    return entry;
+  }
   function reset(nextDefaultValues) {
     const resetSource = nextDefaultValues ?? defaultValues;
     const completedResetConstraints = resetSource === void 0 ? void 0 : mergeStructural(schema, [], resetSource);
@@ -3421,6 +3868,7 @@ function createFormStore(options) {
       strict
     });
     const next = resetResponse.data;
+    rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -3463,16 +3911,18 @@ function createFormStore(options) {
         path: record.path,
         updatedAt: now,
         connected: record.connected,
-        focused: null,
-        blurred: null,
-        touched: null
+        focused: record.focused,
+        blurred: record.blurred,
+        touched: false
       });
     }
     submissionGeneration.value += 1;
     submitting.value = false;
     activeSubmissions.value = 0;
-    submitCount.value = 0;
+    submissionAttempts.value = 0;
+    submitted.value = false;
     submitError.value = null;
+    departAttempts.value = 0;
     cancelFieldValidation();
     variantMemory.clear();
     for (const listener of resetListeners) {
@@ -3545,9 +3995,9 @@ function createFormStore(options) {
       path: record.path,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       connected: record.connected,
-      focused: null,
-      blurred: null,
-      touched: null
+      focused: record.focused,
+      blurred: record.blurred,
+      touched: false
     });
   }
   function isPathPrefix(prefix, candidate) {
@@ -3610,8 +4060,18 @@ function createFormStore(options) {
     shouldShowErrors: resolvedShouldShowErrors,
     submitting,
     activeSubmissions,
-    submitCount,
+    submissionAttempts,
+    submitted,
     submitError,
+    departAttempts,
+    hydrating,
+    hydrateError,
+    defaultValuesFactory,
+    defaultsResolved,
+    activated,
+    activationPromise,
+    rehydrate,
+    activate,
     submissionGeneration,
     activeValidations,
     firstValidationDone,
@@ -3626,6 +4086,7 @@ function createFormStore(options) {
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
+    applySchemaErrorsForSubtree,
     setAllUserErrors,
     addUserErrors,
     clearUserErrors,
@@ -3871,6 +4332,11 @@ const PROTOCOL_VERSION = 1;
 const JOIN_COLLECTION_WINDOW_MS = 50;
 const SNAPSHOT_TIMEOUT_MS = 200;
 const MAX_LEADER_ATTEMPTS = 3;
+function isFileLikeValue(value) {
+  if (typeof File !== "undefined" && value instanceof File) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return false;
+}
 function isDangerousSegment(s) {
   return s === "__proto__" || s === "constructor" || s === "prototype";
 }
@@ -3880,6 +4346,32 @@ function pathContainsDangerousSegment(path) {
   }
   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 = [];
@@ -3892,6 +4384,7 @@ 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));
@@ -3996,6 +4489,7 @@ function createMultiTabSyncModule(state, channelName, options) {
     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);
@@ -4035,6 +4529,9 @@ function createMultiTabSyncModule(state, channelName, options) {
     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 = [];
@@ -4069,11 +4566,7 @@ function createMultiTabSyncModule(state, channelName, options) {
   }
   function handleSnapshot(msg) {
     if (lifecycle !== "joining") return;
-    try {
-      options.validateForm(msg.form);
-    } catch {
-      return;
-    }
+    if (!isInboundShapeAcceptable(state.schema, [], msg.form)) return;
     if (snapshotTimeoutTimer !== null) {
       clearTimeout(snapshotTimeoutTimer);
       snapshotTimeoutTimer = null;
@@ -4212,15 +4705,26 @@ function isSecureContext() {
   return typeof window !== "undefined" && window.isSecureContext === true;
 }
 
-function useAbstractForm(configuration) {
+function resolveTrichotomy(input) {
+  if (typeof input === "function") {
+    return { kind: "async", factory: input };
+  }
+  return { kind: "sync", value: input };
+}
+
+function useAbstractForm(configuration, options) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
     throw new InvalidUseFormConfigError();
   }
   const key = resolveFormKey(configuration.key);
   const instance = getCurrentInstance();
   if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
-  const registry = useRegistry();
-  const merged = mergeWithDefaults(registry.defaults, configuration);
+  const registry = options?.registry ?? useRegistry();
+  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
+  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
+  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
+  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
+  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
   const maxRecursionDepth = normalizeNumericOption({
     value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
     source: "useForm.maxRecursionDepth",
@@ -4241,7 +4745,27 @@ function useAbstractForm(configuration) {
     warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
     warnOnPersistDivergence(key, existing, configuration.persist);
   }
+  const hadPendingHydration = registry.pendingHydration.has(key);
   const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
+    state.defaultsResolved.value = true;
+  }
+  if (existing === void 0 && resolvedDefaults.kind === "async") {
+    const factory = resolvedDefaults.factory;
+    state.defaultValuesFactory.value = factory;
+    if (hadPendingHydration) {
+      state.hydrating.value = false;
+      state.defaultsResolved.value = true;
+    } else if (registry.ssr) {
+      if (configuration.__ssrAccessed === true) {
+        registry.enqueuePrefetch(key);
+      }
+      onServerPrefetch(() => {
+        if (!registry.shouldPrefetch(key)) return;
+        return state.activate();
+      });
+    }
+  }
   if (getCurrentScope() !== void 0) {
     const releaseConsumer = registry.trackConsumer(key);
     onScopeDispose(releaseConsumer);
@@ -4269,7 +4793,7 @@ function useAbstractForm(configuration) {
       void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
     }
   }
-  if (existing === void 0 && merged.multiTab !== false && configuration.key !== void 0 && !registry.ssr) {
+  if (existing === void 0 && merged.multiTab === true && configuration.key !== void 0 && !registry.ssr) {
     const hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
     const secureContext = isSecureContext();
     if (hasBroadcastChannel && secureContext) {
@@ -4376,7 +4900,10 @@ function buildFreshState(key, schema, configuration, registry) {
     configuration.defaultValues,
     schema
   );
-  const initialBlankPaths = pending === void 0 ? walked.paths : void 0;
+  let initialBlankPaths;
+  if (pending === void 0) {
+    initialBlankPaths = walked.paths;
+  }
   const resolvedSensitiveNames = configuration.sensitiveNames;
   const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : createIsSensitivePath(resolvedSensitiveNames);
   const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : createSegmentMatchesSensitive(resolvedSensitiveNames);
@@ -4389,6 +4916,21 @@ function buildFreshState(key, schema, configuration, registry) {
     ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
     ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
     ssr: registry.ssr,
+    // Server-only: bind the SSR prefetch coordination handles. `enqueue`
+    // records intent on every `state.activate()` so a wizard skip-list
+    // override or a future transform mark has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail when the
+    // wizard explicitly skipped this key — even an explicit
+    // `form.activate()` defers to the wizard's render-efficiency
+    // skip-list on the server.
+    ...registry.ssr ? {
+      ssrPrefetch: {
+        enqueue: () => {
+          registry.enqueuePrefetch(key);
+        },
+        shouldFire: () => registry.shouldPrefetch(key)
+      }
+    } : {},
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
     ...configuration.shouldShowErrors !== void 0 ? { shouldShowErrors: configuration.shouldShowErrors } : {},
@@ -4569,8 +5111,9 @@ function wirePersistence(state, config) {
         state.originalBlankPaths.delete(k);
       }
       for (const k of payload.data.blankPaths ?? []) {
-        state.blankPaths.add(k);
-        state.originalBlankPaths.add(k);
+        const key2 = coerceToPathKey(k);
+        state.blankPaths.add(key2);
+        state.originalBlankPaths.add(key2);
       }
       if (include === "form+errors") {
         if (payload.data.schemaErrors !== void 0) {
@@ -4751,7 +5294,9 @@ function isDescendantPathKey(candidate, ancestor) {
 }
 
 let injectedInstanceCounter = 0;
-function injectForm(key) {
+function injectForm(input) {
+  const key = typeof input === "string" ? input : input?.key;
+  const ssrAccessed = typeof input === "object" && input !== null ? input.__ssrAccessed === true : false;
   const instance = getCurrentInstance();
   if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
   const registry = useRegistry();
@@ -4761,6 +5306,10 @@ function injectForm(key) {
     const releaseConsumer = registry.trackConsumer(state.formKey);
     onScopeDispose(releaseConsumer);
   }
+  if (registry.ssr && ssrAccessed) {
+    registry.enqueuePrefetch(state.formKey);
+    onServerPrefetch(() => state.activate());
+  }
   const apiOptions = {};
   const history = state.modules.get("history");
   if (history !== void 0) {
@@ -4778,20 +5327,17 @@ function resolveState(key, registry) {
   if (key !== void 0) {
     const stored = registry.forms.get(key);
     if (stored === void 0) {
-      warnMiss(`no form registered for key '${key}'`, registry.ssr);
+      warnMiss$1(`no form registered for key '${key}'`, registry.ssr);
       return null;
     }
     return stored;
   }
   const ambient = inject(kFormContext, null);
-  if (ambient === null) {
-    warnMiss("no ambient form context", registry.ssr);
-    return null;
-  }
+  if (ambient === null) return null;
   warnIfAmbientProviderHadDuplicates();
   return ambient;
 }
-function warnMiss(detail, ssr) {
+function warnMiss$1(detail, ssr) {
   if (!__DEV__ || ssr) return;
   const frame = captureUserCallSite();
   console.warn(
@@ -4816,5 +5362,1044 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, isUnset as a, defaultShouldShowErrors as b, defineCoercion as c, defaultCoercionRules as d, useAbstractForm as e, setAtPath as f, getAtPath as g, humanize as h, injectForm as i, isPlainRecord as j, normalizeNumericOption as n, slimKindOf as s, unset as u };
-//# sourceMappingURL=attaform.B3ZaPIzS.mjs.map
+const LAZY_BRAND = Symbol.for("attaform/wizard-lazy");
+function lazy(resolve) {
+  return { [LAZY_BRAND]: true, resolve };
+}
+function isLazyMarker(value) {
+  return typeof value === "object" && value !== null && LAZY_BRAND in value;
+}
+
+const NOOP_WIZARD_HISTORY = {
+  push() {
+  },
+  replace() {
+  },
+  read() {
+    return void 0;
+  },
+  subscribe() {
+  },
+  dispose() {
+  }
+};
+function createWizardHistory(param) {
+  if (typeof window === "undefined") return NOOP_WIZARD_HISTORY;
+  const subscribers = [];
+  let disposed = false;
+  function buildUrl(key) {
+    const url = new URL(window.location.href);
+    url.searchParams.set(param, key);
+    return url.toString();
+  }
+  function handlePopstate() {
+    if (disposed) return;
+    const url = new URL(window.location.href);
+    const value = url.searchParams.get(param) ?? void 0;
+    for (const subscriber of subscribers) subscriber(value);
+  }
+  window.addEventListener("popstate", handlePopstate);
+  function safeWriteState(key, op) {
+    try {
+      const fn = op === "push" ? window.history.pushState : window.history.replaceState;
+      fn.call(window.history, {}, "", buildUrl(key));
+    } catch {
+    }
+  }
+  return {
+    push(key) {
+      if (disposed) return;
+      safeWriteState(key, "push");
+    },
+    replace(key) {
+      if (disposed) return;
+      safeWriteState(key, "replace");
+    },
+    read() {
+      const url = new URL(window.location.href);
+      return url.searchParams.get(param) ?? void 0;
+    },
+    subscribe(callback) {
+      if (disposed) return;
+      subscribers.push(callback);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.length = 0;
+      window.removeEventListener("popstate", handlePopstate);
+    }
+  };
+}
+
+const NOOP_FINGERPRINT = "attaform:wizard-noop";
+const EMPTY_SLIM_KINDS = /* @__PURE__ */ new Set();
+function buildNoopWizardSchema(formKey) {
+  const emptyValue = {};
+  const success = {
+    success: true,
+    data: emptyValue,
+    errors: void 0,
+    formKey
+  };
+  const defaultsResponse = {
+    success: true,
+    data: emptyValue,
+    errors: void 0,
+    formKey
+  };
+  return {
+    fingerprint: () => NOOP_FINGERPRINT,
+    getDefaultValues: () => defaultsResponse,
+    getDefaultAtPath: () => void 0,
+    getEmptyValueAtPath: () => void 0,
+    isPreprocessOrCoerceLeaf: () => false,
+    arrayShapeAtPath: () => void 0,
+    getSchemasAtPath: () => [],
+    validateAtPath: () => success,
+    getSlimPrimitiveTypesAtPath: () => new Set(EMPTY_SLIM_KINDS),
+    isLeafAtPath: () => false,
+    isRequiredAtPath: () => false,
+    getUnionDiscriminatorAtPath: () => void 0
+  };
+}
+
+function buildWizardStatusesProxy(statuses) {
+  const snapshot = computed(() => {
+    const result = {};
+    for (const key of Object.keys(statuses)) {
+      result[key] = statuses[key].value;
+    }
+    return result;
+  });
+  const target = (() => {
+  });
+  const proxyToString = () => JSON.stringify(snapshot.value);
+  const proxyToPrimitive = (hint) => hint === "number" ? NaN : proxyToString();
+  return new Proxy(target, {
+    apply(_, __, args) {
+      const key = args[0];
+      if (key === void 0) return snapshot.value;
+      const computedEntry = statuses[key];
+      if (computedEntry === void 0) return void 0;
+      return computedEntry.value;
+    },
+    get(_, key) {
+      if (typeof key === "symbol") {
+        if (key === Symbol.toPrimitive) return proxyToPrimitive;
+        return Reflect.get(target, key);
+      }
+      if (key === "toJSON") return () => snapshot.value;
+      if (key === "toString") return proxyToString;
+      if (key === "valueOf")
+        return function() {
+          return this;
+        };
+      const computedEntry = statuses[key];
+      if (computedEntry === void 0) return void 0;
+      return computedEntry.value;
+    },
+    has(_, key) {
+      if (typeof key === "symbol") return Reflect.has(target, key);
+      return Object.hasOwn(statuses, key);
+    },
+    ownKeys() {
+      return Object.keys(statuses);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key === "symbol") return void 0;
+      const computedEntry = statuses[key];
+      if (computedEntry === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: computedEntry.value
+      };
+    },
+    set(_, key) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] wizard.statuses is read-only \u2014 write to "${String(key)}" was ignored. Statuses derive from each form's meta; mutate the underlying form instead.`
+        );
+      }
+      return true;
+    },
+    deleteProperty(_, key) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] wizard.statuses is read-only \u2014 delete of "${String(key)}" was ignored.`
+        );
+      }
+      return true;
+    },
+    defineProperty: () => true
+  });
+}
+
+const DEFAULT_STEP_PARAM = "step";
+const PENDING_STATUS = {
+  valid: false,
+  dirty: false,
+  submitted: false,
+  errorCount: 0
+};
+const NOOP_VALID_STATUS = {
+  valid: true,
+  dirty: false,
+  submitted: false,
+  errorCount: 0
+};
+function useWizard(options) {
+  const rawSteps = Array.isArray(options.steps) ? options.steps : [];
+  if (rawSteps.length === 0 && __DEV__) {
+    console.error(
+      "[attaform] useWizard({ steps }): expected a non-empty array of step slots. Continuing with an empty step list \u2014 wizard.currentStep reads as undefined, navigation refuses, handleSubmit no-ops."
+    );
+  }
+  const registry = useRegistry();
+  const noopForms = /* @__PURE__ */ new Map();
+  const lazyNoopScope = effectScope(true);
+  for (const slot of rawSteps) {
+    if (typeof slot !== "string") continue;
+    if (noopForms.has(slot)) continue;
+    const noop = useAbstractForm({
+      schema: buildNoopWizardSchema(slot),
+      key: slot
+    });
+    noopForms.set(slot, noop);
+  }
+  function getOrBuildNoop(key) {
+    const existing2 = noopForms.get(key);
+    if (existing2 !== void 0) return existing2;
+    const noop = lazyNoopScope.run(
+      () => useAbstractForm(
+        {
+          schema: buildNoopWizardSchema(key),
+          key
+        },
+        { registry }
+      )
+    );
+    if (noop === void 0) {
+      const stub = { key };
+      return stub;
+    }
+    noopForms.set(key, noop);
+    formsAccumulator.set(key, noop);
+    return noop;
+  }
+  const trackedKeys = /* @__PURE__ */ new Set();
+  function trackOnce(form) {
+    if (trackedKeys.has(form.key)) return;
+    trackedKeys.add(form.key);
+    if (getCurrentScope() !== void 0) {
+      const release = registry.trackConsumer(form.key);
+      onScopeDispose(release);
+    }
+  }
+  for (const slot of rawSteps) {
+    if (typeof slot === "string") {
+      const noop = noopForms.get(slot);
+      if (noop !== void 0) trackOnce(noop);
+    } else if (isAnyForm(slot)) {
+      trackOnce(slot);
+    }
+  }
+  const lazyEpoch = ref(0);
+  const lazyComputeds = /* @__PURE__ */ new Map();
+  const activeKey = ref("");
+  const formsAccumulator = /* @__PURE__ */ new Map();
+  for (const slot of rawSteps) {
+    if (typeof slot === "string") {
+      const noop = noopForms.get(slot);
+      if (noop !== void 0) formsAccumulator.set(noop.key, noop);
+    } else if (isAnyForm(slot)) {
+      formsAccumulator.set(slot.key, slot);
+    }
+  }
+  const slotForms = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      return formsAccumulator.get(key);
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsAccumulator.has(key);
+    },
+    ownKeys() {
+      return [...formsAccumulator.keys()];
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsAccumulator.get(key);
+      if (form === void 0) return void 0;
+      return { configurable: true, enumerable: true, writable: false, value: form };
+    }
+  });
+  const slotCtx = computed(() => ({
+    forms: slotForms,
+    currentKey: activeKey.value === "" ? void 0 : activeKey.value
+  }));
+  function resolveSlot(slot, index, ctx) {
+    if (typeof slot === "string") {
+      return getOrBuildNoop(slot);
+    }
+    if (isLazyMarker(slot)) {
+      const c = lazyComputeds.get(index);
+      return c === void 0 ? void 0 : resolveSlotResult(c.value);
+    }
+    if (typeof slot === "function") {
+      const result = slot(ctx);
+      return resolveSlotResult(result);
+    }
+    if (isAnyForm(slot)) return slot;
+    return void 0;
+  }
+  function resolveSlotResult(result) {
+    if (result === void 0) return void 0;
+    if (typeof result === "string") {
+      return getOrBuildNoop(result);
+    }
+    return result;
+  }
+  const lazyCtx = {
+    forms: slotForms,
+    get currentKey() {
+      return activeKey.value === "" ? void 0 : activeKey.value;
+    }
+  };
+  for (let i = 0; i < rawSteps.length; i++) {
+    const slot = rawSteps[i];
+    if (isLazyMarker(slot)) {
+      const idx = i;
+      const marker = slot;
+      lazyComputeds.set(
+        idx,
+        computed(() => {
+          void lazyEpoch.value;
+          return marker.resolve(lazyCtx);
+        })
+      );
+    }
+  }
+  const compiledSteps = computed(() => {
+    const ctx = slotCtx.value;
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < rawSteps.length; i++) {
+      const slot = rawSteps[i];
+      const form = resolveSlot(slot, i, ctx);
+      if (form === void 0) continue;
+      if (seen.has(form.key)) {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] useWizard: step "${form.key}" appears in more than one slot. The wizard treats the first occurrence as canonical and drops later duplicates.`
+          );
+        }
+        continue;
+      }
+      seen.add(form.key);
+      trackOnce(form);
+      out.push({ key: form.key, form });
+    }
+    return out;
+  });
+  const activeIndex = computed(() => {
+    const key = activeKey.value;
+    if (key === "") return -1;
+    const list = compiledSteps.value;
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].key === key) return i;
+    }
+    return -1;
+  });
+  const currentStep = computed(() => {
+    const key = activeKey.value;
+    if (key !== "") return key;
+    const first = compiledSteps.value[0];
+    return first === void 0 ? void 0 : first.key;
+  });
+  const activeForm = computed(() => {
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    if (idx >= 0 && idx < list.length) {
+      return list[idx].form;
+    }
+    const first = list[0];
+    return first === void 0 ? void 0 : first.form;
+  });
+  const isFinalStep = computed(() => {
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    return list.length > 0 && idx === list.length - 1;
+  });
+  const count = computed(() => compiledSteps.value.length);
+  const formsRecord = computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) out[step.key] = step.form;
+    return out;
+  });
+  const allValues = computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) {
+      const source = step.form;
+      out[step.key] = source.values;
+    }
+    return out;
+  });
+  const allErrors = computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) {
+      const source = step.form;
+      const list = [];
+      const store = registry.forms.get(step.key);
+      const resolved = store?.defaultsResolved.value === true;
+      if (resolved) {
+        const errors = source.meta?.errors ?? [];
+        for (const err of errors) {
+          const entry = {
+            formKey: step.key,
+            path: err.path,
+            message: err.message
+          };
+          if (err.code !== void 0) entry.code = err.code;
+          list.push(entry);
+        }
+      }
+      out[step.key] = list;
+    }
+    return out;
+  });
+  const seedRef = ref(void 0);
+  const seedInput = options.defaultStatuses;
+  if (seedInput !== void 0) {
+    const resolved = resolveTrichotomy(seedInput);
+    if (resolved.kind === "sync") {
+      seedRef.value = resolved.value;
+    } else {
+      const eager = resolved.factory();
+      if (eager instanceof Promise) {
+        void eager.then((value) => {
+          seedRef.value = value;
+        });
+      } else {
+        seedRef.value = eager;
+      }
+    }
+  }
+  const statusCache = /* @__PURE__ */ new Map();
+  function statusFor(form) {
+    const cached = statusCache.get(form.key);
+    if (cached !== void 0) return cached;
+    const source = form;
+    const computedStatus = computed(() => {
+      const store = registry.forms.get(form.key);
+      const resolved = store?.defaultsResolved.value === true;
+      if (resolved) {
+        const meta = source.meta;
+        if (meta !== void 0 && meta !== null) {
+          return {
+            valid: meta.valid,
+            dirty: meta.dirty,
+            submitted: meta.submitted,
+            errorCount: meta.errorCount
+          };
+        }
+      }
+      if (noopForms.has(form.key)) return NOOP_VALID_STATUS;
+      const seedMap = seedRef.value;
+      if (seedMap !== void 0 && Object.hasOwn(seedMap, form.key)) {
+        return seedMap[form.key];
+      }
+      return PENDING_STATUS;
+    });
+    statusCache.set(form.key, computedStatus);
+    return computedStatus;
+  }
+  const statusesRecord = new Proxy({}, {
+    get(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) {
+        const cached = statusCache.get(key);
+        if (cached !== void 0) return cached;
+        return void 0;
+      }
+      return statusFor(form);
+    },
+    ownKeys() {
+      return Object.keys(formsRecord.value);
+    },
+    has(_, key) {
+      if (typeof key !== "string") return false;
+      return formsRecord.value[key] !== void 0;
+    },
+    getOwnPropertyDescriptor(_, key) {
+      if (typeof key !== "string") return void 0;
+      const form = formsRecord.value[key];
+      if (form === void 0) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: statusFor(form)
+      };
+    }
+  });
+  const statuses = buildWizardStatusesProxy(statusesRecord);
+  if (__DEV__ && seedRef.value !== void 0) {
+    const seedMap = seedRef.value;
+    const known = new Set(compiledSteps.value.map((s) => s.key));
+    const unknown = [];
+    for (const key of Object.keys(seedMap)) {
+      if (!known.has(key)) unknown.push(key);
+    }
+    if (unknown.length > 0) {
+      console.warn(
+        `[attaform] useWizard.defaultStatuses: seed contains unknown key(s) ${unknown.map((k) => `"${k}"`).join(", ")}. Known step keys: ${[...known].map((k) => `"${k}"`).join(", ")}.`
+      );
+    }
+  }
+  const progressOverride = options.progress;
+  const progress = computed(() => {
+    if (progressOverride !== void 0) {
+      return progressOverride(compiledSteps.value);
+    }
+    const list = compiledSteps.value;
+    if (list.length === 0) return 0;
+    let valid = 0;
+    for (const step of list) {
+      const status = statusFor(step.form).value;
+      if (status.valid === true) valid += 1;
+    }
+    return valid / list.length;
+  });
+  const complete = computed(() => {
+    if (!isFinalStep.value) return false;
+    for (const step of compiledSteps.value) {
+      if (statusFor(step.form).value.valid !== true) return false;
+    }
+    return true;
+  });
+  const canAdvance = computed(() => activeIndex.value < count.value - 1);
+  const canGoBack = computed(() => activeIndex.value > 0);
+  const visited = ref([]);
+  const wantsDefaultUrlSync = options.restore !== false || options.persist !== false;
+  const historyHandle = wantsDefaultUrlSync ? createWizardHistory(DEFAULT_STEP_PARAM) : NOOP_WIZARD_HISTORY;
+  const injectedResolver = inject(kAttaformWizardActiveStepResolver, null);
+  const urlMirror = ref(void 0);
+  const initialUrlValue = injectedResolver !== null ? injectedResolver(DEFAULT_STEP_PARAM) : historyHandle.read();
+  urlMirror.value = initialUrlValue;
+  historyHandle.subscribe((value) => {
+    urlMirror.value = value;
+  });
+  const restoreCallback = options.restore === false ? void 0 : options.restore !== void 0 ? options.restore : () => {
+    const value = urlMirror.value;
+    return value === void 0 ? void 0 : { step: value };
+  };
+  const persistCallback = options.persist === false ? void 0 : options.persist !== void 0 ? options.persist : (state) => {
+    if (state.step === void 0) return;
+    historyHandle.replace(state.step);
+  };
+  function isCompiledKey(key) {
+    const list = compiledSteps.value;
+    for (const step of list) if (step.key === key) return true;
+    return false;
+  }
+  function firstKey() {
+    const first = compiledSteps.value[0];
+    return first === void 0 ? void 0 : first.key;
+  }
+  let initialKey;
+  const restoredAtSetup = restoreCallback?.();
+  const restoredStep = restoredAtSetup?.step;
+  if (restoredStep !== void 0 && isCompiledKey(restoredStep)) {
+    initialKey = restoredStep;
+  } else {
+    if (__DEV__ && restoredStep !== void 0 && restoredStep !== "" && !isCompiledKey(restoredStep)) {
+      console.warn(
+        `[attaform] useWizard: restore() yielded step "${restoredStep}" which is not in the compiled step list. Falling back to the first step.`
+      );
+    }
+    initialKey = firstKey();
+  }
+  if (initialKey !== void 0) {
+    activeKey.value = initialKey;
+    visited.value = [initialKey];
+  }
+  if (registry.ssr) {
+    for (const step of compiledSteps.value) {
+      if (step.key === initialKey) {
+        registry.enqueuePrefetch(step.key);
+      } else {
+        registry.skipPrefetch(step.key);
+      }
+    }
+  }
+  if (!registry.ssr) {
+    for (const step of compiledSteps.value) {
+      const source = step.form;
+      if (typeof source.activate === "function") void source.activate();
+    }
+  }
+  let lastPersisted = initialUrlValue;
+  if (restoreCallback !== void 0) {
+    watch(
+      () => restoreCallback()?.step,
+      (step) => {
+        if (step === void 0) return;
+        if (!isCompiledKey(step)) {
+          if (__DEV__) {
+            console.warn(
+              `[attaform] useWizard: restore() yielded step "${step}" which is not in the compiled step list. Ignoring.`
+            );
+          }
+          return;
+        }
+        if (step === activeKey.value) return;
+        activeKey.value = step;
+        if (!visited.value.includes(step)) visited.value.push(step);
+      }
+    );
+  }
+  if (persistCallback !== void 0) {
+    watch(
+      () => activeKey.value,
+      (next2) => {
+        if (next2 === lastPersisted) return;
+        lastPersisted = next2;
+        persistCallback({ step: next2 });
+        urlMirror.value = next2;
+      }
+    );
+    if (initialKey !== void 0 && initialKey !== initialUrlValue && initialUrlValue === void 0) {
+      lastPersisted = initialKey;
+      persistCallback({ step: initialKey });
+      urlMirror.value = initialKey;
+    }
+  }
+  const submitting = ref(false);
+  const submissionAttempts = ref(0);
+  const done = ref(false);
+  function activateForm(form) {
+    const source = form;
+    if (typeof source.activate === "function") {
+      void source.activate();
+    }
+  }
+  function moveTo(key, options2) {
+    if (activeKey.value === key) return;
+    activeKey.value = key;
+    if (!visited.value.includes(key)) visited.value.push(key);
+    const list = compiledSteps.value;
+    for (const step of list) {
+      if (step.key === key) {
+        activateForm(step.form);
+        return;
+      }
+    }
+  }
+  function recordDeparture(key) {
+    const store = registry.forms.get(key);
+    if (store !== void 0) store.departAttempts.value += 1;
+  }
+  async function next() {
+    if (submitting.value) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] wizard.next(): blocked while a submit is in flight. Wait for handleSubmit to settle.`
+        );
+      }
+      return;
+    }
+    const list = compiledSteps.value;
+    if (list.length === 0) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.next(): wizard has no compiled steps; no-op.`);
+      }
+      return;
+    }
+    const idx = activeIndex.value;
+    if (idx < 0 || idx >= list.length - 1) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] wizard.next(): already on the final step ("${activeKey.value}"). Use wizard.handleSubmit() to submit.`
+        );
+      }
+      return;
+    }
+    recordDeparture(activeKey.value);
+    const target = list[idx + 1];
+    moveTo(target.key);
+  }
+  function back() {
+    if (submitting.value) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.back(): blocked while a submit is in flight.`);
+      }
+      return;
+    }
+    if (compiledSteps.value.length === 0) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.back(): wizard has no compiled steps; no-op.`);
+      }
+      return;
+    }
+    const idx = activeIndex.value;
+    if (idx <= 0) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.back(): already on the first step ("${activeKey.value}").`);
+      }
+      return;
+    }
+    recordDeparture(activeKey.value);
+    const target = compiledSteps.value[idx - 1];
+    moveTo(target.key);
+  }
+  function goTo(key) {
+    if (submitting.value) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.goTo(): blocked while a submit is in flight.`);
+      }
+      return;
+    }
+    if (!isCompiledKey(key)) {
+      if (__DEV__) {
+        const known = compiledSteps.value.map((s) => `"${s.key}"`).join(", ");
+        console.warn(`[attaform] wizard.goTo("${key}"): unknown step key. Known keys: ${known}.`);
+      }
+      return;
+    }
+    if (key !== activeKey.value) recordDeparture(activeKey.value);
+    moveTo(key);
+  }
+  function buildSubmitContext(valuesMap, currentKey, isFinal) {
+    return {
+      values: valuesMap,
+      get: ((form) => valuesMap[form.key]),
+      currentKey,
+      isFinal
+    };
+  }
+  async function processOne(form) {
+    const full = form;
+    let activationFailure;
+    try {
+      if (typeof full.activate === "function") await full.activate();
+    } catch (err) {
+      activationFailure = err?.message ?? String(err);
+    }
+    if (activationFailure === void 0 && full.hydrateError != null) {
+      activationFailure = full.hydrateError.message;
+    }
+    if (activationFailure !== void 0) {
+      return {
+        success: false,
+        data: void 0,
+        errors: [
+          {
+            formKey: form.key,
+            path: [],
+            message: `Form '${form.key}' failed to activate: ${activationFailure}`,
+            code: AttaformErrorCode.ActivationFailed
+          }
+        ],
+        formKey: form.key
+      };
+    }
+    return full.process();
+  }
+  function collectErrors(results) {
+    const out = [];
+    for (const step of compiledSteps.value) {
+      const processed = results.get(step.key);
+      if (processed === void 0 || processed.success === true) continue;
+      for (const err of processed.errors) {
+        const entry = {
+          formKey: err.formKey,
+          path: err.path,
+          message: err.message
+        };
+        if (err.code !== void 0) entry.code = err.code;
+        out.push(entry);
+      }
+    }
+    return out;
+  }
+  function handleSubmit(onSubmit, onError) {
+    return async function submitHandler(event) {
+      if (event !== void 0 && typeof event.preventDefault === "function") {
+        event.preventDefault();
+      }
+      if (compiledSteps.value.length === 0) {
+        if (__DEV__) {
+          console.warn(`[attaform] wizard.handleSubmit: wizard has no compiled steps; no-op.`);
+        }
+        return;
+      }
+      if (submitting.value) {
+        if (__DEV__) {
+          console.warn(
+            `[attaform] wizard.handleSubmit: re-entrant submit while a prior call is still in flight; resolving no-op.`
+          );
+        }
+        return;
+      }
+      submitting.value = true;
+      try {
+        const currentKey = activeKey.value;
+        const final = isFinalStep.value;
+        const list = compiledSteps.value;
+        const results = /* @__PURE__ */ new Map();
+        if (final) {
+          await Promise.all(
+            list.map(async (step) => {
+              const result = await processOne(step.form);
+              results.set(step.key, result);
+            })
+          );
+        } else {
+          const active = activeForm.value;
+          const result = await processOne(active);
+          results.set(active.key, result);
+        }
+        for (const key of results.keys()) {
+          const store = registry.forms.get(key);
+          if (store !== void 0) store.submissionAttempts.value += 1;
+        }
+        submissionAttempts.value += 1;
+        const errors = collectErrors(results);
+        if (errors.length === 0) {
+          const valuesMap = {};
+          for (const step of list) {
+            const processed = results.get(step.key);
+            if (processed !== void 0 && processed.success === true) {
+              valuesMap[step.key] = processed.data;
+            } else {
+              const source = step.form;
+              valuesMap[step.key] = source.values;
+            }
+          }
+          const ctx = buildSubmitContext(valuesMap, currentKey, final);
+          await onSubmit(ctx);
+          if (final) {
+            done.value = true;
+          } else {
+            recordDeparture(currentKey);
+            const idx = activeIndex.value;
+            const target = list[idx + 1];
+            if (target !== void 0) moveTo(target.key);
+          }
+        } else {
+          if (onError !== void 0) await onError(errors);
+          if (options.focusFirstError !== false) {
+            const firstFailedKey = errors[0]?.formKey;
+            if (firstFailedKey !== void 0 && isCompiledKey(firstFailedKey)) {
+              moveTo(firstFailedKey);
+              await nextTick();
+              const failedForm = formsRecord.value[firstFailedKey];
+              if (failedForm !== void 0 && typeof failedForm.applyInvalidSubmitPolicy === "function") {
+                failedForm.applyInvalidSubmitPolicy();
+              }
+            }
+          }
+        }
+      } finally {
+        submitting.value = false;
+      }
+    };
+  }
+  function reset() {
+    submissionAttempts.value = 0;
+    done.value = false;
+    lazyEpoch.value += 1;
+    for (const step of compiledSteps.value) {
+      const full = step.form;
+      if (typeof full.reset === "function") full.reset();
+    }
+    const firstStep = compiledSteps.value[0];
+    if (firstStep !== void 0) {
+      activeKey.value = firstStep.key;
+      visited.value = [firstStep.key];
+      if (persistCallback !== void 0) {
+        lastPersisted = firstStep.key;
+        persistCallback({ step: firstStep.key });
+      }
+    }
+  }
+  if (getCurrentScope() !== void 0) {
+    onScopeDispose(() => {
+      historyHandle.dispose();
+      lazyNoopScope.stop();
+    });
+  }
+  const explicitKey = options.key;
+  const wizardKey = resolveWizardKey(explicitKey);
+  const handle = {
+    key: wizardKey,
+    next,
+    back,
+    goTo,
+    handleSubmit,
+    reset,
+    get currentStep() {
+      return currentStep.value;
+    },
+    get activeForm() {
+      return activeForm.value;
+    },
+    get activeIndex() {
+      return activeIndex.value;
+    },
+    get isFinalStep() {
+      return isFinalStep.value;
+    },
+    get steps() {
+      return compiledSteps.value;
+    },
+    get forms() {
+      return formsRecord.value;
+    },
+    get count() {
+      return count.value;
+    },
+    statuses,
+    get allValues() {
+      return allValues.value;
+    },
+    get allErrors() {
+      return allErrors.value;
+    },
+    get progress() {
+      return progress.value;
+    },
+    get canAdvance() {
+      return canAdvance.value;
+    },
+    get canGoBack() {
+      return canGoBack.value;
+    },
+    get complete() {
+      return complete.value;
+    },
+    get done() {
+      return done.value;
+    },
+    get submitting() {
+      return submitting.value;
+    },
+    get submissionAttempts() {
+      return submissionAttempts.value;
+    },
+    get visited() {
+      return visited.value;
+    }
+  };
+  const existing = registry.wizards.get(wizardKey);
+  if (existing === void 0) {
+    registry.wizards.set(wizardKey, handle);
+  } else if (__DEV__ && explicitKey !== void 0) {
+    console.warn(
+      `[attaform] useWizard({ key: "${wizardKey}" }): a wizard with this key is already registered. Keeping the existing handle. Pass a unique key to each useWizard call, or share the original handle via injectWizard("${wizardKey}").`
+    );
+  }
+  if (getCurrentScope() !== void 0) {
+    const releaseWizard = registry.trackWizardConsumer(wizardKey);
+    onScopeDispose(releaseWizard);
+  }
+  if (getCurrentInstance() !== null && explicitKey === void 0) {
+    recordAmbientWizardProvide(registry.ssr);
+    provide(kAttaformAncestorWizard, handle);
+  }
+  return handle;
+}
+let anonWizardCounter = 0;
+const ambientWizardProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientWizardProvide(ssr) {
+  if (!__DEV__ || ssr || ambientWizardProvideHistory === null) return;
+  const instance = getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: captureUserCallSite()
+  };
+  const existing = ambientWizardProvideHistory.get(instanceKey);
+  if (existing === void 0) {
+    ambientWizardProvideHistory.set(instanceKey, [entry]);
+    return;
+  }
+  existing.push(entry);
+}
+function resolveWizardKey(key) {
+  if (key !== void 0 && key !== null && key !== "") return key;
+  if (getCurrentInstance() !== null) {
+    return `${ANONYMOUS_WIZARD_KEY_PREFIX}${useId()}`;
+  }
+  return `${ANONYMOUS_WIZARD_KEY_PREFIX}${anonWizardCounter++}`;
+}
+function isAnyForm(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (typeof value.key !== "string") return false;
+  return true;
+}
+
+function injectWizard(input) {
+  const key = typeof input === "string" ? input : input?.key;
+  const instance = getCurrentInstance();
+  if (instance !== null) ensureAttaformInstalled(instance.appContext.app);
+  const registry = useRegistry();
+  if (key !== void 0) {
+    const handle = registry.wizards.get(key);
+    if (handle === void 0) {
+      warnMiss(
+        `no wizard registered for key '${key}'`,
+        registry.ssr,
+        availableKeysHint(registry.wizards)
+      );
+      return null;
+    }
+    if (getCurrentScope() !== void 0) {
+      const release = registry.trackWizardConsumer(key);
+      onScopeDispose(release);
+    }
+    return handle;
+  }
+  const ambient = inject(kAttaformAncestorWizard, null);
+  if (ambient === null) return null;
+  warnIfAmbientWizardProviderHadDuplicates();
+  return ambient;
+}
+function availableKeysHint(wizards) {
+  if (wizards.size === 0) return void 0;
+  const keys = [...wizards.keys()].map((k) => `"${k}"`).join(", ");
+  return `Registered keys: ${keys}.`;
+}
+function warnMiss(detail, ssr, hint) {
+  if (!__DEV__ || ssr) return;
+  const frame = captureUserCallSite();
+  const parts = [`[attaform] injectWizard: ${detail}. Returning null.`];
+  if (hint !== void 0) parts.push(hint);
+  if (frame !== void 0) parts.push(frame);
+  console.warn(parts.join(" "));
+}
+function warnIfAmbientWizardProviderHadDuplicates() {
+  if (!__DEV__ || ambientWizardProvideHistory === null) return;
+  let ancestor = getCurrentInstance()?.parent ?? null;
+  while (ancestor !== null) {
+    const history = ambientWizardProvideHistory.get(ancestor);
+    if (history !== void 0) {
+      if (history.length > 1) {
+        const lines = history.map((entry) => `  - ${entry.source ?? "<unknown location>"}`);
+        console.warn(
+          "[attaform] injectWizard() (no key) resolved against an ancestor with multiple anonymous useWizard() calls; descendants only see the last-provided wizard. Anonymous useWizard() calls were:\n" + lines.join("\n") + '\nFix: pass a key to each call (e.g. useWizard({ steps, key: "x" })) and reach them via injectWizard("x"), or split the wizards across separate components.'
+        );
+      }
+      return;
+    }
+    ancestor = ancestor.parent;
+  }
+}
+
+export { AttaformErrorCode as A, injectWizard as a, isUnset as b, useWizard as c, defaultCoercionRules as d, defaultShouldShowErrors as e, defineCoercion as f, useAbstractForm as g, getAtPath as h, injectForm as i, humanize as j, setAtPath as k, lazy as l, isPlainRecord as m, normalizeNumericOption as n, slimKindOf as s, unset as u };
+//# sourceMappingURL=attaform.DsC3rZHG.mjs.map