attaform 0.17.1 → 0.18.0

package/dist/shared/{attaform.Cer8JO_P.cjs → attaform.II89Pcf4.cjs}

@@ -1,8 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const plugin = require('./attaform.Dee2rU1P.cjs');
-const paths = require('./attaform.BBM2muQ9.cjs');
+const paths = require('./attaform.BqK_L4gK.cjs');
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -123,7 +122,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);
@@ -163,7 +167,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);
@@ -175,10 +179,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;
       }
@@ -506,7 +512,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,
@@ -648,10 +654,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);
@@ -661,7 +669,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) {
@@ -676,7 +684,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)) {
@@ -689,11 +704,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,
@@ -784,22 +826,47 @@ function buildErrorsProxy(state) {
   return buildSurfaceProxy({
     schema: state.schema,
     resolveLeaf: (path) => {
-      const { key } = paths.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 = paths.canonicalizePath(containerPath).key;
+        const literalKey = paths.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 } = paths.canonicalizePath(path);
+      const isFormLevel = key === paths.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
@@ -809,12 +876,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) ? [] : {};
@@ -823,12 +909,33 @@ function materializeErrors(state, containerSegments) {
       if (errors.length === 0) continue;
       const fullPath = paths.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);
@@ -1016,9 +1123,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);
@@ -1050,12 +1174,13 @@ const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
 const PERSISTENCE_KEY_PREFIX = "attaform:";
 const RESERVED_KEY_PREFIX = "__atta:";
 const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
 const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
   const { value, source, allowInfinity, min, defaultValue } = config;
   if (allowInfinity && value === Infinity) return Infinity;
   if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
-    if (plugin.__DEV__) {
+    if (paths.__DEV__) {
       const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
       console.warn(
         `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
@@ -1084,7 +1209,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;
@@ -1096,7 +1221,7 @@ function readPersistedPayload(value) {
   if (envelope.data === void 0 || typeof envelope.data !== "object") return null;
   return envelope;
 }
-const warnedVersions = plugin.__DEV__ ? /* @__PURE__ */ new Set() : null;
+const warnedVersions = paths.__DEV__ ? /* @__PURE__ */ new Set() : null;
 function warnVersionMismatch(observedVersion) {
   if (warnedVersions === null) return;
   if (warnedVersions.has(observedVersion)) return;
@@ -1106,7 +1231,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 = paths.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 {
@@ -1274,13 +1407,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 = plugin.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+const warnedNoScopeStores = paths.__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 = vue.ref({
       pending: true,
@@ -1330,7 +1490,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
     });
     if (vue.getCurrentScope() !== void 0) {
       vue.onScopeDispose(stop);
-    } else if (plugin.__DEV__ && warnedNoScopeStores !== null && !warnedNoScopeStores.has(state)) {
+    } else if (paths.__DEV__ && warnedNoScopeStores !== null && !warnedNoScopeStores.has(state)) {
       warnedNoScopeStores.add(state);
       console.warn(
         "[attaform] validate() called outside a Vue effect scope; its reactive watcher will leak until the form is garbage-collected. Fix: call validate() inside setup() / a child component, or wrap the call in `effectScope().run(...)`."
@@ -1343,7 +1503,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);
@@ -1431,7 +1599,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
             try {
               await onError(merged.errors);
             } catch (cause) {
-              throw new plugin.SubmitErrorHandlerError("User-provided onError threw", { cause });
+              throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
             }
           }
           return;
@@ -1440,6 +1608,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) {
@@ -1453,7 +1624,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;
         }
       }
     };
@@ -1528,7 +1699,7 @@ function extractSchemaFields(schema) {
   return [];
 }
 
-const warnedRejections = plugin.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const warnedRejections = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function shouldWarnOnce$1(store, key) {
   if (warnedRejections === null) return false;
   let set = warnedRejections.get(store);
@@ -1547,6 +1718,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":
@@ -1577,6 +1749,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)) {
@@ -1600,7 +1773,7 @@ function walk$1(schema, store, path, value) {
   return true;
 }
 function reportRejection(store, path, kind, accepted) {
-  if (!plugin.__DEV__) return;
+  if (!paths.__DEV__) return;
   const dotted = path.map((s) => String(s)).join(".") || "(root)";
   const key = `${dotted}::${kind}`;
   if (!shouldWarnOnce$1(store, key)) return;
@@ -1674,13 +1847,13 @@ function indexRules(rules) {
   for (const entry of rules) {
     const candidate = entry;
     if (candidate === null || typeof candidate !== "object" || typeof candidate.transform !== "function") {
-      if (plugin.__DEV__) {
+      if (paths.__DEV__) {
         console.warn("[attaform] coercion entry missing or invalid `transform` \u2014 skipped.");
       }
       continue;
     }
     const key = `${entry.input}->${entry.output}`;
-    if (idx.has(key) && plugin.__DEV__) {
+    if (idx.has(key) && paths.__DEV__) {
       console.warn(`[attaform] duplicate coercion rule for '${key}' \u2014 last entry wins.`);
     }
     idx.set(key, entry);
@@ -1709,7 +1882,7 @@ function pickScalarTarget(accepted) {
   if (accepted.has("bigint")) return "bigint";
   return null;
 }
-const warnedCoerce = plugin.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const warnedCoerce = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 const sharedWarnStore = {};
 function shouldWarnOnce(key) {
   if (warnedCoerce === null) return false;
@@ -1734,7 +1907,7 @@ function coerceScalar(value, accepted, index) {
   try {
     result = entry.transform(value);
   } catch (err) {
-    if (plugin.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
+    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' threw \u2014 write passes through.`,
         err
@@ -1745,7 +1918,7 @@ function coerceScalar(value, accepted, index) {
   if (!result.coerced) return value;
   const returnedKind = slimKindOf(result.value);
   if (returnedKind !== entry.output) {
-    if (plugin.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
+    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' produced a ${returnedKind} \u2014 write passes through.`
       );
@@ -1753,7 +1926,7 @@ function coerceScalar(value, accepted, index) {
     return value;
   }
   if (entry.output === "number" && !Number.isFinite(result.value)) {
-    if (plugin.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
+    if (paths.__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
       console.warn(
         `[attaform] coercion '${entry.input}->${entry.output}' produced a non-finite number \u2014 write passes through.`
       );
@@ -1806,6 +1979,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;
@@ -1842,6 +2020,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;
@@ -1863,10 +2044,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       coerceIndex
     );
     if (persist && !state.ssr && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
-      throw new plugin.AnonPersistError({
+      throw new paths.AnonPersistError({
         cause: "register-without-config",
         schemaFields: extractSchemaFields(state.schema),
-        callSite: plugin.captureUserCallSite()
+        callSite: paths.captureUserCallSite()
       });
     }
     const internalRv = {
@@ -1925,7 +2106,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       ...unmarkNoSync !== void 0 ? { unmarkNoSync } : {},
       transforms,
       coerce,
-      ...coerceElement !== void 0 ? { coerceElement } : {}
+      ...coerceElement !== void 0 ? { coerceElement } : {},
+      acceptsUndefined,
+      acceptsString
     };
     return vue.shallowReadonly(internalRv);
   };
@@ -1946,19 +2129,13 @@ function walkUnsetSentinels(values, schema) {
   const cleaned = walk(values, [], schema, paths);
   return { cleanedValues: cleaned, paths };
 }
-function walk(input, segments, schema, paths$1) {
+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$1);
-    }
-    paths$1.push(paths.canonicalizePath(segments).key);
-    return slim;
+    return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
     const slim = schema.getDefaultAtPath(segments);
-    return walkUnspecified(slim, segments, paths$1);
+    return walkUnspecified(slim, segments, paths);
   }
   if (input === null) return null;
   if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
@@ -1968,7 +2145,7 @@ function walk(input, segments, schema, paths$1) {
     const out = new Array(input.length);
     let mutated = false;
     for (let i = 0; i < input.length; i++) {
-      const walked = walk(input[i], [...segments, i], schema, paths$1);
+      const walked = walk(input[i], [...segments, i], schema, paths);
       out[i] = walked;
       if (walked !== input[i]) mutated = true;
     }
@@ -1977,6 +2154,7 @@ function walk(input, segments, schema, paths$1) {
   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);
@@ -1985,7 +2163,12 @@ function walk(input, segments, schema, paths$1) {
     let mutated = allKeys.size !== inputKeys.length;
     for (const key of allKeys) {
       const orig = input[key];
-      const walked = walk(orig, [...segments, key], schema, paths$1);
+      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;
     }
@@ -1995,7 +2178,7 @@ function walk(input, segments, schema, paths$1) {
 }
 function walkUnspecified(slim, segments, paths$1) {
   if (isPrimitiveOrEmpty(slim)) {
-    if (isNumericPrimitive(slim)) {
+    if (isSlimNumericPrimitive(slim)) {
       paths$1.push(paths.canonicalizePath(segments).key);
     }
     return slim;
@@ -2018,15 +2201,9 @@ function substituteUnsetSentinels(value, prefix, schema) {
   const cleaned = substitute(value, [...prefix], schema, paths);
   return { cleanedValues: cleaned, paths };
 }
-function substitute(input, segments, schema, paths$1) {
+function substitute(input, segments, schema, paths) {
   if (isUnset(input)) {
-    const slim = schema.getDefaultAtPath(segments);
-    if (!isPrimitiveOrEmpty(slim)) {
-      warnNonPrimitiveLeaf(segments, slim);
-      return slim;
-    }
-    paths$1.push(paths.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") {
@@ -2036,7 +2213,7 @@ function substitute(input, segments, schema, paths$1) {
     let mutated = false;
     const out = new Array(input.length);
     for (let i = 0; i < input.length; i++) {
-      const walked = substitute(input[i], [...segments, i], schema, paths$1);
+      const walked = substitute(input[i], [...segments, i], schema, paths);
       out[i] = walked;
       if (walked !== input[i]) mutated = true;
     }
@@ -2047,7 +2224,7 @@ function substitute(input, segments, schema, paths$1) {
     const out = {};
     for (const key of Object.keys(input)) {
       const orig = input[key];
-      const walked = substitute(orig, [...segments, key], schema, paths$1);
+      const walked = substitute(orig, [...segments, key], schema, paths);
       out[key] = walked;
       if (walked !== orig) mutated = true;
     }
@@ -2060,20 +2237,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 = plugin.__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$1) {
+  const du = schema.getUnionDiscriminatorAtPath(segments);
+  if (du !== void 0) {
+    const discPath = [...segments, du.discriminatorKey];
+    const discSlim = schema.getEmptyValueAtPath(discPath);
+    paths$1.push(paths.canonicalizePath(discPath).key);
+    return { [du.discriminatorKey]: blankForKind(discSlim) };
+  }
+  const slim = schema.getEmptyValueAtPath(segments);
+  if (isPrimitiveOrEmpty(slim)) {
+    paths$1.push(paths.canonicalizePath(segments).key);
+    return slim;
+  }
+  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+    paths$1.push(paths.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$1);
+  }
+  return result;
 }
 
 function buildValuesProxy(form) {
@@ -2124,7 +2321,7 @@ function buildValuesProxy(form) {
     // TypeError in strict-mode consumers, surprising users who
     // assigned through the proxy and expected it to be ignored.
     set(_, key) {
-      if (plugin.__DEV__) {
+      if (paths.__DEV__) {
         console.warn(
           `[attaform] form.values is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
         );
@@ -2132,7 +2329,7 @@ function buildValuesProxy(form) {
       return true;
     },
     deleteProperty(_, key) {
-      if (plugin.__DEV__) {
+      if (paths.__DEV__) {
         console.warn(
           `[attaform] form.values is read-only \u2014 delete of "${String(key)}" was ignored.`
         );
@@ -2143,28 +2340,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 = {};
@@ -2187,6 +2362,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,
@@ -2207,49 +2383,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 = paths.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 = paths.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 = paths.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 = paths.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;
     }
@@ -2265,7 +2445,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       if (blankSegments === null) continue;
       state.setValueAtPath(
         blankSegments,
-        state.schema.getDefaultAtPath(blankSegments),
+        state.getValueAtPath(blankSegments),
         withInstanceMeta({ blank: true })
       );
     }
@@ -2279,7 +2459,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       if (e.formKey === state.formKey) own.push(e);
       else dropped++;
     }
-    if (plugin.__DEV__ && dropped > 0) {
+    if (paths.__DEV__ && dropped > 0) {
       console.warn(
         `[attaform] ${op}: dropped ${dropped} error(s) with non-matching formKey (this form's key is "${String(state.formKey)}"). Errors are scoped to the form that produced them \u2014 pass them to the matching form instance.`
       );
@@ -2329,8 +2509,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     state.userErrors.delete(paths.FORM_ERRORS_PATH_KEY);
   }
   const submitting = vue.computed(() => state.submitting.value);
-  const submitCount = vue.computed(() => state.submitCount.value);
+  const submissionAttempts = vue.computed(() => state.submissionAttempts.value);
+  const submitted = vue.computed(() => state.submitted.value);
   const submitError = vue.computed(() => state.submitError.value);
+  const departAttempts = vue.computed(() => state.departAttempts.value);
   const validating = vue.computed(() => state.activeValidations.value > 0);
   const valid = vue.computed(
     () => state.firstValidationDone.value && state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
@@ -2355,8 +2537,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
     };
   };
@@ -2416,8 +2601,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
       meta: vue.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: vue.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
@@ -2437,13 +2628,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       state.reset(walked.cleanedValues);
       for (const pathKey of walked.paths) {
-        const segments = paths.segmentsForPathKey(pathKey);
-        if (segments === null) continue;
-        state.setValueAtPath(
-          segments,
-          state.schema.getDefaultAtPath(segments),
-          withInstanceMeta({ blank: true })
-        );
+        state.blankPaths.add(pathKey);
         state.originalBlankPaths.add(pathKey);
       }
     }
@@ -2464,7 +2649,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const persist = async (pathInput, options2) => {
     const segments = paths.canonicalizePath(pathInput).segments;
-    plugin.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
+    paths.enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true, state.isSensitivePath);
     if (persistence === void 0) return;
     await persistence.writePathImmediately(segments);
   };
@@ -2493,56 +2678,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 = vue.computed(() => {
-    return readonlySetSnapshot(state.blankPaths);
+    const keys = /* @__PURE__ */ new Set();
+    const paths$1 = [];
+    for (const pk of state.blankPaths) {
+      keys.add(pk);
+      const segs = paths.segmentsForPathKey(pk);
+      if (segs !== null) paths$1.push(segs);
+    }
+    Object.freeze(paths$1);
+    const view = {
+      get size() {
+        return keys.size;
+      },
+      has(input) {
+        const { key } = paths.canonicalizePath(input);
+        return keys.has(key);
+      },
+      values() {
+        return paths$1;
+      },
+      [Symbol.iterator]() {
+        return paths$1[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) {
@@ -2555,7 +2825,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;
@@ -2570,7 +2840,7 @@ function isHydratedValidationErrorArray(value) {
   return true;
 }
 function warnMalformedHydration(formKey, kind, rawKey) {
-  if (!plugin.__DEV__) return;
+  if (!paths.__DEV__) return;
   console.warn(
     `[attaform] hydration: skipping malformed ${kind} entry at key '${rawKey}' on form '${formKey}'. This usually means the SSR bundle is on a different version than the client (rolling deploy / stale cache).`
   );
@@ -2592,7 +2862,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 && plugin.__DEV__) {
+      const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
+      if (!isKindBlank && warned !== void 0 && paths.__DEV__) {
         const dotted = path.map((s) => String(s)).join(".") || "(root)";
         const key = `${dotted}::${String(discValue)}`;
         if (!warned.has(key)) {
@@ -2671,9 +2942,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(paths.canonicalizePath(prefix).key);
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) {
+      walkAuthoredFromConstraints(value[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      walkAuthoredFromConstraints(value[i], [...prefix, i], out);
+    }
+  }
+}
+function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
+  if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
+    const left = withDefaults;
+    const right = withoutDefaults;
+    const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const k of keys) {
+      walkAuthoredFromSchemaDiff(left[k], right[k], [...prefix, k], out);
+    }
+    return;
+  }
+  if (Array.isArray(withDefaults) && Array.isArray(withoutDefaults)) {
+    const len = Math.max(withDefaults.length, withoutDefaults.length);
+    for (let i = 0; i < len; i++) {
+      walkAuthoredFromSchemaDiff(withDefaults[i], withoutDefaults[i], [...prefix, i], out);
+    }
+    return;
+  }
+  if (!Object.is(withDefaults, withoutDefaults) && prefix.length > 0) {
+    out.add(paths.canonicalizePath(prefix).key);
+  }
+}
 function createFormStore(options) {
   const { formKey, schema, defaultValues, strict = true, hydration } = options;
   const ssr = options.ssr === true;
+  const ssrPrefetch = options.ssrPrefetch;
   const rememberVariants = options.rememberVariants !== false;
   const fieldValidationMode = options.validateOn ?? "change";
   const fieldValidationDebounceMs = normalizeNumericOption({
@@ -2687,7 +2994,7 @@ function createFormStore(options) {
   const formChangeListeners = /* @__PURE__ */ new Set();
   const submitSuccessListeners = /* @__PURE__ */ new Set();
   const resetListeners = /* @__PURE__ */ new Set();
-  const persistOptIns = plugin.createPersistOptInRegistry();
+  const persistOptIns = paths.createPersistOptInRegistry();
   const noSyncPaths = /* @__PURE__ */ new Set();
   const noSyncPathCounts = /* @__PURE__ */ new Map();
   function incrementNoSyncOptOut(path) {
@@ -2708,8 +3015,8 @@ function createFormStore(options) {
   const resolvedShouldShowErrors = resolveShouldShowErrors(
     options.shouldShowErrors
   );
-  const resolvedIsSensitivePath = options.isSensitivePath ?? plugin.isSensitivePath;
-  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? plugin.segmentMatchesSensitive;
+  const resolvedIsSensitivePath = options.isSensitivePath ?? paths.isSensitivePath;
+  const resolvedSegmentMatchesSensitive = options.segmentMatchesSensitive ?? paths.segmentMatchesSensitive;
   const cleanupHooks = [];
   const modules = /* @__PURE__ */ new Map();
   const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
@@ -2719,6 +3026,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(paths.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
@@ -2735,8 +3065,9 @@ function createFormStore(options) {
   const blankPaths = vue.reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
   for (const raw of initialTransientList) {
-    blankPaths.add(raw);
-    originalBlankPaths.add(raw);
+    const key = paths.coerceToPathKey(raw);
+    blankPaths.add(key);
+    originalBlankPaths.add(key);
   }
   const variantMemory = /* @__PURE__ */ new Map();
   function clearVariantMemoryUnderPath(arrayPath) {
@@ -2804,10 +3135,18 @@ function createFormStore(options) {
   });
   const submitting = vue.ref(false);
   const activeSubmissions = vue.ref(0);
-  const submitCount = vue.ref(0);
+  const submissionAttempts = vue.ref(0);
+  const submitted = vue.ref(false);
   const submitError = vue.ref(null);
+  const departAttempts = vue.ref(0);
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
+  const hydrating = vue.ref(false);
+  const hydrateError = vue.ref(null);
+  const defaultValuesFactory = vue.ref(void 0);
+  const defaultsResolved = vue.ref(false);
+  const activated = vue.ref(false);
+  const activationPromise = vue.ref(void 0);
   const firstValidationDone = vue.ref(!strict || schema.needsAsyncValidation?.() !== true);
   vue.watch(activeValidations, (now, prev) => {
     if (prev > 0 && now === 0) {
@@ -2872,7 +3211,7 @@ function createFormStore(options) {
         connected: false,
         focused: null,
         blurred: null,
-        touched: null
+        touched: false
       });
     });
     if (strict && !schemaResponse.success) {
@@ -2892,9 +3231,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) {
@@ -2925,7 +3271,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;
     }
@@ -3024,9 +3369,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);
@@ -3139,12 +3496,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;
@@ -3156,17 +3512,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) {
@@ -3176,8 +3531,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();
@@ -3346,7 +3706,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) {
@@ -3361,7 +3726,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;
   }
@@ -3370,7 +3735,11 @@ function createFormStore(options) {
     const { key } = paths.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 } = paths.canonicalizePath(path);
@@ -3379,7 +3748,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") {
@@ -3405,7 +3774,7 @@ function createFormStore(options) {
       if (current?.touched === true) continue;
       touchFieldRecord(leafKey, entry.segments, { touched: true });
     }
-    if (!touchedAny && plugin.__DEV__) {
+    if (!touchedAny && paths.__DEV__) {
       console.warn(
         `[attaform] form.touch(): no fields resolved at path ${JSON.stringify(segments)}. Check the path matches an existing field or container.`
       );
@@ -3414,6 +3783,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(
+        vue.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(paths.FORM_ERRORS_PATH_KEY);
+    if (existing === void 0) return;
+    const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
+    if (filtered.length === 0) {
+      schemaErrors.delete(paths.FORM_ERRORS_PATH_KEY);
+    } else {
+      schemaErrors.set(paths.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: [...paths.FORM_ERRORS_PATH],
+      formKey,
+      code: AttaformErrorCode.HydrationFailed
+    };
+    const existing = schemaErrors.get(paths.FORM_ERRORS_PATH_KEY) ?? [];
+    schemaErrors.set(paths.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);
@@ -3423,6 +3870,7 @@ function createFormStore(options) {
       strict
     });
     const next = resetResponse.data;
+    rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -3465,16 +3913,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) {
@@ -3547,9 +3997,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) {
@@ -3612,8 +4062,18 @@ function createFormStore(options) {
     shouldShowErrors: resolvedShouldShowErrors,
     submitting,
     activeSubmissions,
-    submitCount,
+    submissionAttempts,
+    submitted,
     submitError,
+    departAttempts,
+    hydrating,
+    hydrateError,
+    defaultValuesFactory,
+    defaultsResolved,
+    activated,
+    activationPromise,
+    rehydrate,
+    activate,
     submissionGeneration,
     activeValidations,
     firstValidationDone,
@@ -3628,6 +4088,7 @@ function createFormStore(options) {
     setSchemaErrorsForPath,
     setAllSchemaErrors,
     clearSchemaErrors,
+    applySchemaErrorsForSubtree,
     setAllUserErrors,
     addUserErrors,
     clearUserErrors,
@@ -3873,6 +4334,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";
 }
@@ -3882,6 +4348,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 = [];
@@ -3894,6 +4386,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));
@@ -3998,6 +4491,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);
@@ -4037,6 +4531,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 = [];
@@ -4071,11 +4568,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;
@@ -4194,7 +4687,7 @@ const MULTI_TAB_SYNC_MODULE_KEY = "multiTabSync";
 
 const warned = /* @__PURE__ */ new Set();
 function warnOnceInsecureContext(feature) {
-  if (!plugin.__DEV__) return;
+  if (!paths.__DEV__) return;
   if (warned.has(feature)) return;
   warned.add(feature);
   const message = featureMessage(feature);
@@ -4214,15 +4707,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 plugin.InvalidUseFormConfigError();
+    throw new paths.InvalidUseFormConfigError();
   }
   const key = resolveFormKey(configuration.key);
   const instance = vue.getCurrentInstance();
-  if (instance !== null) plugin.ensureAttaformInstalled(instance.appContext.app);
-  const registry = plugin.useRegistry();
-  const merged = mergeWithDefaults(registry.defaults, configuration);
+  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
+  const registry = options?.registry ?? paths.useRegistry();
+  const resolvedDefaults = resolveTrichotomy(configuration.defaultValues);
+  const materialisedDefaults = resolvedDefaults.kind === "sync" ? resolvedDefaults.value : void 0;
+  const { defaultValues: _droppedDefaults, ...configWithoutDefaults } = configuration;
+  const trichotomyOverride = materialisedDefaults === void 0 ? configWithoutDefaults : { ...configWithoutDefaults, defaultValues: materialisedDefaults };
+  const merged = mergeWithDefaults(registry.defaults, trichotomyOverride);
   const maxRecursionDepth = normalizeNumericOption({
     value: merged.maxRecursionDepth ?? DEFAULT_MAX_RECURSION_DEPTH,
     source: "useForm.maxRecursionDepth",
@@ -4232,18 +4736,38 @@ function useAbstractForm(configuration) {
   });
   const resolvedSchema = getComputedSchema(key, configuration.schema, { maxRecursionDepth });
   if (configuration.persist !== void 0 && configuration.key === void 0) {
-    throw new plugin.AnonPersistError({
+    throw new paths.AnonPersistError({
       cause: "no-key",
       schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: plugin.captureUserCallSite()
+      callSite: paths.captureUserCallSite()
     });
   }
   const existing = registry.forms.get(key);
-  if (plugin.__DEV__ && existing !== void 0) {
+  if (paths.__DEV__ && existing !== void 0) {
     warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
     warnOnPersistDivergence(key, existing, configuration.persist);
   }
+  const hadPendingHydration = registry.pendingHydration.has(key);
   const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  if (existing !== void 0) ; else if (resolvedDefaults.kind === "sync") {
+    state.defaultsResolved.value = true;
+  }
+  if (existing === void 0 && resolvedDefaults.kind === "async") {
+    const factory = resolvedDefaults.factory;
+    state.defaultValuesFactory.value = factory;
+    if (hadPendingHydration) {
+      state.hydrating.value = false;
+      state.defaultsResolved.value = true;
+    } else if (registry.ssr) {
+      if (configuration.__ssrAccessed === true) {
+        registry.enqueuePrefetch(key);
+      }
+      vue.onServerPrefetch(() => {
+        if (!registry.shouldPrefetch(key)) return;
+        return state.activate();
+      });
+    }
+  }
   if (vue.getCurrentScope() !== void 0) {
     const releaseConsumer = registry.trackConsumer(key);
     vue.onScopeDispose(releaseConsumer);
@@ -4271,7 +4795,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) {
@@ -4307,11 +4831,11 @@ function useAbstractForm(configuration) {
   }
   if (configuration.key === void 0) {
     recordAmbientProvide(registry.ssr);
-    vue.provide(plugin.kFormContext, state);
+    vue.provide(paths.kFormContext, state);
   }
   const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
   if (vue.getCurrentInstance() !== null) {
-    vue.provide(plugin.kFormInstanceId, formInstanceId);
+    vue.provide(paths.kFormInstanceId, formInstanceId);
   }
   const apiOptions = {};
   if (merged.onInvalidSubmit !== void 0) {
@@ -4378,10 +4902,13 @@ 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 : plugin.createIsSensitivePath(resolvedSensitiveNames);
-  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : plugin.createSegmentMatchesSensitive(resolvedSensitiveNames);
+  const resolvedIsSensitivePath = resolvedSensitiveNames === void 0 ? void 0 : paths.createIsSensitivePath(resolvedSensitiveNames);
+  const resolvedSegmentMatchesSensitive = resolvedSensitiveNames === void 0 ? void 0 : paths.createSegmentMatchesSensitive(resolvedSensitiveNames);
   const createOptions = {
     formKey: key,
     schema,
@@ -4391,6 +4918,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 } : {},
@@ -4407,14 +4949,14 @@ function buildFreshState(key, schema, configuration, registry) {
 }
 let anonCounter = 0;
 let formInstanceCounter = 0;
-const ambientProvideHistory = plugin.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const ambientProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
 function recordAmbientProvide(ssr) {
-  if (!plugin.__DEV__ || ssr || ambientProvideHistory === null) return;
+  if (!paths.__DEV__ || ssr || ambientProvideHistory === null) return;
   const instance = vue.getCurrentInstance();
   if (instance === null) return;
   const instanceKey = instance;
   const entry = {
-    source: plugin.captureUserCallSite()
+    source: paths.captureUserCallSite()
   };
   const existing = ambientProvideHistory.get(instanceKey);
   if (existing === void 0) {
@@ -4426,7 +4968,7 @@ function recordAmbientProvide(ssr) {
 function resolveFormKey(key) {
   if (key !== void 0 && key !== null && key !== "") {
     if (key.startsWith(RESERVED_KEY_PREFIX)) {
-      throw new plugin.ReservedFormKeyError(key);
+      throw new paths.ReservedFormKeyError(key);
     }
     return key;
   }
@@ -4571,8 +5113,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 = paths.coerceToPathKey(k);
+        state.blankPaths.add(key2);
+        state.originalBlankPaths.add(key2);
       }
       if (include === "form+errors") {
         if (payload.data.schemaErrors !== void 0) {
@@ -4711,10 +5254,10 @@ function isEmptyContainer(value) {
 const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
 function enforceAnonPersistRule(formKey, ssr) {
   if (!formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return false;
-  if (plugin.__DEV__)
-    throw new plugin.AnonPersistError({
+  if (paths.__DEV__)
+    throw new paths.AnonPersistError({
       cause: "no-key",
-      callSite: plugin.captureUserCallSite()
+      callSite: paths.captureUserCallSite()
     });
   if (!ssr && !warnedAnonPersistKeys.has(formKey)) {
     warnedAnonPersistKeys.add(formKey);
@@ -4753,22 +5296,28 @@ 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 = vue.getCurrentInstance();
-  if (instance !== null) plugin.ensureAttaformInstalled(instance.appContext.app);
-  const registry = plugin.useRegistry();
+  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
+  const registry = paths.useRegistry();
   const state = resolveState(key, registry);
   if (state === null) return null;
   if (vue.getCurrentScope() !== void 0) {
     const releaseConsumer = registry.trackConsumer(state.formKey);
     vue.onScopeDispose(releaseConsumer);
   }
+  if (registry.ssr && ssrAccessed) {
+    registry.enqueuePrefetch(state.formKey);
+    vue.onServerPrefetch(() => state.activate());
+  }
   const apiOptions = {};
   const history = state.modules.get("history");
   if (history !== void 0) {
     apiOptions.history = history;
   }
-  const ambientInstanceId = vue.getCurrentInstance() !== null ? vue.inject(plugin.kFormInstanceId, null) : null;
+  const ambientInstanceId = vue.getCurrentInstance() !== null ? vue.inject(paths.kFormInstanceId, null) : null;
   const formInstanceId = ambientInstanceId ?? (vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
   return buildFormApi(
     state,
@@ -4780,28 +5329,25 @@ 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 = vue.inject(plugin.kFormContext, null);
-  if (ambient === null) {
-    warnMiss("no ambient form context", registry.ssr);
-    return null;
-  }
+  const ambient = vue.inject(paths.kFormContext, null);
+  if (ambient === null) return null;
   warnIfAmbientProviderHadDuplicates();
   return ambient;
 }
-function warnMiss(detail, ssr) {
-  if (!plugin.__DEV__ || ssr) return;
-  const frame = plugin.captureUserCallSite();
+function warnMiss$1(detail, ssr) {
+  if (!paths.__DEV__ || ssr) return;
+  const frame = paths.captureUserCallSite();
   console.warn(
     `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
   );
 }
 function warnIfAmbientProviderHadDuplicates() {
-  if (!plugin.__DEV__ || ambientProvideHistory === null) return;
+  if (!paths.__DEV__ || ambientProvideHistory === null) return;
   let ancestor = vue.getCurrentInstance()?.parent ?? null;
   while (ancestor !== null) {
     const history = ambientProvideHistory.get(ancestor);
@@ -4818,6 +5364,1045 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
+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 = vue.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 (paths.__DEV__) {
+        console.warn(
+          `[attaform] wizard.statuses is read-only \u2014 write to "${String(key)}" was ignored. Statuses derive from each form's meta; mutate the underlying form instead.`
+        );
+      }
+      return true;
+    },
+    deleteProperty(_, key) {
+      if (paths.__DEV__) {
+        console.warn(
+          `[attaform] wizard.statuses is read-only \u2014 delete of "${String(key)}" was ignored.`
+        );
+      }
+      return true;
+    },
+    defineProperty: () => true
+  });
+}
+
+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 && paths.__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 = paths.useRegistry();
+  const noopForms = /* @__PURE__ */ new Map();
+  const lazyNoopScope = vue.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 (vue.getCurrentScope() !== void 0) {
+      const release = registry.trackConsumer(form.key);
+      vue.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 = vue.ref(0);
+  const lazyComputeds = /* @__PURE__ */ new Map();
+  const activeKey = vue.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 = vue.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,
+        vue.computed(() => {
+          void lazyEpoch.value;
+          return marker.resolve(lazyCtx);
+        })
+      );
+    }
+  }
+  const compiledSteps = vue.computed(() => {
+    const ctx = slotCtx.value;
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < rawSteps.length; i++) {
+      const slot = rawSteps[i];
+      const form = resolveSlot(slot, i, ctx);
+      if (form === void 0) continue;
+      if (seen.has(form.key)) {
+        if (paths.__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 = vue.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 = vue.computed(() => {
+    const key = activeKey.value;
+    if (key !== "") return key;
+    const first = compiledSteps.value[0];
+    return first === void 0 ? void 0 : first.key;
+  });
+  const activeForm = vue.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 = vue.computed(() => {
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    return list.length > 0 && idx === list.length - 1;
+  });
+  const count = vue.computed(() => compiledSteps.value.length);
+  const formsRecord = vue.computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) out[step.key] = step.form;
+    return out;
+  });
+  const allValues = vue.computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) {
+      const source = step.form;
+      out[step.key] = source.values;
+    }
+    return out;
+  });
+  const allErrors = vue.computed(() => {
+    const out = {};
+    for (const step of compiledSteps.value) {
+      const source = step.form;
+      const list = [];
+      const store = registry.forms.get(step.key);
+      const resolved = store?.defaultsResolved.value === true;
+      if (resolved) {
+        const errors = source.meta?.errors ?? [];
+        for (const err of errors) {
+          const entry = {
+            formKey: step.key,
+            path: err.path,
+            message: err.message
+          };
+          if (err.code !== void 0) entry.code = err.code;
+          list.push(entry);
+        }
+      }
+      out[step.key] = list;
+    }
+    return out;
+  });
+  const seedRef = vue.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 = vue.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 (paths.__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 = vue.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 = vue.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 = vue.computed(() => activeIndex.value < count.value - 1);
+  const canGoBack = vue.computed(() => activeIndex.value > 0);
+  const visited = vue.ref([]);
+  const wantsDefaultUrlSync = options.restore !== false || options.persist !== false;
+  const historyHandle = wantsDefaultUrlSync ? createWizardHistory(DEFAULT_STEP_PARAM) : NOOP_WIZARD_HISTORY;
+  const injectedResolver = vue.inject(paths.kAttaformWizardActiveStepResolver, null);
+  const urlMirror = vue.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 (paths.__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) {
+    vue.watch(
+      () => restoreCallback()?.step,
+      (step) => {
+        if (step === void 0) return;
+        if (!isCompiledKey(step)) {
+          if (paths.__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) {
+    vue.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 = vue.ref(false);
+  const submissionAttempts = vue.ref(0);
+  const done = vue.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 (paths.__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 (paths.__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 (paths.__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 (paths.__DEV__) {
+        console.warn(`[attaform] wizard.back(): blocked while a submit is in flight.`);
+      }
+      return;
+    }
+    if (compiledSteps.value.length === 0) {
+      if (paths.__DEV__) {
+        console.warn(`[attaform] wizard.back(): wizard has no compiled steps; no-op.`);
+      }
+      return;
+    }
+    const idx = activeIndex.value;
+    if (idx <= 0) {
+      if (paths.__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 (paths.__DEV__) {
+        console.warn(`[attaform] wizard.goTo(): blocked while a submit is in flight.`);
+      }
+      return;
+    }
+    if (!isCompiledKey(key)) {
+      if (paths.__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 (paths.__DEV__) {
+          console.warn(`[attaform] wizard.handleSubmit: wizard has no compiled steps; no-op.`);
+        }
+        return;
+      }
+      if (submitting.value) {
+        if (paths.__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 vue.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 (vue.getCurrentScope() !== void 0) {
+    vue.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 (paths.__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 (vue.getCurrentScope() !== void 0) {
+    const releaseWizard = registry.trackWizardConsumer(wizardKey);
+    vue.onScopeDispose(releaseWizard);
+  }
+  if (vue.getCurrentInstance() !== null && explicitKey === void 0) {
+    recordAmbientWizardProvide(registry.ssr);
+    vue.provide(paths.kAttaformAncestorWizard, handle);
+  }
+  return handle;
+}
+let anonWizardCounter = 0;
+const ambientWizardProvideHistory = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientWizardProvide(ssr) {
+  if (!paths.__DEV__ || ssr || ambientWizardProvideHistory === null) return;
+  const instance = vue.getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: paths.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 (vue.getCurrentInstance() !== null) {
+    return `${ANONYMOUS_WIZARD_KEY_PREFIX}${vue.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 = vue.getCurrentInstance();
+  if (instance !== null) paths.ensureAttaformInstalled(instance.appContext.app);
+  const registry = paths.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 (vue.getCurrentScope() !== void 0) {
+      const release = registry.trackWizardConsumer(key);
+      vue.onScopeDispose(release);
+    }
+    return handle;
+  }
+  const ambient = vue.inject(paths.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 (!paths.__DEV__ || ssr) return;
+  const frame = paths.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 (!paths.__DEV__ || ambientWizardProvideHistory === null) return;
+  let ancestor = vue.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;
+  }
+}
+
 exports.AttaformErrorCode = AttaformErrorCode;
 exports.defaultCoercionRules = defaultCoercionRules;
 exports.defaultShouldShowErrors = defaultShouldShowErrors;
@@ -4825,11 +6410,14 @@ exports.defineCoercion = defineCoercion;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
 exports.injectForm = injectForm;
+exports.injectWizard = injectWizard;
 exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
+exports.lazy = lazy;
 exports.normalizeNumericOption = normalizeNumericOption;
 exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
-//# sourceMappingURL=attaform.Cer8JO_P.cjs.map
+exports.useWizard = useWizard;
+//# sourceMappingURL=attaform.II89Pcf4.cjs.map