attaform 0.21.1 → 0.22.0

package/dist/shared/{attaform.DR6RmxWZ.mjs → attaform.CsB-iKbU.mjs}

@@ -1,5 +1,5 @@
-import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
-import { _ as __DEV__, j as canonicalizePath, G as segmentsForPathKey, t as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, H as toError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, r as getOrAssignElementId, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, v as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, K as useRegistry, z as kFormContext, B as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, y as kAttaformWizardActiveStepResolver, w as kAttaformAncestorWizard } from './attaform.pmtahXKy.mjs';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, isRef, toValue, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
+import { q as pathsEqual, l as isPathPrefix, _ as __DEV__, a as canonicalizePath, s as segmentsForPathKey, F as FORM_ERRORS_PATH_KEY, r as keyForSegments, S as SubmitErrorHandlerError, t as toError, A as AnonPersistError, w as INTERACTIVE_TAG_NAMES, x as getOrAssignElementId, R as ROOT_PATH, y as allowSensitivePersist, z as FORM_ERRORS_PATH, e as ROOT_PATH_KEY, B as segmentsToDotted, C as coerceToPathKey, E as isSensitivePath, G as createPersistOptInRegistry, d as InvalidUseFormConfigError, H as ensureAttaformInstalled, u as useRegistry, J as kFormContext, K as kFormInstanceId, h as ReservedFormKeyError, L as createIsSensitivePath, M as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, k as kAttaformWizardActiveStepResolver, N as kAttaformAncestorWizard } from './attaform.BKFwekY2.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -34,7 +34,7 @@ function descendStep(value, segment) {
   if (typeof value !== "object") return NOT_FOUND;
   if (Array.isArray(value)) {
     if (typeof segment !== "number") return NOT_FOUND;
-    if (segment < 0 || segment >= value.length) return NOT_FOUND;
+    if (!(segment in value)) return NOT_FOUND;
     return value[segment];
   }
   const record = value;
@@ -69,7 +69,7 @@ function hasAtPath(root, path) {
   if (current === null || current === void 0) return false;
   if (typeof current !== "object") return false;
   if (Array.isArray(current)) {
-    return typeof last === "number" && last >= 0 && last < current.length;
+    return typeof last === "number" && last in current;
   }
   const key = typeof last === "number" ? String(last) : last;
   if (isShadowedKey(key)) return safeOwnHas(current, key);
@@ -98,6 +98,31 @@ function setAtPathOffset(root, path, value, offset) {
   safeAssign(rec, head, setAtPathOffset(safeOwnRead(rec, head), path, value, nextOffset));
   return rec;
 }
+const NO_IN_PLACE = { applied: false };
+function tryInPlaceLeafWrite(root, path, value) {
+  if (path.length === 0) return NO_IN_PLACE;
+  let node = root;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (Array.isArray(node)) {
+      if (typeof seg !== "number" || seg < 0 || seg >= node.length) return NO_IN_PLACE;
+    } else if (isPlainRecord(node)) {
+      if (typeof seg !== "string" || isShadowedKey(seg) || !(seg in node)) return NO_IN_PLACE;
+    } else {
+      return NO_IN_PLACE;
+    }
+    const container = node;
+    if (i < path.length - 1) {
+      node = container[seg];
+      continue;
+    }
+    const old = container[seg];
+    if (isPlainRecord(old) || Array.isArray(old)) return NO_IN_PLACE;
+    container[seg] = value;
+    return { applied: true, old };
+  }
+  return NO_IN_PLACE;
+}
 function deleteAtPath(root, path) {
   return deleteAtPathOffset(root, path, 0);
 }
