attaform 0.21.1 → 0.22.0

package/dist/shared/{attaform.ClXwitZj.cjs → attaform.CjMcwV7W.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.D32WwKk6.cjs');
+const paths = require('./attaform.01iKS_lz.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -36,7 +36,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;
@@ -71,7 +71,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);
@@ -100,6 +100,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);
 }
@@ -162,68 +187,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;
@@ -306,55 +343,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 });
@@ -378,7 +387,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);
@@ -396,11 +446,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 || paths.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 (paths.isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(curEl, nextEl, arrayOpPath, childPath)) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
     }
   } else {
     const t = target;
@@ -412,7 +478,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;
@@ -524,6 +597,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;
@@ -625,13 +742,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);
@@ -646,9 +769,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,
@@ -697,9 +818,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;
@@ -718,12 +862,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 (!paths.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 } = paths.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;
     }
@@ -734,7 +882,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) {
@@ -751,7 +899,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;
@@ -785,9 +933,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,
@@ -1380,7 +1526,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);
@@ -1570,20 +1716,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,
@@ -1667,87 +1813,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 = paths.__DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 function buildProcessForm(state, formInstanceId, options = {}) {
@@ -2006,6 +2111,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([]);
@@ -2064,9 +2196,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";
@@ -2076,13 +2208,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;
       }
     }
@@ -2370,7 +2502,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       throw new paths.AnonPersistError({
         cause: "register-without-config",
         schemaFields: extractSchemaFields(state.schema),
-        callSite: paths.captureUserCallSite()
+        callSite: captureUserCallSite()
       });
     }
     const { aria } = computeFieldIdentity(formInstanceId, state.formKey, pathKey);
@@ -2482,49 +2614,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;
     }
@@ -2539,7 +2682,7 @@ function walkUnspecified(slim, segments, paths$1) {
     }
     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;
@@ -2558,40 +2701,9 @@ function walkUnspecified(slim, segments, paths$1) {
 }
 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;
@@ -2621,7 +2733,7 @@ function expandUnsetAt(segments, schema, paths$1) {
     paths$1.push(paths.canonicalizePath(segments).key);
     return slim;
   }
-  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+  if (isOpaqueLeaf(slim)) {
     paths$1.push(paths.canonicalizePath(segments).key);
     return slim;
   }
@@ -2755,20 +2867,128 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (instanceMeta === void 0) return meta;
     return meta === void 0 ? { instance: instanceMeta } : { ...meta, instance: instanceMeta };
   };
+  const reMarkBlanksAfterSubstitution = (paths$1) => {
+    for (const pathKey of paths$1) {
+      const blankSegments = paths.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,
       paths.ROOT_PATH,
       paths.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
     };
@@ -2803,24 +3023,21 @@ function buildFormApi(state, formInstanceId, options = {}) {
     const segments = paths.canonicalizePath(pathInput).segments;
     return vue.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 = paths.segmentsForPathKey(pathKey);
-        if (blankSegments === null) continue;
-        state.setValueAtPath(
-          blankSegments,
-          state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
-        );
-      }
+      reMarkBlanksAfterSubstitution(walked2.paths);
       return true;
     }
     const segments = paths.canonicalizePath(pathOrValue).segments;
@@ -2832,7 +3049,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 = [];
@@ -2843,9 +3060,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       const segmentsKey = paths.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 = paths.segmentsForPathKey(pathKey);
@@ -2853,7 +3070,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
         state.setValueAtPath(
           blankSegments,
           state.getValueAtPath(blankSegments),
-          withInstanceMeta({ blank: true })
+          writeMeta({ blank: true })
         );
       }
       return true;
