attaform 0.30.0 → 0.31.0

package/dist/shared/{attaform.DNJOWjQw.mjs → attaform.DNPJPOO7.mjs}

@@ -1,12 +1,12 @@
-import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.WiGdIqgx.mjs';
-import { c as armDomBinding } from './attaform.B3resMQ1.mjs';
+import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, onBeforeMount, onBeforeUpdate, onMounted, nextTick } from 'vue';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.C4shmwyJ.mjs';
+import { c as armDomBinding, r as recordInheritedModifiers, w as withInheritedModifiers } from './attaform.DxKQsqFZ.mjs';
 import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
-import { A as ANONYMOUS_FORM_KEY_PREFIX, i as isShadowedKey, d as safeOwnHas, a as safeOwnRead, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.BRDDQeHV.mjs';
+import { A as ANONYMOUS_FORM_KEY_PREFIX, i as isShadowedKey, d as safeOwnHas, a as safeOwnRead, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, c as callConsumerFn, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.8mfKZCwH.mjs';
 import { i as isPathPrefix, e as canonicalizePath, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, s as segmentsForPathKey, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform.CdZIEf7_.mjs';
 
 const AttaformErrorCode = {
-  /** A required field is in the blank set — user hasn't supplied a value. */
+  /** A required field is in the blank set: no value was supplied. */
   NoValueSupplied: "atta:no-value-supplied",
   /** The schema adapter's `validateAtPath` threw synchronously. */
   AdapterThrew: "atta:adapter-threw",
@@ -532,7 +532,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
   const pristine = state.isPristineAtPathByKey(key, segments);
-  const cell = state.errorCells.get(key);
+  const cell = state.errorCells().get(key);
   const schemaForKey = cell !== void 0 && cell.schema.length > 0 ? cell.schema : void 0;
   const blankForKey = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments)] : void 0;
   const userForKey = cell !== void 0 && cell.user.length > 0 ? cell.user : void 0;
@@ -566,9 +566,8 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     updatedAt: record?.updatedAt ?? null,
     errors,
     // A leaf has no descendants, so its own-bucket errors ARE its subtree
-    // errors. Reuse the same array reference: referential `ownErrors ===
-    // errors`, and no second read of the whole-form `derivedBlankErrors`
-    // map (preserves the P3 blank-reactivity optimization above).
+    // errors. Reuse the array reference, which makes `ownErrors === errors`
+    // and avoids a second read of the whole-form `derivedBlankErrors` map.
     ownErrors: errors,
     validating,
     valid,
@@ -748,19 +747,19 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       elements: EMPTY_ELEMENTS,
       updatedAt,
       errors,
-      // The container's OWN bucket only (this exact path), excluding every
-      // descendant that `errors` rolls up: a cross-field `.refine()` here,
-      // or `setErrors` pinned at this node. The same raw union the leaf
-      // builds from the three stores; the container already depends on all
-      // three via `aggregateErrorsAt`, so there's no new reactivity cost.
+      // The container's OWN bucket at this exact path, excluding every
+      // descendant `errors` rolls up: a cross-field `.refine()` here, or a
+      // `setErrors` pinned at this node. The same raw union the leaf builds
+      // from the three stores, and the container already depends on all three
+      // through `aggregateErrorsAt`, so it costs no new reactivity.
       ownErrors: state.getErrorsForPath(segments),
       validating,
       valid,
       transforming,
       busy: transforming || validating,
-      // A container surfaces its OWN transform failure (a transform registered
-      // on the container path, e.g. a file normalizer) but never rolls up a
-      // descendant leaf's failure — that stays a per-field channel.
+      // A container surfaces its OWN transform failure, from a transform
+      // registered on the container path such as a file normalizer, and never
+      // rolls up a descendant's: that stays a per-field channel.
       transformError: ownTransformError,
       path: segments,
       ...computeFieldIdentity(formInstanceId, state.formKey, key),
@@ -822,7 +821,7 @@ function aggregateErrorsAt(state, prefix, prefixKey) {
   const candidates = state.errorWindowAt(prefix, prefixKey);
   if (candidates.length === 0) return [];
   const formValue = state.form.value;
-  const cells = state.errorCells;
+  const cells = state.errorCells();
   const buckets = /* @__PURE__ */ new Map();
   for (const { key, segments } of candidates) {
     if (!isPathPrefix(prefix, segments)) continue;
@@ -1092,16 +1091,16 @@ function buildErrorsSurface(state, sweep) {
     // non-schema keys reachable while a genuinely-absent key stays out.
     hasOwn: (segments, key) => liveContainerHasKey(state, segments, key) || errorAwareContainerKeys(state, segments).includes(key),
     isArrayAt: (segments) => isArrayPath(state, segments),
-    // `errors()` / `errors([])` / `errors(path)` are all the subtree
-    // aggregate — the same helper `meta.errors` reads, so the surfaces
-    // never drift.
+    // `errors()`, `errors([])` and `errors(path)` are all the subtree
+    // aggregate, through the helper `meta.errors` reads, so they cannot
+    // drift.
     call: (path) => aggregateErrorsAt(state, path, keyForSegments(path).key),
     surface: "form.errors",
     sweep
   });
 }
 function collectErrorsAt(state, key, segments, active, into) {
-  const cell = state.errorCells.get(key);
+  const cell = state.errorCells().get(key);
   if (active) {
     if (cell !== void 0) into.push(...cell.schema);
     if (state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments)) {
@@ -1682,7 +1681,7 @@ function createArrayBookkeeping(deps) {
       ...record,
       path: segments
     }));
-    migrateMapSubtree(errorCells, arrayPath, remap, (cell, segments) => ({
+    migrateMapSubtree(errorCells(), arrayPath, remap, (cell, segments) => ({
       schema: NO_ERRORS,
       user: cell.user.map((error) => ({ ...error, path: [...segments] }))
     }));
@@ -1732,7 +1731,7 @@ function createArrayBookkeeping(deps) {
       migrateElementState(arrayPath, remap);
       for (const freshIndex of remap.fresh) seedFreshElement(arrayPath, freshIndex);
       const changed = changedIndices(remap);
-      evictSchemaVerdictsAtIndices(errorCells, arrayPath, changed);
+      evictSchemaVerdictsAtIndices(errorCells(), arrayPath, changed);
       abortValidationAtVacatedIndices(arrayPath, remap);
       variantMemory.dropAtIndices(arrayPath, changed);
       arrayIdentity.applyOp(arrayPath, remap);
@@ -2037,7 +2036,7 @@ function adapterThrowMessage(err) {
   return "Adapter validateAtPath threw a non-Error value";
 }
 function hasUserErrorEntries(state) {
-  for (const cell of state.errorCells.values()) {
+  for (const cell of state.errorCells().values()) {
     if (cell.user.length > 0) return true;
   }
   return false;
@@ -2257,6 +2256,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
     const isRequired = state.schema.isRequiredAtPath(segments);
     const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
     const markBlank = () => state.setValueAtPath(segments, slimDefault, withInstanceMeta({ blank: true }));
+    const commitFromHost = (value) => value === "" && !acceptsString || value === null && !slimTypes.has("null") || value === void 0 && !acceptsUndefined ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
     const internalRv = {
       innerRef,
       displayValue,
@@ -2273,7 +2273,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       },
       ensureDomBinding: (factory) => {
         var _a;
-        (_a = state.domBinding).value ?? (_a.value = factory(state));
+        return (_a = state.domBinding).value ?? (_a.value = factory(state));
       },
       registerElement: (element) => {
         const dom = state.domBinding.value;
@@ -2288,13 +2288,14 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       setValueWithInternalPath: (value, meta) => {
         return state.setValueAtPath(segments, value, withInstanceMeta(meta));
       },
-      setValueFromHost: (value) => {
+      commitFromHost,
+      setValueFromHost: (value, modifiers) => {
         state.markInteracted(segments);
-        const isBlankSignal = value === "" && !acceptsString || value === null && !slimTypes.has("null") || value === void 0 && !acceptsUndefined;
-        const accepted = isBlankSignal ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
+        const accepted = state.domBinding.value?.hostChannel.write(internalRv, value, modifiers) ?? commitFromHost(value);
         return accepted;
       },
-      // Called by the `vRegisterHint` compile-time transform's wrapping
+      setValueFromHostInput: (payload, modifiers) => state.domBinding.value?.hostChannel.writeInput(internalRv, payload, modifiers) ?? false,
+      // Called by the `vRegisterHintTransform` compile-time transform's wrapping
       // IIFE on every server-side render of `<element v-register="…">`.
       // Without it, every SSR'd FieldState serialises `connected: false`
       // (because Vue skips directive lifecycle during SSR) and the client
@@ -2323,12 +2324,12 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         }
         return false;
       },
-      // --- Async transform lifecycle (internal; the directive's
-      // deferred orchestrator is the only legitimate consumer). Thin
-      // path-bound delegates to the store's per-path token / counter
-      // machinery — same pattern as `markBlank` / `setValueWithInternalPath`,
-      // so the directive (which holds only this RegisterValue, never the
-      // store) can drive the busy/discard/error bookkeeping. ---
+      // --- Async transform lifecycle (internal; the directive's deferred
+      // orchestrator is the only legitimate consumer). Thin path-bound
+      // delegates to the store's per-path token and counter machinery,
+      // the same pattern as `markBlank` and `setValueWithInternalPath`, so
+      // the directive (which holds this RegisterValue and never the store)
+      // can drive the busy / discard / error bookkeeping. ---
       beginTransform: (holder) => state.beginTransform(pathKey, holder),
       isCurrentTransform: (token) => state.isCurrentTransform(pathKey, token),
       endTransform: (token) => state.endTransform(pathKey, token),
@@ -2341,10 +2342,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         return (state.fieldTransformCounts.get(pathKey) ?? 0) > 0;
       },
       path: pathKey,
-      // Frozen so a wrapper component can pass `rv.segments` directly
-      // to `form.fields(...)` without defensive copying — and so test
-      // fixtures or downstream code can't mutate the canonical
-      // segment list out from under the directive.
+      // Frozen so a wrapper component can pass `rv.segments` straight to
+      // `form.fields(...)` with no defensive copy, and so neither a test
+      // fixture nor downstream code can mutate the canonical segment list
+      // out from under the directive.
       segments: Object.freeze(segments.slice()),
       formKey: state.formKey,
       formInstanceId,
@@ -2367,25 +2368,24 @@ function isUnset(value) {
   return value === unset;
 }
 
-function walkUnsetSentinels(values, schema) {
+function walkUnsetSentinels(values, schema, rootDefault) {
   const paths = [];
   if (values === void 0) {
-    const rootSlim = schema.getDefaultAtPath([]);
-    walkUnspecified(rootSlim, [], paths);
+    walkUnspecified(rootDefault, [], paths);
     return { cleanedValues: void 0, paths };
   }
-  const cleaned = walkCore(values, [], schema, paths, true);
+  const cleaned = walkCore(values, [], schema, paths, { rootDefault });
   return { cleanedValues: cleaned, paths };
 }
 function isRecursable(value) {
   return Array.isArray(value) || isPlainRecord(value);
 }
-function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
+function walkCore(input, segments, schema, paths, synthesis) {
   if (isUnset(input)) {
     return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
-    if (synthesizeSchemaKeys) {
+    if (synthesis !== null) {
       const slim = schema.getDefaultAtPath(segments);
       return walkUnspecified(slim, segments, paths);
     }
@@ -2398,7 +2398,7 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     let mutated = false;
     for (let i = 0; i < input.length; i++) {
       const original = readConsumerIndex(input, i);
-      const walked = walkCore(original, [...segments, i], schema, paths, synthesizeSchemaKeys);
+      const walked = walkCore(original, [...segments, i], schema, paths, synthesis);
       out[i] = walked;
       if (walked !== original) mutated = true;
     }
@@ -2410,10 +2410,10 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     let keys = inputKeys;
     let mutated = false;
     let inputKeysSet = null;
-    if (synthesizeSchemaKeys) {
+    if (synthesis !== null) {
       inputKeysSet = new Set(inputKeys);
       const allKeys = new Set(inputKeys);
-      const slim = schema.getDefaultAtPath(segments);
+      const slim = segments.length === 0 ? synthesis.rootDefault : schema.getDefaultAtPath(segments);
       if (isPlainRecord(slim)) {
         for (const k of Object.keys(slim)) allKeys.add(k);
       }
@@ -2423,12 +2423,12 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     const out = {};
     for (const key of keys) {
       const orig = readConsumerProp(obj, key);
-      if (synthesizeSchemaKeys && orig === void 0 && inputKeysSet?.has(key) === true) {
+      if (synthesis !== null && orig === void 0 && inputKeysSet?.has(key) === true) {
         safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
-      const walked = walkCore(orig, [...segments, key], schema, paths, synthesizeSchemaKeys);
+      const walked = walkCore(orig, [...segments, key], schema, paths, synthesis);
       safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
@@ -2452,7 +2452,7 @@ function walkUnspecified(slim, segments, paths) {
 }
 function substituteUnsetSentinels(value, prefix, schema) {
   const paths = [];
-  const cleaned = walkCore(value, [...prefix], schema, paths, false);
+  const cleaned = walkCore(value, [...prefix], schema, paths, null);
   return { cleanedValues: cleaned, paths };
 }
 function isPrimitiveOrEmpty(value) {
@@ -2550,15 +2550,15 @@ function buildMetaProxy(keys, read) {
   return new Proxy(target, {
     get: (_, key) => owns.has(key) ? read(key) : Reflect.get(target, key),
     has: (_, key) => owns.has(key) || Reflect.has(target, key),
-    // Safe to hand back the same array every time: the spec copies a
-    // trap's key list before using it.
+    // Safe to hand back the same array every time: the spec copies a trap's
+    // key list before using it.
     ownKeys: () => keys,
     getOwnPropertyDescriptor(_, key) {
       if (!owns.has(key)) return Reflect.getOwnPropertyDescriptor(target, key);
       return { configurable: true, enumerable: true, value: read(key), writable: false };
     },
-    // A getter with no setter throws on assignment under strict mode,
-    // which every module here is. `false` keeps that.
+    // A getter with no setter throws on assignment under strict mode, which
+    // every module here is; `false` keeps that.
     set: denyWrite,
     deleteProperty: denyWrite,
     defineProperty: denyWrite
@@ -2617,7 +2617,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
     void state.submitted.value;
     return metaBase;
   };
-  const pathSweep = state.pathSweep;
+  const releases = [];
+  const lease = (release) => {
+    releases.push(release);
+    return release;
+  };
+  onScopeDispose(() => {
+    for (const release of releases) release();
+  }, true);
+  const pathSweep = {
+    track: state.pathSweep.track,
+    onEvict: (evict) => lease(state.pathSweep.onEvict(evict))
+  };
   const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
@@ -2675,7 +2686,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
       const walked2 = walkUnsetSentinels(
         next,
-        state.schema
+        state.schema,
+        state.schema.getDefaultAtPath([])
       );
       const ok2 = state.setValueAtPath([], walked2.cleanedValues, writeMeta());
       if (!ok2) return false;
@@ -2740,7 +2752,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const errorsProxy = buildErrorsSurface(state, pathSweep);
   function flattenUserErrors() {
     const all = [];
-    for (const cell of state.errorCells.values()) all.push(...cell.user);
+    for (const cell of state.errorCells().values()) all.push(...cell.user);
     return all;
   }
   function setErrors(arg1, arg2) {
@@ -2748,7 +2760,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (isScoped) {
       const { segments, key } = canonicalizePath(arg1);
       const input2 = arg2;
-      const resolved2 = typeof input2 === "function" ? input2([...state.errorCells.get(key)?.user ?? []]) : input2;
+      const resolved2 = typeof input2 === "function" ? input2([...state.errorCells().get(key)?.user ?? []]) : input2;
       state.setUserErrorsForPath(
         segments,
         normalizeErrorInputs(resolved2, segments, AttaformErrorCode.UserError)
@@ -2776,7 +2788,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const departAttempts = computed(() => state.departAttempts.value);
   const validating = computed(() => state.activeValidations.value > 0);
   const valid = computed(
-    () => state.firstValidationDone.value && state.errorCells.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
+    () => state.firstValidationDone.value && state.errorCells().size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
   );
   const history = options.history;
   const formHistory = history === void 0 ? inertHistory() : readonly(
@@ -2794,12 +2806,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
   );
   const rootFieldState = getRootFieldStateAt([]);
   const metaOwn = {
-    // Whole-form work signals compose the LIFECYCLE counters with the
-    // per-leaf rollup: a submit-time validate shows up as
-    // activeValidations, per-field debounced validators as
-    // fieldValidationCounts — either flips the flag. `valid` keeps the
-    // form-level `firstValidationDone` mount gate; `errors` is the
-    // unfiltered whole-form aggregate.
+    // Whole-form work signals compose the LIFECYCLE counters with the per-leaf
+    // rollup: a submit-time validate shows up in `activeValidations` and a
+    // per-field debounced validator in `fieldValidationCounts`, and either
+    // flips the flag. `valid` keeps the form-level mount gate, and `errors` is
+    // the unfiltered whole-form aggregate.
     validating: computed(
       () => state.activeValidations.value > 0 || rootFieldState.value.validating
     ),
@@ -2811,7 +2822,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     busy: computed(
       () => state.activeValidations.value > 0 || state.activeTransforms.value > 0 || rootFieldState.value.validating || rootFieldState.value.transforming
     ),
-    // Lifecycle (form-level only — not on FieldState).
+    // Lifecycle, form-level only and never on FieldState.
     submitting,
     submissionAttempts,
     departAttempts,
@@ -2893,7 +2904,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     };
     return Object.freeze(view);
   });
-  const valuesProxy = buildValuesSurface(state.form, state.onFormChange);
+  const valuesProxy = buildValuesSurface(
+    state.form,
+    (listener) => lease(state.onFormChange(listener))
+  );
   const fieldStateProxy = buildFieldsSurface(state, getRootFieldStateAt, pathSweep);
   const needsLazyGate = state.defaultValuesFactory.value !== void 0 || state.hasSsrPrefetch;
   function gated(fn) {
@@ -2928,10 +2942,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   const api = {
     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.
+    // The callable readonly Proxies (`values`, `fields`, `errors`) and the
+    // reactive containers (`meta`, `history`, `blankPaths`) are exposed through
+    // getters, so reading one activates the form on first touch. Each
+    // underlying object is identity-stable across reads.
     get values() {
       void state.activate();
       return valuesProxy;
@@ -2948,7 +2962,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     key: state.formKey,
     // 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.
+    // activates the form: observing factory state implies use.
     get hydrating() {
       void state.activate();
       return state.hydrating.value;
@@ -2957,20 +2971,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
       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.
+    // Orthogonal to `hydrating` and `hydrateError`. `ready` flips true once
+    // defaults are applied, whether sync at construction or from a factory
+    // that resolved, and it is a one-way latch: it stays true through later
+    // refetches even when those fail, so a stale-while-revalidate UI keeps
+    // rendering the prior values while `hydrateError` surfaces the 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` and `activate` are activation entry points themselves and
+    // fire the factory by design, so wrapping them in `gated` would
+    // double-fire. They call `state` directly.
     rehydrate: () => state.rehydrate(),
     activate: () => state.activate(),
     get errors() {
@@ -3016,7 +3028,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
 const SWEEP_SLICE = 8;
 function createDynamicPathSweep(deps) {
   const dynamicKeys = /* @__PURE__ */ new Set();
-  const evictors = [];
+  const evictors = /* @__PURE__ */ new Set();
   const isDynamicPath = (segments) => {
     for (let i = 0; i < segments.length; i++) {
       if (typeof segments[i] === "number") return true;
@@ -3047,7 +3059,10 @@ function createDynamicPathSweep(deps) {
       if (isDynamicPath(segments)) dynamicKeys.add(key);
     },
     onEvict(evict) {
-      evictors.push(evict);
+      evictors.add(evict);
+      return () => {
+        evictors.delete(evict);
+      };
     }
   };
 }
@@ -3246,7 +3261,7 @@ function mergeObjectKeys(target, source, path, schema) {
 async function runFactoryAndApply(st, factory) {
   try {
     const value = await factory();
-    walkAuthoredFromConstraints(value, [], st.authoredPaths);
+    if (st.hasPreprocessOrCoerce) walkAuthoredFromConstraints(value, [], st.authoredPaths);
     const full = mergeSparseHydration(
       toRaw(st.form.value),
       value,
@@ -3270,7 +3285,7 @@ async function runFactoryAndApply(st, factory) {
   }
 }
 function clearHydrationFailedEntry(st) {
-  const existing = st.errorCells.get(ROOT_PATH_KEY)?.schema;
+  const existing = st.errorCells().get(ROOT_PATH_KEY)?.schema;
   if (existing === void 0 || existing.length === 0) return;
   const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
   if (filtered.length !== existing.length) {
@@ -3284,7 +3299,7 @@ function appendHydrationFailedEntry(st, error) {
     path: [...ROOT_PATH],
     code: AttaformErrorCode.HydrationFailed
   };
-  const existing = st.errorCells.get(ROOT_PATH_KEY)?.schema ?? [];
+  const existing = st.errorCells().get(ROOT_PATH_KEY)?.schema ?? [];
   st.setSchemaErrorsForPath([...ROOT_PATH], [...existing, entry]);
   return entry;
 }
@@ -3402,23 +3417,24 @@ function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out)
     out.add(canonicalizePath(prefix).key);
   }
 }
-function computeBaselineResponse(schema, source) {
-  const completed = source === void 0 ? void 0 : mergeStructural(schema, [], source);
+function computeBaseline(schema, source, schemaDefaults) {
+  if (source === void 0) return schemaDefaults;
   return schema.getDefaultValues({
     useDefaultSchemaValues: true,
-    constraints: completed
+    constraints: mergeStructural(schema, [], source, schemaDefaults)
   });
 }
 function initialFirstValidationGate(schema) {
   return schema.needsAsyncValidation?.() !== true;
 }
-function seedOriginalsFromBaseline(st, baseline, ensureOrdinals) {
+function seedOriginalsFromBaseline(st, baseline) {
   st.originals.clear();
   diffAndApply({}, baseline, [], (patch) => {
     if (patch.kind !== "added") return;
-    const { key } = canonicalizePath(patch.path);
-    st.originals.set(key, { segments: patch.path, value: patch.newValue });
-    if (ensureOrdinals) ensurePathOrdinal(st, key);
+    st.originals.set(canonicalizePath(patch.path).key, {
+      segments: patch.path,
+      value: patch.newValue
+    });
   });
 }
 function queueInitialAsyncValidation(st) {
@@ -3432,6 +3448,7 @@ function queueInitialAsyncValidation(st) {
   }
 }
 function rebuildAuthoredPaths(st, constraints, schemaWithDefaultsData) {
+  if (!st.hasPreprocessOrCoerce) return;
   st.authoredPaths.clear();
   if (constraints !== void 0) {
     walkAuthoredFromConstraints(constraints, [], st.authoredPaths);
@@ -3465,6 +3482,7 @@ function ensurePathOrdinal(st, key) {
   return ordinal;
 }
 function pathHasAsyncValidationByKey(st, key, segments) {
+  if (st.schema.needsAsyncValidation?.() === false) return false;
   const cached = st.pathAsyncCache.get(key);
   if (cached !== void 0) return cached;
   const candidates = st.schema.getSchemasAtPath(segments);
@@ -3585,19 +3603,16 @@ function touchFieldRecord(st, pathKey, path, patch) {
     path,
     updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
     connected: patch.connected ?? current?.connected ?? false,
-    // 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` / `blurred` need an explicit-undefined guard: a patch
+    // legitimately carries `null` to mark a disconnect, and `??` would
+    // short-circuit on it and fall through to `current`, losing the intent.
     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` is a plain boolean, so `??` is equivalent to the guard above.
     touched: patch.touched ?? current?.touched ?? false,
-    // interacted is sticky-true; a merge patch only ever sets it, so
-    // `??` preserves the current bit. It flips back to false solely
-    // through the reset paths, which reconstruct the record outright.
+    // `interacted` is sticky-true and a merge patch only ever sets it, so `??`
+    // preserves the current bit. Only the reset paths clear it, and they
+    // reconstruct the record outright.
     interacted: patch.interacted ?? current?.interacted ?? false,
     blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
   });
@@ -3796,16 +3811,19 @@ function setValueAtPath(st, path, value, meta) {
       }
     }
   }
-  const wasAuthoredBefore = st.authoredPaths.has(pathKey);
-  if (arrayOpRemap !== null && Array.isArray(value)) {
-    if (path.length > 0) st.authoredPaths.add(pathKey);
-    for (const idx of arrayOpRemap.fresh) {
-      walkAuthoredFromConstraints(value[idx], [...path, idx], st.authoredPaths);
+  let newlyAuthored = false;
+  if (st.hasPreprocessOrCoerce) {
+    const wasAuthoredBefore = st.authoredPaths.has(pathKey);
+    if (arrayOpRemap !== null && Array.isArray(value)) {
+      if (path.length > 0) st.authoredPaths.add(pathKey);
+      for (const idx of arrayOpRemap.fresh) {
+        walkAuthoredFromConstraints(value[idx], [...path, idx], st.authoredPaths);
+      }
+    } else {
+      walkAuthoredFromConstraints(value, path, st.authoredPaths);
     }
-  } else {
-    walkAuthoredFromConstraints(value, path, st.authoredPaths);
+    newlyAuthored = !wasAuthoredBefore && st.authoredPaths.has(pathKey);
   }
-  const newlyAuthored = !wasAuthoredBefore && st.authoredPaths.has(pathKey);
   let completedValue;
   if (arrayOpRemap !== null && Array.isArray(value)) {
     for (const idx of arrayOpRemap.fresh) {
@@ -4062,22 +4080,38 @@ function getValueAtPath(st, path) {
   return getAtPath(st.form.value, path);
 }
 const ERROR_SOURCES = ["schema", "user"];
+function createErrorCells(schema, pristine) {
+  const raw = /* @__PURE__ */ new Map();
+  const cells = shallowReactive(raw);
+  return (seed) => {
+    const data = pristine;
+    if (data !== void 0) {
+      pristine = void 0;
+      if (seed) {
+        for (const [key, list] of groupErrorsByKey(schema.validateSync(data))) {
+          raw.set(key, { schema: list, user: NO_ERRORS });
+        }
+      }
+    }
+    return cells;
+  };
+}
 function setErrorChannelForKey(st, key, src, entries) {
-  const current = st.errorCells.get(key);
+  const current = st.errorCells().get(key);
   const schema = src === "schema" ? entries : current?.schema ?? NO_ERRORS;
   const user = src === "user" ? entries : current?.user ?? NO_ERRORS;
   if (schema.length === 0 && user.length === 0) {
-    if (current !== void 0) st.errorCells.delete(key);
+    if (current !== void 0) st.errorCells().delete(key);
     return;
   }
-  st.errorCells.set(key, { schema, user });
+  st.errorCells().set(key, { schema, user });
 }
 function replaceErrorChannel(st, src, entries) {
   const other = src === "schema" ? "user" : "schema";
   const grouped = groupErrorsByKey(entries);
-  for (const [key, cell] of st.errorCells) {
+  for (const [key, cell] of st.errorCells()) {
     if (cell[other].length === 0) {
-      st.errorCells.delete(key);
+      st.errorCells().delete(key);
       continue;
     }
     const fresh = grouped.get(key);
@@ -4102,8 +4136,9 @@ function clearErrorChannel(st, src, path) {
 function applySchemaErrorsForSubtree(st, path, entries) {
   const parentKey = canonicalizePath(path).key;
   const grouped = groupErrorsByKey(entries);
+  if (path.length === 0) st.skipErrorSeed();
   if (!grouped.has(parentKey)) setErrorChannelForKey(st, parentKey, "schema", NO_ERRORS);
-  for (const [existingKey, cell] of st.errorCells) {
+  for (const [existingKey, cell] of st.errorCells()) {
     if (existingKey === parentKey) continue;
     if (cell.schema.length === 0) continue;
     if (isPathKeyUnder(existingKey, path) && !grouped.has(existingKey)) {
@@ -4115,15 +4150,15 @@ function applySchemaErrorsForSubtree(st, path, entries) {
   }
 }
 function restoreErrorCells(st, entries) {
-  st.errorCells.clear();
+  st.skipErrorSeed().clear();
   for (const [key, cell] of entries) {
     if (cell.schema.length === 0 && cell.user.length === 0) continue;
-    st.errorCells.set(key, { schema: [...cell.schema], user: [...cell.user] });
+    st.errorCells().set(key, { schema: [...cell.schema], user: [...cell.user] });
   }
 }
 function getErrorsForPath(st, path) {
   const { key } = canonicalizePath(path);
-  const cell = st.errorCells.get(key);
+  const cell = st.errorCells().get(key);
   const blankForKey = st.derivedBlankErrors.value.get(key);
   if (cell === void 0 && blankForKey === void 0) {
     return [];
@@ -4160,13 +4195,13 @@ function markFocused(st, path, focused, meta) {
   touchFieldRecord(st, key, path, {
     focused,
     blurred: !focused,
-    // `touched` flips to true on blur and stays true thereafter; while
-    // a field is currently focused we keep whatever value it held.
+    // `touched` flips true on blur and stays; a focused field keeps whatever
+    // it held.
     touched: focused ? current?.touched ?? false : true,
-    // `blurredAfterInteraction` flips true on the first blur that lands
-    // after a value edit and stays true. A tab-through blur before any
-    // edit leaves it false (`interacted` is still false at that blur),
-    // which is what keeps a clean tab-through from arming the gate.
+    // `blurredAfterInteraction` flips true on the first blur after a value
+    // edit and stays. A tab-through blur before any edit leaves it false,
+    // since `interacted` is still false, which is what keeps a clean
+    // tab-through from arming the gate.
     blurredAfterInteraction: !focused && current?.interacted === true ? true : current?.blurredAfterInteraction ?? false
   });
   const focusMode = meta?.instance?.validateOn ?? st.fieldValidationMode;
@@ -4273,7 +4308,14 @@ function adoptResolvedDefaults(st, value) {
       st.schema
     )
   );
-  seedOriginalsFromBaseline(st, computeBaselineResponse(st.schema, st.defaultValues).data, false);
+  seedOriginalsFromBaseline(
+    st,
+    computeBaseline(
+      st.schema,
+      st.defaultValues,
+      st.schema.getDefaultValues({ useDefaultSchemaValues: true })
+    )
+  );
 }
 function reset(st, nextDefaultValues) {
   const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
@@ -4282,13 +4324,16 @@ function reset(st, nextDefaultValues) {
     st.schema
   );
   st.defaultValues = structuralSnapshot(resetSource);
-  const resetResponse = computeBaselineResponse(st.schema, resetSource);
-  const next = resetResponse.data;
+  const next = computeBaseline(
+    st.schema,
+    resetSource,
+    st.schema.getDefaultValues({ useDefaultSchemaValues: true })
+  );
   rebuildAuthoredPaths(st, resetSource, next);
   applyFormReplacement(st, next);
   st.arrayIdentity.rebaselineAll();
   st.removedSubtrees.clear();
-  seedOriginalsFromBaseline(st, next, false);
+  seedOriginalsFromBaseline(st, next);
   if (nextDefaultValues !== void 0) {
     const mentioned = /* @__PURE__ */ new Set();
     walkAuthoredFromConstraints(nextDefaultValues, [], mentioned);
@@ -4298,14 +4343,8 @@ function reset(st, nextDefaultValues) {
   for (const key of st.originalBlankPaths) {
     st.blankPaths.add(key);
   }
-  st.errorCells.clear();
-  if (!resetResponse.success) {
-    replaceErrorChannel(st, "schema", resetResponse.errors);
-  }
-  const syncResult = st.schema.validateAtPath(st.form.value, void 0, { sync: true });
-  if (!(syncResult instanceof Promise) && !syncResult.success) {
-    applySchemaErrorsForSubtree(st, [], syncResult.errors);
-  }
+  st.skipErrorSeed().clear();
+  replaceErrorChannel(st, "schema", st.schema.validateSync(next));
   st.firstValidationDone.value = initialFirstValidationGate(st.schema);
   queueInitialAsyncValidation(st);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4382,7 +4421,7 @@ function resetField(st, path) {
   }
 }
 function deleteErrorCellsUnderPrefix(st, prefix) {
-  for (const [errorKey, cell] of st.errorCells) {
+  for (const [errorKey, cell] of st.errorCells()) {
     for (const src of ERROR_SOURCES) {
       const first = cell[src][0];
       if (first !== void 0 && isPathPrefix(prefix, first.path)) {
@@ -4447,8 +4486,8 @@ function createFormStore(options) {
   const fieldValidatingSince = reactive(/* @__PURE__ */ new Map());
   const displayEngine = createDisplayEngine(ssr);
   cleanupHooks.push(() => displayEngine.dispose());
-  const schemaResponse = computeBaselineResponse(schema, defaultValues);
-  const schemaInitialData = schemaResponse.data;
+  const ownDefaultValues = structuralSnapshot(defaultValues);
+  const schemaInitialData = computeBaseline(schema, ownDefaultValues, options.schemaDefaults);
   const authoredPaths = /* @__PURE__ */ new Set();
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
   const hasDU = schema.hasDiscriminatedUnions?.() !== false;
@@ -4462,7 +4501,11 @@ function createFormStore(options) {
   });
   const fields = shallowReactive(/* @__PURE__ */ new Map());
   const domBinding = shallowRef(null);
-  const errorCells = shallowReactive(/* @__PURE__ */ new Map());
+  const errorStore = createErrorCells(
+    schema,
+    hydration === void 0 ? schemaInitialData : void 0
+  );
+  const errorCells = () => errorStore(true);
   const originals = shallowReactive(/* @__PURE__ */ new Map());
   const removedSubtrees = /* @__PURE__ */ new Set();
   const blankPaths = reactive(/* @__PURE__ */ new Set());
@@ -4486,7 +4529,7 @@ function createFormStore(options) {
     return result;
   });
   const errorPathIndex = computed(
-    () => buildErrorPathIndex(errorCells, derivedBlankErrors.value)
+    () => buildErrorPathIndex(errorCells(), derivedBlankErrors.value)
   );
   const submitting = ref(false);
   const activeSubmissions = ref(0);
@@ -4618,21 +4661,16 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     // --- kernel-internal state ---
-    // Defensive copy, not a fix for an observed alias: today
-    // `getDefaultValues` happens to build a fresh tree, so form storage
-    // does not currently share structure with the consumer's object.
-    // That is an adapter implementation detail rather than a contract,
-    // and this field is now durable state that every `reset()` reads, so
-    // it should not depend on it. The copy also means a consumer who
-    // keeps a reference to the literal they passed cannot mutate the
-    // form's defaults from outside. `reset()` snapshots for a harder
-    // reason (see there) where an alias IS reachable.
-    defaultValues: structuralSnapshot(defaultValues),
+    // The copy taken above, which also stops a consumer holding a reference to
+    // the literal they passed from mutating the form's defaults from outside.
+    // `reset()` snapshots for a harder reason, where an alias IS reachable.
+    defaultValues: ownDefaultValues,
     ssrPrefetch,
     rememberVariants,
     fieldValidationMode,
     fieldValidationDebounceMs,
     hasDU,
+    hasPreprocessOrCoerce: schema.hasPreprocessOrCoerce?.() !== false,
     fieldValidationState,
     formChangeListeners,
     submitSuccessListeners,
@@ -4648,6 +4686,7 @@ function createFormStore(options) {
     transformRuns,
     transformWaiters,
     arrayBookkeeping,
+    skipErrorSeed: () => errorStore(false),
     nextOrdinal: 0,
     scheduleEpoch: 0,
     lastCommittedEpoch: 0,
@@ -4664,10 +4703,10 @@ function createFormStore(options) {
     arrayElementKey: bind(arrayElementKey),
     reset: bind(reset),
     resetField: bind(resetField),
-    // The schema/user pair below reads as a fold waiting to happen. It was
-    // tried: a `setErrorsForPathIn(channel)` factory measured 10 B LARGER,
-    // because gzip had already collected the rent on two adjacent copies
-    // and the helper added a name the original did not need.
+    // The schema/user pair below reads as a fold waiting to happen. Folding
+    // them into a `setErrorsForPathIn(channel)` factory measures 10 B LARGER:
+    // gzip has already collected the rent on two adjacent copies, and the
+    // helper adds a name the original does not need.
     setSchemaErrorsForPath: (path, entries) => setErrorChannelForKey(
       st,
       canonicalizePath(path).key,
@@ -4715,7 +4754,25 @@ function createFormStore(options) {
     dispose: bind(dispose)
   };
   rebuildAuthoredPaths(st, defaultValues, schemaInitialData);
-  seedOriginalsFromBaseline(st, schemaInitialData, true);
+  const initStamp = (/* @__PURE__ */ new Date()).toISOString();
+  diffAndApply({}, schemaInitialData, [], (patch) => {
+    if (patch.kind !== "added") return;
+    const { key } = canonicalizePath(patch.path);
+    originals.set(key, { segments: patch.path, value: patch.newValue });
+    ensurePathOrdinal(st, key);
+    if (hydration === void 0) {
+      fields.set(key, {
+        path: patch.path,
+        updatedAt: initStamp,
+        connected: false,
+        focused: null,
+        blurred: null,
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
+      });
+    }
+  });
   if (hydration !== void 0) {
     for (const [rawKey, record] of hydration.fields) {
       if (typeof rawKey !== "string" || !isHydratedFieldRecord(record)) {
@@ -4735,25 +4792,6 @@ function createFormStore(options) {
       }
       setErrorChannelForKey(st, rawKey, "user", errs);
     }
-  } else {
-    const initStamp = (/* @__PURE__ */ new Date()).toISOString();
-    diffAndApply({}, initialData, [], (patch) => {
-      if (patch.kind !== "added") return;
-      const { key } = canonicalizePath(patch.path);
-      fields.set(key, {
-        path: patch.path,
-        updatedAt: initStamp,
-        connected: false,
-        focused: null,
-        blurred: null,
-        touched: false,
-        interacted: false,
-        blurredAfterInteraction: false
-      });
-    });
-    if (!schemaResponse.success) {
-      replaceErrorChannel(st, "schema", schemaResponse.errors);
-    }
   }
   queueInitialAsyncValidation(st);
   return st;
@@ -4846,9 +4884,11 @@ const HISTORY_MODULE_KEY = "history";
 function buildFreshState(key, schema, configuration, registry) {
   const pending = registry.pendingHydration.get(key);
   if (pending !== void 0) registry.pendingHydration.delete(key);
+  const schemaDefaults = schema.getDefaultValues({ useDefaultSchemaValues: true });
   const walked = walkUnsetSentinels(
     configuration.defaultValues,
-    schema
+    schema,
+    schemaDefaults
   );
   let initialBlankPaths;
   if (pending === void 0) {
@@ -4858,6 +4898,7 @@ function buildFreshState(key, schema, configuration, registry) {
     formKey: key,
     schema,
     defaultValues: walked.cleanedValues,
+    schemaDefaults,
     hydration: pending,
     ssr: registry.ssr,
     ...pickDefined({
@@ -4868,12 +4909,10 @@ function buildFreshState(key, schema, configuration, registry) {
       coerce: configuration.coerce,
       initialBlankPaths
     }),
-    // 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
+    // Server only. `enqueue` records intent on every `state.activate()`
+    // so a wizard skip-list override has a consistent set to diff
+    // against; `shouldFire` lets the activate path bail on a key the
+    // wizard skipped. Even an explicit `form.activate()` defers to that
     // skip-list on the server.
     ...registry.ssr ? {
       ssrPrefetch: {
@@ -4910,6 +4949,7 @@ function resolveFormKey(key) {
 }
 
 let injectedInstanceCounter = 0;
+const sharedApis = /* @__PURE__ */ new WeakMap();
 function injectForm(input) {
   const key = typeof input === "string" ? input : input?.key;
   const ssrAccessed = typeof input === "object" && input !== null ? input.__ssrAccessed === true : false;
@@ -4932,12 +4972,37 @@ function injectForm(input) {
     apiOptions.history = history;
   }
   const ambientInstanceId = getCurrentInstance() !== null ? inject(kFormInstanceId, null) : null;
-  const formInstanceId = ambientInstanceId ?? (getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
-  return buildFormApi(
+  const api = ambientInstanceId !== null ? shareApi(state, ambientInstanceId, apiOptions) : buildFormApi(
     state,
-    formInstanceId,
+    getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`,
     apiOptions
   );
+  return api;
+}
+function shareApi(state, formInstanceId, options) {
+  let instances = sharedApis.get(state);
+  if (instances === void 0) {
+    instances = /* @__PURE__ */ new Map();
+    sharedApis.set(state, instances);
+  }
+  const byInstance = instances;
+  let shared = byInstance.get(formInstanceId);
+  if (shared === void 0) {
+    const scope = effectScope(true);
+    const api = scope.run(() => buildFormApi(state, formInstanceId, options));
+    if (api === void 0) return buildFormApi(state, formInstanceId, options);
+    shared = { api, scope, users: 0 };
+    byInstance.set(formInstanceId, shared);
+  }
+  const entry = shared;
+  entry.users += 1;
+  onScopeDispose(() => {
+    entry.users -= 1;
+    if (entry.users > 0) return;
+    entry.scope.stop();
+    byInstance.delete(formInstanceId);
+  });
+  return entry.api;
 }
 function resolveState(key, registry) {
   if (key !== void 0) {
@@ -4997,22 +5062,23 @@ function useRegister(options) {
   const capturedRegisterValue = shallowRef(void 0);
   const refreshAndStripBridgeAttrs = () => {
     const rawAttrs = instance.attrs;
+    const parentBinding = instance.vnode.dirs?.find(
+      (dir) => dir.dir?.[V_REGISTER_MARKER] === true
+    );
     if ("registerValue" in rawAttrs) {
       capturedRegisterValue.value = rawAttrs["registerValue"];
       delete rawAttrs["registerValue"];
-      if (capturedRegisterValue.value !== void 0) armDomBinding(capturedRegisterValue.value);
-    } else {
-      const dirs = instance.vnode.dirs;
-      if (dirs !== null && dirs !== void 0) {
-        for (const dir of dirs) {
-          const marked = dir.dir?.[V_REGISTER_MARKER];
-          if (marked === true) {
-            capturedRegisterValue.value = dir.value;
-            if (capturedRegisterValue.value !== void 0)
-              armDomBinding(capturedRegisterValue.value);
-            break;
-          }
-        }
+    } else if (parentBinding !== void 0) {
+      capturedRegisterValue.value = parentBinding.value;
+    }
+    const captured = capturedRegisterValue.value;
+    if (captured !== void 0) {
+      armDomBinding(captured);
+      if (parentBinding !== void 0) {
+        recordInheritedModifiers(
+          captured,
+          withInheritedModifiers(parentBinding.value, parentBinding.modifiers)
+        );
       }
     }
     if ("value" in rawAttrs) delete rawAttrs["value"];
@@ -5119,11 +5185,11 @@ const NOOP_SUCCESS = {
   data: EMPTY_VALUE,
   errors: void 0
 };
-const NOOP_DEFAULTS = NOOP_SUCCESS;
 let NOOP_SCHEMA;
 function buildNoopWizardSchema() {
   NOOP_SCHEMA ?? (NOOP_SCHEMA = {
-    getDefaultValues: () => NOOP_DEFAULTS,
+    getDefaultValues: () => EMPTY_VALUE,
+    validateSync: () => [],
     getDefaultAtPath: () => void 0,
     getEmptyValueAtPath: () => void 0,
     isPreprocessOrCoerceLeaf: () => false,
@@ -5139,7 +5205,8 @@ function buildNoopWizardSchema() {
     isLeafAtPath: () => false,
     isRequiredAtPath: () => false,
     getUnionDiscriminatorAtPath: () => void 0,
-    hasDiscriminatedUnions: () => false
+    hasDiscriminatedUnions: () => false,
+    hasPreprocessOrCoerce: () => false
   });
   return NOOP_SCHEMA;
 }
@@ -5335,27 +5402,33 @@ function useWizard(options) {
       return activeKey.value === "" ? void 0 : activeKey.value;
     }
   };
-  function lazyComputedFor(marker) {
+  function lazyComputedFor(marker, index) {
     const cached = lazyComputeds.get(marker);
     if (cached !== void 0) return cached;
     const c = computed(() => {
       void lazyEpoch.value;
-      return marker.resolve(slotCtx);
+      return callConsumerFn(
+        () => marker.resolve(slotCtx),
+        void 0);
     });
     lazyComputeds.set(marker, c);
     return c;
   }
   const MAX_SLOT_DEPTH = 32;
-  function normalizeSlot(slot, ctx, gated, depth) {
+  function normalizeSlot(slot, ctx, gated, depth, index) {
     if (depth > MAX_SLOT_DEPTH) {
       return void 0;
     }
     if (slot === void 0 || slot === null) return void 0;
     if (typeof slot === "string") return { form: getOrBuildNoop(slot), gated };
     if (isGateMarker(slot)) return normalizeSlot(slot.inner, ctx, true, depth + 1);
-    if (isLazyMarker(slot)) return normalizeSlot(lazyComputedFor(slot).value, ctx, gated, depth + 1);
+    if (isLazyMarker(slot)) {
+      return normalizeSlot(lazyComputedFor(slot).value, ctx, gated, depth + 1);
+    }
     if (typeof slot === "function") {
-      const result = slot(ctx);
+      const result = callConsumerFn(
+        () => slot(ctx),
+        void 0);
       return normalizeSlot(result, ctx, gated, depth + 1);
     }
     if (isAnyForm(slot)) return { form: slot, gated };
@@ -5673,13 +5746,14 @@ function useWizard(options) {
       seedRef.value = resolved.value;
       applyGateSeed(resolved.value);
     } else {
-      const eager = resolved.factory();
+      const eager = callConsumerFn(() => resolved.factory(), void 0);
       if (eager instanceof Promise) {
         void eager.then((value) => {
           seedRef.value = value;
           applyGateSeed(value);
+        }).catch((err) => {
         });
-      } else {
+      } else if (eager !== void 0) {
         seedRef.value = eager;
         applyGateSeed(eager);
       }
@@ -5752,10 +5826,13 @@ function useWizard(options) {
   const statuses = buildWizardStatusesProxy(statusesRecord);
   const progressOverride = options.progress;
   const progress = computed(() => {
+    const list = compiledSteps.value;
     if (progressOverride !== void 0) {
-      return progressOverride(compiledSteps.value);
+      const override = callConsumerFn(
+        () => progressOverride(list),
+        null);
+      if (override !== null) return override;
     }
-    const list = compiledSteps.value;
     if (list.length === 0) return 0;
     let valid = 0;
     for (const step of list) {
@@ -5783,11 +5860,15 @@ function useWizard(options) {
   historyHandle.subscribe((value) => {
     urlMirror.value = value;
   });
-  const restoreCallback = options.restore === false ? void 0 : options.restore !== void 0 ? options.restore : () => {
+  const consumerRestore = options.restore;
+  const restoreCallback = consumerRestore === false ? void 0 : consumerRestore !== void 0 ? () => callConsumerFn(() => consumerRestore(), void 0) : () => {
     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) => {
+  const consumerPersist = options.persist;
+  const persistCallback = consumerPersist === false ? void 0 : consumerPersist !== void 0 ? (state) => {
+    callConsumerFn(() => consumerPersist(state), void 0);
+  } : (state) => {
     if (state.step === void 0) return;
     const current = historyHandle.read();
     const effectiveCurrent = current !== void 0 && isCompiledKey(current) ? current : firstKey();
@@ -6038,7 +6119,7 @@ function useWizard(options) {
     for (const key of keys) {
       const store = registry.forms.get(key);
       if (store === void 0) continue;
-      for (const cell of store.errorCells.values()) {
+      for (const cell of store.errorCells().values()) {
         for (const err of cell.user) out.push(toWizardAggregateError(err, key));
       }
     }