@@ -160,68 +185,80 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
   }
   if (consumer === null) return null;
   if (Array.isArray(consumer)) {
-    const shape = resolveArrayShape(schema, scratch);
-    const isTuple = typeof shape === "number";
-    const targetLen = isTuple ? shape : consumer.length;
-    let cachedElementDefault;
-    let cachedElementDefaultRead = false;
-    let mutated = targetLen > consumer.length;
-    const out = consumer.slice();
-    while (out.length < targetLen) out.push(void 0);
-    for (let i = 0; i < targetLen; i++) {
-      scratch.push(i);
-      let elemDefault;
-      if (isTuple) {
-        elemDefault = schema.getDefaultAtPath(scratch);
-      } else {
-        if (!cachedElementDefaultRead) {
-          cachedElementDefault = schema.getDefaultAtPath(scratch);
-          cachedElementDefaultRead = true;
-        }
-        elemDefault = cachedElementDefault;
-      }
-      const consumerElem = i < consumer.length ? consumer[i] : void 0;
-      const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
-      scratch.pop();
-      if (merged !== consumerElem) {
-        out[i] = merged;
-        mutated = true;
-      }
-    }
-    return mutated ? out : consumer;
+    return mergeStructuralArray(schema, scratch, consumer);
   }
   if (isPlainRecord(consumer)) {
     if (!isPlainRecord(defaultValue)) {
       return consumer;
     }
-    let mutated = false;
     const out = { ...consumer };
-    for (const key of Object.keys(defaultValue)) {
-      if (!safeOwnHas(consumer, key)) {
-        const defAtKey = safeOwnRead(defaultValue, key);
-        scratch.push(key);
-        const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
-        scratch.pop();
-        if (filled !== void 0) {
-          safeAssign(out, key, filled);
-          mutated = true;
-        }
+    const filledAny = fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out);
+    const recursedAny = recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out);
+    return filledAny || recursedAny ? out : consumer;
+  }
+  return consumer;
+}
+function mergeStructuralArray(schema, scratch, consumer) {
+  const shape = resolveArrayShape(schema, scratch);
+  const isTuple = typeof shape === "number";
+  const targetLen = isTuple ? shape : consumer.length;
+  let cachedElementDefault;
+  let cachedElementDefaultRead = false;
+  let mutated = targetLen > consumer.length;
+  const out = consumer.slice();
+  while (out.length < targetLen) out.push(void 0);
+  for (let i = 0; i < targetLen; i++) {
+    scratch.push(i);
+    let elemDefault;
+    if (isTuple) {
+      elemDefault = schema.getDefaultAtPath(scratch);
+    } else {
+      if (!cachedElementDefaultRead) {
+        cachedElementDefault = schema.getDefaultAtPath(scratch);
+        cachedElementDefaultRead = true;
       }
+      elemDefault = cachedElementDefault;
+    }
+    const consumerElem = i < consumer.length ? consumer[i] : void 0;
+    const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
+    scratch.pop();
+    if (merged !== consumerElem) {
+      out[i] = merged;
+      mutated = true;
     }
-    for (const key of Object.keys(consumer)) {
-      const cVal = safeOwnRead(consumer, key);
-      if (cVal === void 0) continue;
+  }
+  return mutated ? out : consumer;
+}
+function fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out) {
+  let mutated = false;
+  for (const key of Object.keys(defaultValue)) {
+    if (!safeOwnHas(consumer, key)) {
+      const defAtKey = safeOwnRead(defaultValue, key);
       scratch.push(key);
-      const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
+      const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
       scratch.pop();
-      if (merged !== cVal) {
-        safeAssign(out, key, merged);
+      if (filled !== void 0) {
+        safeAssign(out, key, filled);
         mutated = true;
       }
     }
-    return mutated ? out : consumer;
   }
-  return consumer;
+  return mutated;
+}
+function recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out) {
+  let mutated = false;
+  for (const key of Object.keys(consumer)) {
+    const cVal = safeOwnRead(consumer, key);
+    if (cVal === void 0) continue;
+    scratch.push(key);
+    const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
+    scratch.pop();
+    if (merged !== cVal) {
+      safeAssign(out, key, merged);
+      mutated = true;
+    }
+  }
+  return mutated;
 }
 function setAtPathWithSchemaFill(root, schema, fullPath, value) {
   if (fullPath.length === 0) return value;
@@ -304,55 +341,27 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   const oldIsDescendable = isDescendable(oldValue);
   const newIsDescendable = isDescendable(newValue);
   if (oldValue === void 0 && newIsDescendable) {
-    if (Array.isArray(newValue)) {
-      for (let i = 0; i < newValue.length; i++) {
-        diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = newValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
-      }
-    }
+    walkNewDescendable(newValue, prefix, visit);
     return;
   }
   if (oldIsDescendable && newValue === void 0) {
-    if (Array.isArray(oldValue)) {
-      for (let i = 0; i < oldValue.length; i++) {
-        diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
-      }
-    } else {
-      const rec = oldValue;
-      for (const k of Object.keys(rec)) {
-        diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
-      }
-    }
+    walkOldDescendable(oldValue, prefix, visit);
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
     const oldIsArray = Array.isArray(oldValue);
     const newIsArray = Array.isArray(newValue);
     if (oldIsArray && newIsArray) {
-      const oldArr = oldValue;
-      const newArr = newValue;
-      const max = Math.max(oldArr.length, newArr.length);
-      for (let i = 0; i < max; i++) {
-        diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
-      }
+      diffArraysLockstep(oldValue, newValue, prefix, visit);
       return;
     }
     if (!oldIsArray && !newIsArray) {
-      const oldRec = oldValue;
-      const newRec = newValue;
-      const seen = /* @__PURE__ */ new Set();
-      for (const k of Object.keys(oldRec)) {
-        seen.add(k);
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
-      for (const k of Object.keys(newRec)) {
-        if (seen.has(k)) continue;
-        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
-      }
+      diffObjectsLockstep(
+        oldValue,
+        newValue,
+        prefix,
+        visit
+      );
       return;
     }
     visit({ kind: "changed", path: prefix, oldValue, newValue });
@@ -376,7 +385,48 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   }
   visit({ kind: "changed", path: prefix, oldValue, newValue });
 }
-function applyChangedKeys(target, source) {
+function walkNewDescendable(newValue, prefix, visit) {
+  if (Array.isArray(newValue)) {
+    for (let i = 0; i < newValue.length; i++) {
+      diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+    }
+  } else {
+    const rec = newValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+    }
+  }
+}
+function walkOldDescendable(oldValue, prefix, visit) {
+  if (Array.isArray(oldValue)) {
+    for (let i = 0; i < oldValue.length; i++) {
+      diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+    }
+  } else {
+    const rec = oldValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+    }
+  }
+}
+function diffArraysLockstep(oldArr, newArr, prefix, visit) {
+  const max = Math.max(oldArr.length, newArr.length);
+  for (let i = 0; i < max; i++) {
+    diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+  }
+}
+function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(oldRec)) {
+    seen.add(k);
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+  for (const k of Object.keys(newRec)) {
+    if (seen.has(k)) continue;
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+}
+function applyChangedKeys(target, source, arrayOpPath, currentPath) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
@@ -394,11 +444,27 @@ function applyChangedKeys(target, source) {
   if (targetIsArray) {
     const t = target;
     const s = source;
-    if (t.length > s.length) t.length = s.length;
-    for (const idx of changedFirstSegments) {
-      if (typeof idx === "symbol") continue;
-      const i = typeof idx === "number" ? idx : Number(idx);
-      t[i] = s[i];
+    if (arrayOpPath === null || pathsEqual(currentPath, arrayOpPath)) {
+      if (t.length > s.length) t.length = s.length;
+      for (const idx of changedFirstSegments) {
+        if (typeof idx === "symbol") continue;
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        t[i] = s[i];
+      }
+    } else {
+      for (const idx of changedFirstSegments) {
+        if (typeof idx === "symbol") continue;
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        const childPath = appendSegment(currentPath, i);
+        const curEl = t[i];
+        const nextEl = s[i];
+        if (isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(curEl, nextEl, arrayOpPath, childPath)) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
     }
   } else {
     const t = target;
@@ -410,7 +476,14 @@ function applyChangedKeys(target, source) {
     for (const k of changedFirstSegments) {
       if (typeof k === "symbol") continue;
       const key = String(k);
-      safeAssign(t, key, safeOwnRead(s, key));
+      const nextVal = safeOwnRead(s, key);
+      if (arrayOpPath !== null) {
+        const curVal = safeOwnRead(t, key);
+        if (isDescendable(curVal) && isDescendable(nextVal) && applyChangedKeys(curVal, nextVal, arrayOpPath, appendSegment(currentPath, key))) {
+          continue;
+        }
+      }
+      safeAssign(t, key, nextVal);
     }
   }
   return true;
@@ -522,6 +595,50 @@ function resolveGetDisplayState(config) {
   return config ?? defaultDisplayState;
 }
 
+const AttaformErrorCode = {
+  /** A required field is in the blank set — user hasn't supplied a value. */
+  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",
+  /**
+   * 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"
+};
+function makeBlankRequiredError(segments, formKey) {
+  return {
+    message: "No value supplied",
+    path: [...segments],
+    formKey,
+    code: AttaformErrorCode.NoValueSupplied
+  };
+}
+
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -623,13 +740,19 @@ function buildFieldStateAccessor(state, formInstanceId, getFormMetaBase, options
     return c;
   };
 }
+function resolveFieldMetaAndLabel(state, segments) {
+  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
+  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
+  const label = resolved.label || humanize(lastSegment);
+  return { resolved, label };
+}
 function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const record = state.fields.get(key);
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
   const pristine = state.isPristineAtPath(segments);
   const schemaForKey = state.schemaErrors.get(key);
-  const blankForKey = state.derivedBlankErrors.value.get(key);
+  const blankForKey = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments, state.formKey)] : void 0;
   const userForKey = state.userErrors.get(key);
   const errors = [];
   if (schemaForKey !== void 0) errors.push(...schemaForKey);
@@ -644,9 +767,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const elementRecord = state.elements.get(key);
   const elementsArr = elementRecord ? Object.freeze([...elementRecord.elements]) : EMPTY_ELEMENTS;
   const firstElement = elementsArr[0] ?? null;
-  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
-  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
-  const label = resolved.label || humanize(lastSegment);
+  const { resolved, label } = resolveFieldMetaAndLabel(state, segments);
   return {
     value,
     original,
@@ -695,9 +816,32 @@ function buildLeafFieldState(state, segments, key, formInstanceId, getFormMetaBa
     getDisplayState
   );
 }
+function visitActiveLeafPaths(value, base, visit) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const child = value[i];
+      if (Array.isArray(child) || isPlainRecord(child)) {
+        visitActiveLeafPaths(child, [...base, i], visit);
+      } else {
+        visit([...base, i]);
+      }
+    }
+    return;
+  }
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) {
+      const child = value[k];
+      if (Array.isArray(child) || isPlainRecord(child)) {
+        visitActiveLeafPaths(child, [...base, k], visit);
+      } else {
+        visit([...base, k]);
+      }
+    }
+  }
+}
 function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
-  const value = state.getValueAtPath(segments);
+  const value = getAtPath(formValue, segments);
   const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
@@ -716,12 +860,16 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let asyncPending = false;
   const submissionAttempts = state.submissionAttempts.value;
   const blurredLeafSegments = [];
-  for (const [leafKey, entry] of state.originals) {
-    if (!isPathPrefix(segments, entry.segments)) continue;
-    if (segments.length === entry.segments.length) continue;
-    if (!hasAtPath(formValue, entry.segments)) continue;
+  const descendantLeaves = [];
+  visitActiveLeafPaths(value, segments, (leafSegments) => {
+    const { key: leafKey } = keyForSegments(leafSegments);
+    const entry = state.originals.get(leafKey);
+    if (entry === void 0) return;
+    descendantLeaves.push({ key: leafKey, segments: entry.segments });
+  });
+  for (const { key: leafKey, segments: leafSeg } of descendantLeaves) {
     const leafRecord = state.fields.get(leafKey);
-    if (!state.isPristineAtPathByKey(leafKey, entry.segments)) {
+    if (!state.isPristineAtPathByKey(leafKey, leafSeg)) {
       pristine = false;
       dirty = true;
     }
@@ -732,7 +880,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (leafRecord?.interacted === true) interacted = true;
     if (leafRecord?.blurredAfterInteraction === true) {
       blurredAfterInteraction = true;
-      blurredLeafSegments.push(entry.segments);
+      blurredLeafSegments.push(leafSeg);
     }
     if (leafRecord?.connected === true) connected = true;
     if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) {
@@ -749,7 +897,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       if (leafGateOpen && since !== void 0 && (transformingSince === null || since < transformingSince))
         transformingSince = since;
     }
-    if (state.pathHasAsyncValidationByKey(leafKey, entry.segments)) asyncPending = true;
+    if (state.pathHasAsyncValidationByKey(leafKey, leafSeg)) asyncPending = true;
     const ts = leafRecord?.updatedAt;
     if (ts !== void 0 && ts !== null) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
@@ -783,9 +931,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const ownTransformError = state.transformErrors.get(key) ?? null;
   const gated = asyncPending && !state.firstValidationDone.value;
   const valid = !gated && errors.length === 0 && !validating;
-  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
-  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
-  const label = resolved.label || humanize(lastSegment);
+  const { resolved, label } = resolveFieldMetaAndLabel(state, segments);
   return {
     base: {
       value,
@@ -1378,7 +1524,7 @@ function buildFieldArrayApi(state) {
     append(path, value) {
       const next = readArray(path);
       next.push(value);
-      return writeArray(path, next);
+      return writeArray(path, next, { kind: "insert", index: next.length - 1 });
     },
     prepend(path, value) {
       const next = readArray(path);
@@ -1568,20 +1714,20 @@ function buildFieldStateProxy(state, formInstanceId, getFormMetaBase, options) {
 }
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
   const liveValue = getAtPath(state.form.value, containerSegments);
-  return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
+  return walk$1(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
 }
-function walk$2(value, basePath, schema, snapshotFieldStateAt) {
+function walk$1(value, basePath, schema, snapshotFieldStateAt) {
   if (schema.isLeafAtPath(basePath)) return snapshotFieldStateAt(basePath);
   if (value === null || value === void 0) return value;
   if (typeof value !== "object") {
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((_, i) => walk$2(value[i], [...basePath, i], schema, snapshotFieldStateAt));
+    return value.map((_, i) => walk$1(value[i], [...basePath, i], schema, snapshotFieldStateAt));
   }
   const result = {};
   for (const key of Object.keys(value)) {
-    result[key] = walk$2(
+    result[key] = walk$1(
       value[key],
       [...basePath, key],
       schema,
@@ -1665,87 +1811,46 @@ function mergeDeep(target, source, path, schema) {
   if (!isPlainRecord(source)) return source;
   if (schema !== void 0) {
     const du = schema.getUnionDiscriminatorAtPath(path);
-    if (du !== void 0) {
-      const sourceRecord = source;
-      const sourceDisc = sourceRecord[du.discriminatorKey];
-      if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
-        return { [du.discriminatorKey]: sourceDisc };
-      }
-      if (sourceDisc !== void 0) {
-        const variantDefault = du.getVariantDefault(sourceDisc);
-        if (isPlainRecord(variantDefault)) {
-          const out2 = { ...variantDefault };
-          for (const key of Object.keys(sourceRecord)) {
-            if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
-            safeAssign(
-              out2,
-              key,
-              mergeDeep(
-                safeOwnRead(out2, key),
-                safeOwnRead(sourceRecord, key),
-                [...path, key],
-                schema
-              )
-            );
-          }
-          return out2;
-        }
-      }
-      return {};
+    if (du !== void 0) return mergeDuAwareKeys(source, path, schema, du);
+  }
+  return mergeObjectKeys(target, source, path, schema);
+}
+function mergeDuAwareKeys(source, path, schema, du) {
+  const sourceDisc = source[du.discriminatorKey];
+  if (sourceDisc !== void 0 && !du.isVariantSelected(sourceDisc)) {
+    return { [du.discriminatorKey]: sourceDisc };
+  }
+  if (sourceDisc !== void 0) {
+    const variantDefault = du.getVariantDefault(sourceDisc);
+    if (isPlainRecord(variantDefault)) {
+      return mergeVariantKeys(source, variantDefault, path, schema, du);
     }
   }
-  const mergeTarget = target;
-  const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
+  return {};
+}
+function mergeVariantKeys(source, variantDefault, path, schema, du) {
+  const out = { ...variantDefault };
   for (const key of Object.keys(source)) {
+    if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
     safeAssign(
       out,
       key,
-      mergeDeep(
-        safeOwnRead(out, key),
-        safeOwnRead(source, key),
-        [...path, key],
-        schema
-      )
+      mergeDeep(safeOwnRead(out, key), safeOwnRead(source, key), [...path, key], schema)
+    );
+  }
+  return out;
+}
+function mergeObjectKeys(target, source, path, schema) {
+  const out = isPlainRecord(target) ? { ...target } : {};
+  for (const key of Object.keys(source)) {
+    safeAssign(
+      out,
+      key,
+      mergeDeep(safeOwnRead(out, key), safeOwnRead(source, key), [...path, key], schema)
     );
   }
   return out;
 }
-
-const AttaformErrorCode = {
-  /** A required field is in the blank set — user hasn't supplied a value. */
-  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",
-  /**
-   * A walked form's `activate()` (async `defaultValues` factory) threw
-   * during `wizard.handleSubmit`'s path walk. Surfaced as a synthetic
-   * `ValidationError` at the form-level path (`[]`) so the wizard's
-   * aggregate error pipeline can carry the failure alongside ordinary
-   * validation errors. The raw factory error remains on
-   * `form.hydrateError` for retry UX.
-   */
-  ActivationFailed: "atta:activation-failed"
-};
 
 const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
@@ -2004,6 +2109,33 @@ function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
   target.element.focus({ preventScroll: true });
 }
 
+function captureUserCallSite() {
+  const raw = new Error().stack;
+  if (typeof raw !== "string") return void 0;
+  const lines = raw.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const frame = lines[i];
+    if (frame === void 0) continue;
+    if (/attaform[/-]forms?/i.test(frame)) continue;
+    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
+    const trimmed = frame.trim();
+    if (trimmed.length === 0) continue;
+    return shortenSourceFrame(trimmed);
+  }
+  return void 0;
+}
+function shortenSourceFrame(frame) {
+  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
+  if (match === null) return frame;
+  const [, urlOrPath, line] = match;
+  if (urlOrPath === void 0 || line === void 0) return frame;
+  let path = urlOrPath;
+  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
+  path = path.replace(/^_nuxt\//, "");
+  path = path.replace(/^\//, "");
+  return `(${path}:${line})`;
+}
+
 function extractSchemaFields(schema) {
   try {
     const root = schema.getDefaultAtPath([]);
@@ -2062,9 +2194,9 @@ function isLeafValue(value) {
   return true;
 }
 function isSlimPrimitiveValid(schema, store, path, value) {
-  return walk$1(schema, store, path, value);
+  return walk(schema, store, path, value);
 }
-function walk$1(schema, store, path, value) {
+function walk(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";
@@ -2074,13 +2206,13 @@ function walk$1(schema, store, path, value) {
   }
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      if (!walk$1(schema, store, [...path, i], value[i])) return false;
+      if (!walk(schema, store, [...path, i], value[i])) return false;
     }
     return true;
   }
   if (isPlainRecord(value)) {
     for (const key of Object.keys(value)) {
-      if (!walk$1(schema, store, [...path, key], value[key])) {
+      if (!walk(schema, store, [...path, key], value[key])) {
         return false;
       }
     }
@@ -2480,49 +2612,60 @@ function walkUnsetSentinels(values, schema) {
     walkUnspecified(rootSlim, [], paths);
     return { cleanedValues: void 0, paths };
   }
-  const cleaned = walk(values, [], schema, paths);
+  const cleaned = walkCore(values, [], schema, paths, true);
   return { cleanedValues: cleaned, paths };
 }
-function walk(input, segments, schema, paths) {
+function isOpaqueLeaf(value) {
+  return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || typeof value === "function";
+}
+function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
   if (isUnset(input)) {
     return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
-    const slim = schema.getDefaultAtPath(segments);
-    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") {
+    if (synthesizeSchemaKeys) {
+      const slim = schema.getDefaultAtPath(segments);
+      return walkUnspecified(slim, segments, paths);
+    }
     return input;
   }
+  if (input === null) return null;
+  if (isOpaqueLeaf(input)) return input;
   if (Array.isArray(input)) {
     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);
+      const walked = walkCore(input[i], [...segments, i], schema, paths, synthesizeSchemaKeys);
       out[i] = walked;
       if (walked !== input[i]) mutated = true;
     }
     return mutated ? out : input;
   }
   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);
+    const obj = input;
+    const inputKeys = Object.keys(obj);
+    let keys = inputKeys;
+    let mutated = false;
+    let inputKeysSet = null;
+    if (synthesizeSchemaKeys) {
+      inputKeysSet = new Set(inputKeys);
+      const allKeys = new Set(inputKeys);
+      const slim = schema.getDefaultAtPath(segments);
+      if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !isOpaqueLeaf(slim)) {
+        for (const k of Object.keys(slim)) allKeys.add(k);
+      }
+      keys = allKeys;
+      mutated = allKeys.size !== inputKeys.length;
     }
     const out = {};
-    let mutated = allKeys.size !== inputKeys.length;
-    for (const key of allKeys) {
-      const orig = input[key];
-      if (orig === void 0 && inputKeysSet.has(key)) {
+    for (const key of keys) {
+      const orig = obj[key];
+      if (synthesizeSchemaKeys && orig === void 0 && inputKeysSet?.has(key) === true) {
         safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
-      const walked = walk(orig, [...segments, key], schema, paths);
+      const walked = walkCore(orig, [...segments, key], schema, paths, synthesizeSchemaKeys);
       safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
@@ -2537,7 +2680,7 @@ function walkUnspecified(slim, segments, paths) {
     }
     return slim;
   }
-  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+  if (isOpaqueLeaf(slim)) {
     return slim;
   }
   if (Array.isArray(slim)) return slim;
@@ -2556,40 +2699,9 @@ function walkUnspecified(slim, segments, paths) {
 }
 function substituteUnsetSentinels(value, prefix, schema) {
   const paths = [];
-  const cleaned = substitute(value, [...prefix], schema, paths);
+  const cleaned = walkCore(value, [...prefix], schema, paths, false);
   return { cleanedValues: cleaned, paths };
 }
-function substitute(input, segments, schema, paths) {
-  if (isUnset(input)) {
-    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") {
-    return input;
-  }
-  if (Array.isArray(input)) {
-    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);
-      out[i] = walked;
-      if (walked !== input[i]) mutated = true;
-    }
-    return mutated ? out : input;
-  }
-  if (typeof input === "object") {
-    let mutated = false;
-    const out = {};
-    for (const key of Object.keys(input)) {
-      const orig = input[key];
-      const walked = substitute(orig, [...segments, key], schema, paths);
-      safeAssign(out, key, walked);
-      if (walked !== orig) mutated = true;
-    }
-    return mutated ? out : input;
-  }
-  return input;
-}
 function isPrimitiveOrEmpty(value) {
   if (value === null || value === void 0) return true;
   const t = typeof value;
@@ -2619,7 +2731,7 @@ function expandUnsetAt(segments, schema, paths) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
-  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+  if (isOpaqueLeaf(slim)) {
     paths.push(canonicalizePath(segments).key);
     return slim;
   }
@@ -2753,20 +2865,128 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
+  const reMarkBlanksAfterSubstitution = (paths) => {
+    for (const pathKey of paths) {
+      const blankSegments = segmentsForPathKey(pathKey);
+      if (blankSegments === null) continue;
+      state.setValueAtPath(
+        blankSegments,
+        state.getValueAtPath(blankSegments),
+        withInstanceMeta({ blank: true })
+      );
+    }
+  };
   const getFormMetaBase = () => {
-    const { base: rootBase } = buildContainerFieldStateBase(
+    let rollup;
+    const rootBase = () => rollup ?? (rollup = buildContainerFieldStateBase(
       state,
       ROOT_PATH,
       ROOT_PATH_KEY,
       formInstanceId
-    );
+    ).base);
     return {
-      ...rootBase,
+      // Rollup-derived (FieldStateBase) — the whole rollup builds once, on the
+      // first access of any of these.
+      get value() {
+        return rootBase().value;
+      },
+      get original() {
+        return rootBase().original;
+      },
+      get pristine() {
+        return rootBase().pristine;
+      },
+      get dirty() {
+        return rootBase().dirty;
+      },
+      get focused() {
+        return rootBase().focused;
+      },
+      get blurred() {
+        return rootBase().blurred;
+      },
+      get touched() {
+        return rootBase().touched;
+      },
+      get interacted() {
+        return rootBase().interacted;
+      },
+      get blurredAfterInteraction() {
+        return rootBase().blurredAfterInteraction;
+      },
+      get connected() {
+        return rootBase().connected;
+      },
+      get element() {
+        return rootBase().element;
+      },
+      get elements() {
+        return rootBase().elements;
+      },
+      get updatedAt() {
+        return rootBase().updatedAt;
+      },
+      get errors() {
+        return rootBase().errors;
+      },
+      get validating() {
+        return rootBase().validating;
+      },
+      get valid() {
+        return rootBase().valid;
+      },
+      get transforming() {
+        return rootBase().transforming;
+      },
+      get busy() {
+        return rootBase().busy;
+      },
+      get transformError() {
+        return rootBase().transformError;
+      },
+      get path() {
+        return rootBase().path;
+      },
+      get id() {
+        return rootBase().id;
+      },
+      get aria() {
+        return rootBase().aria;
+      },
+      get key() {
+        return rootBase().key;
+      },
+      get blank() {
+        return rootBase().blank;
+      },
+      get label() {
+        return rootBase().label;
+      },
+      get description() {
+        return rootBase().description;
+      },
+      get placeholder() {
+        return rootBase().placeholder;
+      },
+      get meta() {
+        return rootBase().meta;
+      },
+      get errorCount() {
+        return rootBase().errors.length;
+      },
+      // Form-level scalars — EAGER reads, tracked on every field-state eval.
+      // They are O(1) refs that never change on a keystroke, so tracking them
+      // per field costs nothing on the hot path. Kept eager (NOT lazy like the
+      // rollup) because behaviors beyond the predicate's own output depend on
+      // every field re-evaluating when they flip — most notably, the display
+      // engine is cleared on submit (revealing held spinners), and that
+      // imperative reset only becomes visible if `submitting` is a tracked dep
+      // of each field. Matches the pre-bust dependency set for these scalars
+      // exactly.
       submitting: state.submitting.value,
       submissionAttempts: state.submissionAttempts.value,
       departAttempts: state.departAttempts.value,
       submitError: state.submitError.value,
-      errorCount: rootBase.errors.length,
       submitted: state.submitted.value,
       instanceId: formInstanceId
     };
@@ -2801,24 +3021,21 @@ function buildFormApi(state, formInstanceId, options = {}) {
     const segments = canonicalizePath(pathInput).segments;
     return computed(() => getAtPath(state.form.value, segments));
   }
-  function setValueImpl(pathOrValue, maybeValue) {
-    if (arguments.length === 1) {
+  function setValueImpl(pathOrValue, maybeValue, maybeOptions) {
+    const argc = arguments.length;
+    const isPathForm = argc >= 2 && (typeof pathOrValue === "string" || Array.isArray(pathOrValue));
+    const options2 = isPathForm ? maybeOptions : argc >= 2 ? maybeValue : void 0;
+    const silent = options2?.silent === true;
+    const writeMeta = (extra) => withInstanceMeta(silent ? { ...extra, silent: true } : extra);
+    if (!isPathForm) {
       const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
       const walked2 = walkUnsetSentinels(
         next,
         state.schema
       );
-      const ok2 = state.setValueAtPath([], walked2.cleanedValues, withInstanceMeta());
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues, writeMeta());
       if (!ok2) return false;
-      for (const pathKey of walked2.paths) {
-        const blankSegments = segmentsForPathKey(pathKey);
-        if (blankSegments === null) continue;
-        state.setValueAtPath(
-          blankSegments,
-          state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
-        );
-      }
+      reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
     }
     const segments = canonicalizePath(pathOrValue).segments;
@@ -2830,7 +3047,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
         if (parentDU?.discriminatorKey === last) {
           const slimDefault = state.schema.getEmptyValueAtPath(segments);
           const blank = blankForKind(slimDefault);
-          return state.setValueAtPath(segments, blank, withInstanceMeta({ blank: true }));
+          return state.setValueAtPath(segments, blank, writeMeta({ blank: true }));
         }
       }
       const blankPaths = [];
@@ -2841,9 +3058,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       const segmentsKey = canonicalizePath(segments).key;
       if (blankPaths.length === 1 && blankPaths[0] === segmentsKey) {
-        return state.setValueAtPath(segments, expanded, withInstanceMeta({ blank: true }));
+        return state.setValueAtPath(segments, expanded, writeMeta({ blank: true }));
       }
-      const ok2 = state.setValueAtPath(segments, expanded, withInstanceMeta());
+      const ok2 = state.setValueAtPath(segments, expanded, writeMeta());
       if (!ok2) return false;
       for (const pathKey of blankPaths) {
         const blankSegments = segmentsForPathKey(pathKey);
@@ -2851,7 +3068,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.setValueAtPath(
           blankSegments,
           state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
+          writeMeta({ blank: true })
         );
       }
       return true;
@@ -2871,17 +3088,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       segments,
       state.schema
     );
-    const ok = state.setValueAtPath(segments, walked.cleanedValues, withInstanceMeta());
+    const ok = state.setValueAtPath(segments, walked.cleanedValues, writeMeta());
     if (!ok) return false;
-    for (const pathKey of walked.paths) {
-      const blankSegments = segmentsForPathKey(pathKey);
-      if (blankSegments === null) continue;
-      state.setValueAtPath(
-        blankSegments,
-        state.getValueAtPath(blankSegments),
-        withInstanceMeta({ blank: true })
-      );
-    }
+    reMarkBlanksAfterSubstitution(walked.paths);
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
@@ -3250,7 +3459,19 @@ function buildFormApi(state, formInstanceId, options = {}) {
     }
     return Object.freeze(out);
   }
-  return {
+  const formHandle = {
+    current: void 0
+  };
+  function onChangeImpl(a, b, c) {
+    const sourced = typeof b === "function";
+    const source = sourced ? a : void 0;
+    const handler = sourced ? b : a;
+    const options2 = sourced ? c : b;
+    const stop = state.registerOnChange(source, handler, options2, () => formHandle.current);
+    if (getCurrentScope() !== void 0) onScopeDispose(stop);
+    return stop;
+  }
+  const api = {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
     // reactive containers (`meta`, `history`, `blankPaths`) are exposed
@@ -3337,8 +3558,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
     get blankPaths() {
       void state.activate();
       return blankPathsView;
-    }
+    },
+    onChange: onChangeImpl
   };
+  formHandle.current = api;
+  return api;
 }
 
 const IDLE = Object.freeze({ display: "idle" });
@@ -3765,6 +3989,7 @@ function createArrayBookkeeping(deps) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -3792,6 +4017,7 @@ function createArrayBookkeeping(deps) {
     }));
     migrateSetSubtree(blankPaths, arrayPath, remap);
     migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateSetSubtree(authoredPaths, arrayPath, remap);
     migrateMapSubtree(fieldValidatingSince, arrayPath, remap, (since) => since);
     migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
     arrayIdentity.applyRemap(arrayPath, remap);
@@ -3835,7 +4061,7 @@ function createArrayBookkeeping(deps) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(key);
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -3847,6 +4073,170 @@ function createArrayBookkeeping(deps) {
   };
 }
 
+const NOOP_STOP = () => {
+};
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function isSuppressed(meta) {
+  return meta?.hydration === true || meta?.crossTab === true || meta?.silent === true;
+}
+function canonicalizeSourceList(raw) {
+  const list = typeof raw === "string" ? [raw] : raw;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of list) {
+    const { segments, key } = canonicalizePath(entry);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ segments, key, dotted: segmentsToDotted(segments) });
+  }
+  return out;
+}
+function makeResolver(source) {
+  if (source === void 0) {
+    const root = [{ segments: ROOT_PATH, key: ROOT_PATH_KEY, dotted: "" }];
+    return () => root;
+  }
+  if (typeof source !== "function" && !isRef(source)) {
+    const fixed = canonicalizeSourceList(source);
+    return () => fixed;
+  }
+  return () => canonicalizeSourceList(toValue(source));
+}
+function createOnChangeRegistry(deps) {
+  const handlers = /* @__PURE__ */ new Set();
+  function isCurrent(reg, key, token) {
+    return reg.runs.get(key)?.token === token;
+  }
+  function routeError(reg, error, source, changed, value, previous, attempt, token) {
+    if (reg.onError === void 0) {
+      if (__DEV__) {
+        console.error(
+          `[attaform] onChange handler threw for path '${source.dotted}' \u2014 error swallowed. Pass { onError } to handle it. Original error:`,
+          error
+        );
+      }
+      return;
+    }
+    const retry = () => {
+      if (!isCurrent(reg, source.key, token)) return;
+      runHandler(reg, source, changed, value, previous, attempt + 1);
+    };
+    const errCtx = {
+      path: source.dotted,
+      value,
+      attempt,
+      retry,
+      form: reg.getForm()
+    };
+    try {
+      reg.onError(error, errCtx);
+    } catch (err) {
+      if (__DEV__) console.error("[attaform] onChange onError threw:", err);
+    }
+  }
+  function runHandler(reg, source, changed, value, previous, attempt) {
+    const prior = reg.runs.get(source.key);
+    if (prior) prior.controller.abort();
+    const controller = new AbortController();
+    const token = ++reg.seq;
+    reg.runs.set(source.key, { token, controller });
+    const ctx = {
+      path: source.dotted,
+      previous,
+      signal: controller.signal,
+      attempt,
+      form: reg.getForm(),
+      changed
+    };
+    let result;
+    try {
+      result = reg.handler(value, ctx);
+    } catch (error) {
+      routeError(reg, error, source, changed, value, previous, attempt, token);
+      return;
+    }
+    if (isThenable(result)) {
+      result.then(void 0, (error) => {
+        if (isCurrent(reg, source.key, token)) {
+          routeError(reg, error, source, changed, value, previous, attempt, token);
+        }
+      });
+    }
+  }
+  function dispatch(patches, meta) {
+    if (handlers.size === 0 || isSuppressed(meta)) return;
+    for (const reg of handlers) {
+      let sources;
+      try {
+        sources = reg.resolve();
+      } catch (error) {
+        if (__DEV__) console.error("[attaform] onChange source getter threw:", error);
+        continue;
+      }
+      for (const source of sources) {
+        let changed;
+        for (const patch of patches) {
+          if (isPathPrefix(source.segments, patch.path) || isPathPrefix(patch.path, source.segments)) {
+            (changed ?? (changed = [])).push(segmentsToDotted(patch.path));
+          }
+        }
+        if (changed === void 0) continue;
+        const value = deps.getValueAtPath(source.segments);
+        const previous = reg.previous.has(source.key) ? reg.previous.get(source.key) : value;
+        reg.previous.set(source.key, value);
+        runHandler(reg, source, changed, value, previous, 0);
+      }
+    }
+  }
+  function register(source, handler, options, getForm) {
+    if (deps.ssr) return NOOP_STOP;
+    const reg = {
+      handler,
+      onError: options?.onError,
+      getForm,
+      resolve: makeResolver(source),
+      previous: /* @__PURE__ */ new Map(),
+      runs: /* @__PURE__ */ new Map(),
+      seq: 0
+    };
+    try {
+      for (const { key, segments } of reg.resolve()) {
+        reg.previous.set(key, deps.getValueAtPath(segments));
+      }
+    } catch (error) {
+      if (__DEV__) console.error("[attaform] onChange source getter threw at registration:", error);
+    }
+    handlers.add(reg);
+    let stopped = false;
+    return () => {
+      if (stopped) return;
+      stopped = true;
+      handlers.delete(reg);
+      for (const run of reg.runs.values()) run.controller.abort();
+      reg.runs.clear();
+      reg.previous.clear();
+    };
+  }
+  function dispose() {
+    for (const reg of handlers) {
+      for (const run of reg.runs.values()) run.controller.abort();
+      reg.runs.clear();
+      reg.previous.clear();
+    }
+    handlers.clear();
+  }
+  return {
+    get active() {
+      return handlers.size > 0;
+    },
+    register,
+    dispatch,
+    dispose
+  };
+}
+
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
@@ -3931,6 +4321,17 @@ function walkAuthoredFromConstraints(value, prefix, out) {
     }
   }
 }