@@ -2873,17 +3090,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 = paths.segmentsForPathKey(pathKey);
-      if (blankSegments === null) continue;
-      state.setValueAtPath(
-        blankSegments,
-        state.getValueAtPath(blankSegments),
-        withInstanceMeta({ blank: true })
-      );
-    }
+    reMarkBlanksAfterSubstitution(walked.paths);
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
@@ -3252,7 +3461,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 (vue.getCurrentScope() !== void 0) vue.onScopeDispose(stop);
+    return stop;
+  }
+  const api = {
     handleSubmit: gated(handleSubmit),
     // Callable readonly Proxies (`values`, `fields`, `errors`) and the
     // reactive containers (`meta`, `history`, `blankPaths`) are exposed
@@ -3339,8 +3560,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" });
@@ -3767,6 +3991,7 @@ function createArrayBookkeeping(deps) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -3794,6 +4019,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);
@@ -3837,7 +4063,7 @@ function createArrayBookkeeping(deps) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(key);
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -3849,6 +4075,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 } = paths.canonicalizePath(entry);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ segments, key, dotted: paths.segmentsToDotted(segments) });
+  }
+  return out;
+}
+function makeResolver(source) {
+  if (source === void 0) {
+    const root = [{ segments: paths.ROOT_PATH, key: paths.ROOT_PATH_KEY, dotted: "" }];
+    return () => root;
+  }
+  if (typeof source !== "function" && !vue.isRef(source)) {
+    const fixed = canonicalizeSourceList(source);
+    return () => fixed;
+  }
+  return () => canonicalizeSourceList(vue.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 (paths.__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 (paths.__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 (paths.__DEV__) console.error("[attaform] onChange source getter threw:", error);
+        continue;
+      }
+      for (const source of sources) {
+        let changed;
+        for (const patch of patches) {
+          if (paths.isPathPrefix(source.segments, patch.path) || paths.isPathPrefix(patch.path, source.segments)) {
+            (changed ?? (changed = [])).push(paths.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 (paths.__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;
@@ -3933,6 +4323,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;
@@ -3971,6 +4372,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 = paths.createPersistOptInRegistry();
   const noSyncPaths = /* @__PURE__ */ new Set();
   const noSyncPathCounts = /* @__PURE__ */ new Map();
@@ -4009,11 +4411,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) {
@@ -4032,7 +4431,7 @@ function createFormStore(options) {
   });
   const form = vue.ref(stubbedInitialData);
   const arrayIdentity = createArrayIdentity((arraySegs) => {
-    const v = getAtPath(form.value, arraySegs);
+    const v = getAtPath(vue.toRaw(form.value), arraySegs);
     return Array.isArray(v) ? v.length : 0;
   });
   function arrayElementKey(path) {
@@ -4075,14 +4474,7 @@ function createFormStore(options) {
       const segments = paths.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;
   });
@@ -4322,6 +4714,7 @@ function createFormStore(options) {
     originals,
     blankPaths,
     originalBlankPaths,
+    authoredPaths,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -4331,17 +4724,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 } = paths.canonicalizePath(patch.path);
       if (patch.kind === "added" && !originals.has(key)) {
@@ -4356,10 +4740,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])
+    )) {
+      vue.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) {
@@ -4452,22 +4889,37 @@ function createFormStore(options) {
         }
       }
     }
+    const currentValue = getAtPath(form.value, path);
     const pathKey = paths.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;
@@ -4481,8 +4933,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);
@@ -4565,7 +5016,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;
@@ -4589,15 +5040,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;
@@ -4614,7 +5069,7 @@ function createFormStore(options) {
       const dataAtScope = subtreeScope ? getAtPath(form.value, path) : form.value;
       const scopeKey = subtreeScope ? paths.canonicalizePath(path).key : paths.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") {
@@ -4651,7 +5106,7 @@ function createFormStore(options) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(pkey);
       }
-      entry.controller.abort();
+      entry.aborted = true;
     }
     fieldValidationState.clear();
   }
@@ -4667,7 +5122,7 @@ function createFormStore(options) {
         decFieldValidation(key);
         entry.released = true;
       }
-      entry.controller.abort();
+      entry.aborted = true;
       fieldValidationState.delete(key);
     }
   }
@@ -4726,6 +5181,7 @@ function createFormStore(options) {
     formChangeListeners.clear();
     submitSuccessListeners.clear();
     resetListeners.clear();
+    onChangeRegistry.dispose();
     persistOptIns.clear();
     noSyncPaths.clear();
     noSyncPathCounts.clear();
@@ -5031,7 +5487,7 @@ function createFormStore(options) {
     });
     const next = resetResponse.data;
     rebuildAuthoredPaths(resetSource, next);
-    applyFormReplacement(next);
+    applyFormReplacement(next, { silent: true });
     arrayIdentity.rebaselineAll();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
@@ -5277,6 +5733,7 @@ function createFormStore(options) {
     settleTransforms,
     scheduleFieldValidation,
     onFormChange,
+    registerOnChange: onChangeRegistry.register,
     onSubmitSuccess,
     onReset,
     emitSubmitSuccess,
@@ -5306,6 +5763,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 || paths.pathsEqual(av.path, bvi.path);
+}
 function errorsEqual(a, b) {
   if (a.length !== b.length) return false;
   const bMap = /* @__PURE__ */ new Map();
@@ -5315,18 +5779,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;
@@ -5540,7 +5993,7 @@ function useAbstractForm(configuration, options) {
     throw new paths.AnonPersistError({
       cause: "no-key",
       schemaFields: extractSchemaFields(resolvedSchema),
-      callSite: paths.captureUserCallSite()
+      callSite: captureUserCallSite()
     });
   }
   const existing = registry.forms.get(key);
@@ -5694,11 +6147,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 (vue.getCurrentScope() !== void 0) vue.onScopeDispose(stop);
+  }
+  return api;
 }
 function mergeWithDefaults(defaults, configuration) {
   const strict = configuration.strict ?? defaults.strict;
@@ -5789,7 +6247,7 @@ function recordAmbientProvide(ssr) {
   if (instance === null) return;
   const instanceKey = instance;
   const entry = {
-    source: paths.captureUserCallSite()
+    source: captureUserCallSite()
   };
   const existing = ambientProvideHistory.get(instanceKey);
   if (existing === void 0) {
@@ -5828,7 +6286,7 @@ function enforceAnonPersistRule(formKey, ssr) {
   if (paths.__DEV__)
     throw new paths.AnonPersistError({
       cause: "no-key",
-      callSite: paths.captureUserCallSite()
+      callSite: captureUserCallSite()
     });
   if (!ssr && !warnedAnonPersistKeys.has(formKey)) {
     warnedAnonPersistKeys.add(formKey);
@@ -5885,7 +6343,7 @@ function resolveState(key, registry) {
 }
 function warnMiss$1(detail, ssr) {
   if (!paths.__DEV__ || ssr) return;
-  const frame = paths.captureUserCallSite();
+  const frame = captureUserCallSite();
   console.warn(
     `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
   );
@@ -5908,6 +6366,99 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
+const warnedNoParentRV = paths.__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 = vue.getCurrentInstance();
+  if (instance === null) {
+    warnOutsideSetup();
+    return makeRegisterValueProxy(vue.shallowRef(void 0));
+  }
+  paths.ensureAttaformInstalled(instance.appContext.app);
+  const capturedRegisterValue = vue.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?.[paths.V_REGISTER_MARKER];
+          if (marked === true) {
+            capturedRegisterValue.value = dir.value;
+            break;
+          }
+        }
+      }
+    }
+    if ("value" in rawAttrs) delete rawAttrs["value"];
+  };
+  refreshAndStripBridgeAttrs();
+  vue.onBeforeMount(refreshAndStripBridgeAttrs);
+  vue.onBeforeUpdate(refreshAndStripBridgeAttrs);
+  vue.onMounted(() => {
+    const el = instance.vnode.el;
+    if (el !== null && el !== void 0 && typeof el === "object") {
+      el[paths.REGISTER_OWNER_MARKER] = true;
+    }
+    if (capturedRegisterValue.value === void 0) {
+      warnNoParentRV(instance);
+    }
+  });
+  return makeRegisterValueProxy(capturedRegisterValue);
+}
+function warnOutsideSetup() {
+  if (!paths.__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 (!paths.__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 };
@@ -6892,7 +7443,7 @@ function recordAmbientWizardProvide(ssr) {
   if (instance === null) return;
   const instanceKey = instance;
   const entry = {
-    source: paths.captureUserCallSite()
+    source: captureUserCallSite()
   };
   const existing = ambientWizardProvideHistory.get(instanceKey);
   if (existing === void 0) {
@@ -6947,7 +7498,7 @@ function availableKeysHint(wizards) {
 }
 function warnMiss(detail, ssr, hint) {
   if (!paths.__DEV__ || ssr) return;
-  const frame = paths.captureUserCallSite();
+  const frame = captureUserCallSite();
   const parts = [`[attaform] injectWizard: ${detail}. Returning null.`];
   if (hint !== void 0) parts.push(hint);
   if (frame !== void 0) parts.push(frame);
@@ -7001,5 +7552,6 @@ exports.slimKindOf = slimKindOf;
 exports.structuralSnapshot = structuralSnapshot;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
+exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.ClXwitZj.cjs.map
+//# sourceMappingURL=attaform.CjMcwV7W.cjs.map