+function freshElementIndices(op) {
+  switch (op.kind) {
+    case "insert":
+    case "replace-at":
+      return [op.index];
+    case "remove":
+    case "swap":
+    case "move":
+      return [];
+  }
+}
 function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out) {
   if (isPlainRecord(withDefaults) && isPlainRecord(withoutDefaults)) {
     const left = withDefaults;
@@ -3969,6 +4370,7 @@ function createFormStore(options) {
   const formChangeListeners = /* @__PURE__ */ new Set();
   const submitSuccessListeners = /* @__PURE__ */ new Set();
   const resetListeners = /* @__PURE__ */ new Set();
+  const onChangeRegistry = createOnChangeRegistry({ getValueAtPath, ssr });
   const persistOptIns = createPersistOptInRegistry();
   const noSyncPaths = /* @__PURE__ */ new Set();
   const noSyncPathCounts = /* @__PURE__ */ new Map();
@@ -4007,11 +4409,8 @@ function createFormStore(options) {
     if (constraints !== void 0) {
       walkAuthoredFromConstraints(constraints, [], authoredPaths);
     }
-    const slimResponse = schema.getDefaultValues({
-      useDefaultSchemaValues: false,
-      strict
-    });
-    walkAuthoredFromSchemaDiff(schemaWithDefaultsData, slimResponse.data, [], authoredPaths);
+    const slimBaseline = schema.getEmptyValueAtPath([]);
+    walkAuthoredFromSchemaDiff(schemaWithDefaultsData, slimBaseline, [], authoredPaths);
   }
   rebuildAuthoredPaths(defaultValues, schemaInitialData);
   function filterAuthoredErrors(errors) {
@@ -4030,7 +4429,7 @@ function createFormStore(options) {
   });
   const form = ref(stubbedInitialData);
   const arrayIdentity = createArrayIdentity((arraySegs) => {
-    const v = getAtPath(form.value, arraySegs);
+    const v = getAtPath(toRaw(form.value), arraySegs);
     return Array.isArray(v) ? v.length : 0;
   });
   function arrayElementKey(path) {
@@ -4073,14 +4472,7 @@ function createFormStore(options) {
       const segments = segmentsForPathKey(pathKey);
       if (segments === null) continue;
       if (!schema.isRequiredAtPath(segments)) continue;
-      result.set(pathKey, [
-        {
-          message: "No value supplied",
-          path: [...segments],
-          formKey,
-          code: AttaformErrorCode.NoValueSupplied
-        }
-      ]);
+      result.set(pathKey, [makeBlankRequiredError(segments, formKey)]);
     }
     return result;
   });
@@ -4320,6 +4712,7 @@ function createFormStore(options) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -4329,17 +4722,8 @@ function createFormStore(options) {
     touchFieldRecord,
     decFieldValidation
   });
-  function applyFormReplacement(next, meta) {
-    const prev = form.value;
-    if (Object.is(prev, next)) return;
+  function commitWritePatches(patches, meta) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const patches = [];
-    diffAndApply(prev, next, [], (patch) => {
-      patches.push(patch);
-    });
-    if (!applyChangedKeys(prev, next)) {
-      form.value = next;
-    }
     for (const patch of patches) {
       const { key } = canonicalizePath(patch.path);
       if (patch.kind === "added" && !originals.has(key)) {
@@ -4354,10 +4738,63 @@ function createFormStore(options) {
         console.error("[attaform] onFormChange threw:", err);
       }
     }
+    if (onChangeRegistry.active) onChangeRegistry.dispatch(patches, meta);
+  }
+  function applyFormReplacementWithPath(next, meta, arrayOpPath) {
+    const prev = form.value;
+    if (Object.is(prev, next)) return;
+    const patches = [];
+    diffAndApply(prev, next, [], (patch) => {
+      patches.push(patch);
+    });
+    if (!applyChangedKeys(prev, next, arrayOpPath, [])) {
+      form.value = next;
+    } else if (patches.some(
+      (p) => p.path.length > 0 && typeof p.path[0] === "string" && isShadowedKey(p.path[0])
+    )) {
+      triggerRef(form);
+    }
+    commitWritePatches(patches, meta);
+  }
+  function applyFormReplacement(next, meta) {
+    applyFormReplacementWithPath(next, meta, null);
+  }
+  function applyTargetedWrite(path, completedValue, meta) {
+    const result = tryInPlaceLeafWrite(form.value, path, completedValue);
+    if (!result.applied) {
+      applyFormReplacementWithPath(
+        setAtPathWithSchemaFill(form.value, schema, path, completedValue),
+        meta,
+        meta?.arrayOp !== void 0 ? path : null
+      );
+      return;
+    }
+    const patches = [];
+    diffAndApply(result.old, completedValue, path, (patch) => {
+      patches.push(patch);
+    });
+    commitWritePatches(patches, meta);
   }
   function setValueAtPath(path, value, meta) {
-    value = stripSymbolsDeep(value);
-    if (!isSlimPrimitiveValid(schema, form, path, value)) {
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        value[idx] = stripSymbolsDeep(value[idx]);
+      }
+    } else {
+      value = stripSymbolsDeep(value);
+    }
+    let slimOk = true;
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        if (!isSlimPrimitiveValid(schema, form, [...path, idx], value[idx])) {
+          slimOk = false;
+          break;
+        }
+      }
+    } else {
+      slimOk = isSlimPrimitiveValid(schema, form, path, value);
+    }
+    if (!slimOk) {
       return false;
     }
     if (path.length >= 2) {
@@ -4450,22 +4887,37 @@ function createFormStore(options) {
         }
       }
     }
+    const currentValue = getAtPath(form.value, path);
     const pathKey = canonicalizePath(path).key;
     if (meta?.blank === true) {
       blankPaths.add(pathKey);
     } else {
       if (blankPaths.has(pathKey)) blankPaths.delete(pathKey);
-      if (meta?.arrayOp === void 0) {
+      if (meta?.arrayOp === void 0 && (isPlainRecord(currentValue) || Array.isArray(currentValue))) {
         for (const existingKey of [...blankPaths]) {
           if (isPathKeyUnder(existingKey, path)) blankPaths.delete(existingKey);
         }
       }
     }
     const wasAuthoredBefore = authoredPaths.has(pathKey);
-    walkAuthoredFromConstraints(value, path, authoredPaths);
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      if (path.length > 0) authoredPaths.add(pathKey);
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        walkAuthoredFromConstraints(value[idx], [...path, idx], authoredPaths);
+      }
+    } else {
+      walkAuthoredFromConstraints(value, path, authoredPaths);
+    }
     const newlyAuthored = !wasAuthoredBefore && authoredPaths.has(pathKey);
-    const completedValue = mergeStructural(schema, path, value);
-    const currentValue = getAtPath(form.value, path);
+    let completedValue;
+    if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
+      for (const idx of freshElementIndices(meta.arrayOp)) {
+        value[idx] = mergeStructural(schema, [...path, idx], value[idx]);
+      }
+      completedValue = value;
+    } else {
+      completedValue = mergeStructural(schema, path, value);
+    }
     if (Object.is(currentValue, completedValue)) {
       if (newlyAuthored && schema.isPreprocessOrCoerceLeaf(path)) {
         const modeForAuthoringTransition = meta?.instance?.validateOn ?? fieldValidationMode;
@@ -4479,8 +4931,7 @@ function createFormStore(options) {
       return true;
     }
     const oldArrayLength = Array.isArray(currentValue) ? currentValue.length : 0;
-    const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
-    applyFormReplacement(nextForm, meta);
+    applyTargetedWrite(path, completedValue, meta);
     if (meta?.arrayOp !== void 0) {
       const remap = remapForOp(meta.arrayOp, oldArrayLength);
       arrayBookkeeping.migrateElementState(path, remap);
@@ -4563,7 +5014,7 @@ function createFormStore(options) {
         const prevValidation = fieldValidationState.get(parentKey2);
         if (prevValidation !== void 0) {
           if (prevValidation.timer !== null) clearTimeout(prevValidation.timer);
-          prevValidation.controller.abort();
+          prevValidation.aborted = true;
           fieldValidationState.delete(parentKey2);
         }
         appliedSync = true;
@@ -4587,15 +5038,19 @@ function createFormStore(options) {
     const prev = fieldValidationState.get(key);
     if (prev !== void 0) {
       if (prev.timer !== null) clearTimeout(prev.timer);
-      prev.controller.abort();
+      prev.aborted = true;
     }
-    const controller = new AbortController();
-    const fresh = { controller, timer: null, settled: false, released: false };
+    const fresh = {
+      aborted: false,
+      timer: null,
+      settled: false,
+      released: false
+    };
     fieldValidationState.set(key, fresh);
     const myEpoch = ++scheduleEpoch;
     const run = () => {
       fresh.timer = null;
-      if (controller.signal.aborted) return;
+      if (fresh.aborted) return;
       let activeIncremented = false;
       try {
         activeValidations.value += 1;
@@ -4612,7 +5067,7 @@ function createFormStore(options) {
       const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
       const scopeKey = subtreeScope ? canonicalizePath(path).key : ROOT_PATH_KEY;
       void Promise.resolve().then(() => schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
-        if (controller.signal.aborted) return;
+        if (fresh.aborted) return;
         if (myEpoch <= lastCommittedEpoch) return;
         lastCommittedEpoch = myEpoch;
         if (effectiveMode === "blur") {
@@ -4649,7 +5104,7 @@ function createFormStore(options) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(pkey);
       }
-      entry.controller.abort();
+      entry.aborted = true;
     }
     fieldValidationState.clear();
   }
@@ -4665,7 +5120,7 @@ function createFormStore(options) {
         decFieldValidation(key);
         entry.released = true;
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -4724,6 +5179,7 @@ function createFormStore(options) {
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
+    onChangeRegistry.dispose();
     persistOptIns.clear();
     noSyncPaths.clear();
     noSyncPathCounts.clear();
@@ -5029,7 +5485,7 @@ function createFormStore(options) {
     });
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
-    applyFormReplacement(next);
+    applyFormReplacement(next, { silent: true });
     arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -5275,6 +5731,7 @@ function createFormStore(options) {
     settleTransforms,
     scheduleFieldValidation,
     onFormChange,
+    registerOnChange: onChangeRegistry.register,
     onSubmitSuccess,
     onReset,
     emitSubmitSuccess,
@@ -5304,6 +5761,13 @@ function captureErrorEntries(map) {
   for (const [k, v] of map) out.push([k, [...v]]);
   return out;
 }
+function errorFieldsEqual(av, bvi) {
+  if (av === bvi) return true;
+  if (av.message !== bvi.message) return false;
+  if (av.code !== bvi.code) return false;
+  if (av.formKey !== bvi.formKey) return false;
+  return av.path === bvi.path || pathsEqual(av.path, bvi.path);
+}
 function errorsEqual(a, b) {
   if (a.length !== b.length) return false;
   const bMap = /* @__PURE__ */ new Map();
@@ -5313,18 +5777,7 @@ function errorsEqual(a, b) {
     if (bv === void 0) return false;
     if (v.length !== bv.length) return false;
     for (let i = 0; i < v.length; i++) {
-      const av = v[i];
-      const bvi = bv[i];
-      if (av === bvi) continue;
-      if (av.message !== bvi.message) return false;
-      if (av.code !== bvi.code) return false;
-      if (av.formKey !== bvi.formKey) return false;
-      if (av.path !== bvi.path) {
-        if (av.path.length !== bvi.path.length) return false;
-        for (let j = 0; j < av.path.length; j++) {
-          if (av.path[j] !== bvi.path[j]) return false;
-        }
-      }
+      if (!errorFieldsEqual(v[i], bv[i])) return false;
     }
   }
   return true;
@@ -5692,11 +6145,16 @@ function useAbstractForm(configuration, options) {
   if (merged.autoAria !== void 0) {
     apiOptions.autoAria = merged.autoAria;
   }
-  return buildFormApi(
-    state,
-    formInstanceId,
-    apiOptions
-  );
+  const api = buildFormApi(state, formInstanceId, apiOptions);
+  const onChangeConfig = configuration.onChange;
+  if (onChangeConfig !== void 0) {
+    const handler = typeof onChangeConfig === "function" ? onChangeConfig : onChangeConfig.handler;
+    const onError = typeof onChangeConfig === "function" ? void 0 : onChangeConfig.onError;
+    const options2 = onError === void 0 ? void 0 : { onError };
+    const stop = state.registerOnChange(void 0, handler, options2, () => api);
+    if (getCurrentScope() !== void 0) onScopeDispose(stop);
+  }
+  return api;
 }
 function mergeWithDefaults(defaults, configuration) {
   const strict = configuration.strict ?? defaults.strict;
@@ -5906,6 +6364,99 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
+const warnedNoParentRV = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+let warnedOutsideSetup = false;
+function makeRegisterValueProxy(capturedRegisterValue) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "__v_isRef") return true;
+      if (prop === "value") return capturedRegisterValue.value;
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return void 0;
+      return Reflect.get(v, prop);
+    },
+    has(_target, prop) {
+      if (prop === "__v_isRef" || prop === "value") return true;
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return false;
+      return Reflect.has(v, prop);
+    },
+    ownKeys(_target) {
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return [];
+      return Reflect.ownKeys(v);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const v = capturedRegisterValue.value;
+      if (v === void 0) return void 0;
+      const desc = Reflect.getOwnPropertyDescriptor(v, prop);
+      if (desc !== void 0) {
+        desc.configurable = true;
+      }
+      return desc;
+    }
+  });
+}
+function useRegister() {
+  const instance = getCurrentInstance();
+  if (instance === null) {
+    warnOutsideSetup();
+    return makeRegisterValueProxy(shallowRef(void 0));
+  }
+  ensureAttaformInstalled(instance.appContext.app);
+  const capturedRegisterValue = shallowRef(void 0);
+  const refreshAndStripBridgeAttrs = () => {
+    const rawAttrs = instance.attrs;
+    if ("registerValue" in rawAttrs) {
+      capturedRegisterValue.value = rawAttrs["registerValue"];
+      delete rawAttrs["registerValue"];
+    } 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;
+            break;
+          }
+        }
+      }
+    }
+    if ("value" in rawAttrs) delete rawAttrs["value"];
+  };
+  refreshAndStripBridgeAttrs();
+  onBeforeMount(refreshAndStripBridgeAttrs);
+  onBeforeUpdate(refreshAndStripBridgeAttrs);
+  onMounted(() => {
+    const el = instance.vnode.el;
+    if (el !== null && el !== void 0 && typeof el === "object") {
+      el[REGISTER_OWNER_MARKER] = true;
+    }
+    if (capturedRegisterValue.value === void 0) {
+      warnNoParentRV(instance);
+    }
+  });
+  return makeRegisterValueProxy(capturedRegisterValue);
+}
+function warnOutsideSetup() {
+  if (!__DEV__) return;
+  if (warnedOutsideSetup) return;
+  warnedOutsideSetup = true;
+  const frame = captureUserCallSite();
+  console.warn(
+    `[attaform] useRegister() called outside a component setup; returning an unbound RegisterValue proxy. Fix: call it inside <script setup> or a setup() function \u2014 not from an event handler or async callback.` + (frame !== void 0 ? ` ${frame}` : "")
+  );
+}
+function warnNoParentRV(instance) {
+  if (!__DEV__ || warnedNoParentRV === null) return;
+  if (warnedNoParentRV.has(instance)) return;
+  warnedNoParentRV.add(instance);
+  const frame = captureUserCallSite();
+  console.warn(
+    `[attaform] useRegister: no parent registerValue prop; RegisterValue fields will read as undefined. Pass v-register on the parent: \`<YourComponent v-register="form.register('field')" />\`.` + (frame !== void 0 ? ` ${frame}` : "")
+  );
+}
+
 const LAZY_BRAND = Symbol.for("attaform/wizard-lazy");
 function lazy(resolve) {
   return { [LAZY_BRAND]: true, resolve };
@@ -6969,5 +7520,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, useAbstractForm as B, useWizard as C, DEFAULT_PERSISTENCE_DEBOUNCE_MS as D, PERSISTENCE_MODULE_KEY as P, DEFAULT_TIMINGS as a, applyPatchesForward as b, cleanupOrphanKeys as c, defaultCoercionRules as d, defaultDisplayState as e, defineCoercion as f, deleteAtPath as g, diffAndApply as h, getAtPath as i, humanize as j, injectForm as k, injectWizard as l, isPlainRecord as m, isUnset as n, lazy as o, makeDefaultDisplayState as p, mergeSparseHydration as q, normalizeNumericOption as r, normalizePersistConfig as s, resolveStorageKeyBase as t, safeAssign as u, safeOwnRead as v, setAtPath as w, slimKindOf as x, structuralSnapshot as y, unset as z };
-//# sourceMappingURL=attaform.DR6RmxWZ.mjs.map
+export { AttaformErrorCode as A, deleteAtPath as B, safeOwnRead as C, DEFAULT_TIMINGS as D, humanize as E, PERSISTENCE_MODULE_KEY as P, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, isPlainRecord as e, safeAssign as f, diffAndApply as g, slimKindOf as h, injectForm as i, applyPatchesForward as j, normalizeNumericOption as k, lazy as l, defaultCoercionRules as m, normalizePersistConfig as n, defaultDisplayState as o, defineCoercion as p, makeDefaultDisplayState as q, useAbstractForm as r, structuralSnapshot as s, getAtPath as t, unset as u, setAtPath as v, resolveStorageKeyBase as w, DEFAULT_PERSISTENCE_DEBOUNCE_MS as x, cleanupOrphanKeys as y, mergeSparseHydration as z };
+//# sourceMappingURL=attaform.CsB-iKbU.mjs.map