attaform 0.30.1 → 0.31.1

package/dist/dev/shared/{attaform-dev.DxHdkkPG.mjs → attaform-dev.3uTCYwy8.mjs}

@@ -1,8 +1,9 @@
-import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope } from 'vue';
-import { A as ANONYMOUS_FORM_KEY_PREFIX, i as isShadowedKey, d as safeOwnHas, a as safeOwnRead, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, c as callConsumerFn, t as reportConsumerThrow, u as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform-dev.CZz4GYZ6.mjs';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.Chm4D6SJ.mjs';
-import { R as REGISTER_OWNER_MARKER, d as armDomBinding, V as V_REGISTER_MARKER } from './attaform-dev.BMQ3GcgD.mjs';
-import { i as isPathPrefix, e as canonicalizePath, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, s as segmentsForPathKey, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform-dev.zlvDr0WB.mjs';
+import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, onBeforeMount, onBeforeUpdate, onMounted } from 'vue';
+import { A as ANONYMOUS_FORM_KEY_PREFIX, d as diffAndApply, i as isBarePatch, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, a as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, b as isDescendable, c as applyChangedKeys, R as RESERVED_KEY_PREFIX, e as DEFAULT_MAX_RECURSION_DEPTH, f as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform-dev.n6n00owJ.mjs';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform-dev.Bu6wgrA5.mjs';
+import { R as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, d as armDomBinding, r as recordInheritedModifiers, w as withInheritedModifiers } from './attaform-dev.Cbx0AiQF.mjs';
+import { e as canonicalizePath, i as isPathPrefix, f as pathsEqual, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, s as segmentsForPathKey, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform-dev.04aupFBW.mjs';
+import { i as isShadowedKey, e as safeOwnHas, a as safeOwnRead, f as consumerHas, g as spreadConsumerRecord, h as copyConsumerArray, r as readConsumerIndex, s as safeAssign, c as consumerKeys, b as readConsumerProp, d as callConsumerFn, j as consumerSymbolKeys, k as reportConsumerThrow } from './attaform-dev.CwYTWyPX.mjs';
 
 const AttaformErrorCode = {
   /** A required field is in the blank set: no value was supplied. */
@@ -141,7 +142,7 @@ function hashStableString(input, seed = 0) {
 const ANON_STEM = "atta";
 function readableFormKeyStem(formKey) {
   if (formKey === "" || formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return ANON_STEM;
-  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|(?<!-)-+$/g, "");
+  const sanitized = formKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|([^-])-+$/g, "$1");
   return sanitized === "" ? ANON_STEM : sanitized;
 }
 function fieldIdToken(formInstanceId, pathKey) {
@@ -531,7 +532,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
   const value = state.getValueAtPath(segments);
   const original = state.originals.get(key)?.value;
   const pristine = state.isPristineAtPathByKey(key, segments);
-  const cell = state.errorCells.get(key);
+  const cell = state.errorCells().get(key);
   const schemaForKey = cell !== void 0 && cell.schema.length > 0 ? cell.schema : void 0;
   const blankForKey = state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments) ? [makeBlankRequiredError(segments)] : void 0;
   const userForKey = cell !== void 0 && cell.user.length > 0 ? cell.user : void 0;
@@ -645,6 +646,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   let asyncPending = false;
   const submissionAttempts = state.submissionAttempts.value;
   const blurredLeafSegments = [];
+  const errorsByKey = errorBucketsAt(state, segments, key);
   const descendantLeaves = [];
   visitActiveLeafPaths(value, segments, (leafSegments) => {
     const { key: leafKey } = keyForSegments(leafSegments);
@@ -654,6 +656,8 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   });
   for (const { key: leafKey, segments: leafSeg } of descendantLeaves) {
     const leafRecord = state.fields.get(leafKey);
+    const leafErrors = errorsByKey.get(leafKey);
+    if (leafErrors !== void 0) leafErrors.walked = true;
     if (!state.isPristineAtPathByKey(leafKey, leafSeg)) {
       pristine = false;
       dirty = true;
@@ -688,22 +692,28 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       if (updatedAt === null || ts > updatedAt) updatedAt = ts;
     }
   }
-  if (!dirty && state.hasStructuralChangeUnder(segments)) {
+  if (!dirty && !(Array.isArray(value) || isPlainRecord(value)) && !state.isPristineAtPathByKey(key, segments)) {
     pristine = false;
     dirty = true;
   }
-  if (!dirty && state.hasRemovedSubtreeUnder(segments)) {
+  if (!dirty && state.hasStructuralChangeUnder(segments, key)) {
     pristine = false;
     dirty = true;
   }
-  const errors = aggregateErrorsAt(state, segments, key);
-  const revealedDescendantError = errors.length > 0 && errors.some((e) => {
-    const ePath = e.path;
-    if (ePath.length === segments.length && ePath.every((s, i) => s === segments[i])) return false;
-    if (submissionAttempts > 0) return true;
-    if (ePath.length === 1 && ePath[0] === "") return blurredAfterInteraction;
-    return blurredLeafSegments.some((s) => isPathPrefix(ePath, s));
-  });
+  if (!dirty && state.hasRemovedSubtreeUnder(segments, key)) {
+    pristine = false;
+    dirty = true;
+  }
+  const errorBuckets = sortErrorBuckets(errorsByKey);
+  const errors = flattenErrorBuckets(errorBuckets);
+  const revealedDescendantError = errors.length > 0 && descendantErrorRevealed(
+    state,
+    segments,
+    errorBuckets,
+    submissionAttempts,
+    blurredAfterInteraction,
+    blurredLeafSegments
+  );
   if (!asyncPending && state.pathHasAsyncValidationByKey(key, segments)) asyncPending = true;
   if ((state.fieldValidationCounts.get(key) ?? 0) > 0) {
     validating = true;
@@ -725,6 +735,8 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     if (ownRecord.interacted === true) interacted = true;
     if (ownRecord.blurredAfterInteraction === true) blurredAfterInteraction = true;
     if (ownRecord.connected === true) connected = true;
+    const ts = ownRecord.updatedAt;
+    if (ts !== null && (updatedAt === null || ts > updatedAt)) updatedAt = ts;
   }
   const ownTransformError = state.transformErrors.get(key) ?? null;
   const gated = asyncPending && !state.firstValidationDone.value;
@@ -816,11 +828,43 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     firstOwnError
   };
 }
+function descendantErrorRevealed(state, segments, buckets, submissionAttempts, blurredAfterInteraction, blurredLeafSegments) {
+  for (const bucket of buckets) {
+    let ownHistory;
+    for (const e of bucket.errors) {
+      const ePath = e.path;
+      if (pathsEqual(ePath, segments)) continue;
+      if (submissionAttempts > 0) return true;
+      if (ePath.length === 1 && ePath[0] === "") {
+        if (blurredAfterInteraction) return true;
+        continue;
+      }
+      for (const leaf of blurredLeafSegments) if (isPathPrefix(ePath, leaf)) return true;
+      if (bucket.walked) continue;
+      ownHistory ?? (ownHistory = state.fields.get(bucket.key)?.blurredAfterInteraction === true);
+      if (ownHistory) return true;
+    }
+  }
+  return false;
+}
 function aggregateErrorsAt(state, prefix, prefixKey) {
+  return flattenErrorBuckets(sortErrorBuckets(errorBucketsAt(state, prefix, prefixKey)));
+}
+const NO_ERROR_BUCKETS = /* @__PURE__ */ new Map();
+function sortErrorBuckets(buckets) {
+  if (buckets.size <= 1) return [...buckets.values()];
+  return [...buckets.values()].sort((a, b) => a.ordinal - b.ordinal);
+}
+function flattenErrorBuckets(buckets) {
+  if (buckets.length === 0) return [];
+  if (buckets.length === 1) return buckets[0]?.errors ?? [];
+  return buckets.flatMap((bucket) => bucket.errors);
+}
+function errorBucketsAt(state, prefix, prefixKey) {
   const candidates = state.errorWindowAt(prefix, prefixKey);
-  if (candidates.length === 0) return [];
+  if (candidates.length === 0) return NO_ERROR_BUCKETS;
   const formValue = state.form.value;
-  const cells = state.errorCells;
+  const cells = state.errorCells();
   const buckets = /* @__PURE__ */ new Map();
   for (const { key, segments } of candidates) {
     if (!isPathPrefix(prefix, segments)) continue;
@@ -831,19 +875,16 @@ function aggregateErrorsAt(state, prefix, prefixKey) {
     const userList = cell?.user;
     const total = (schemaList?.length ?? 0) + (blankList?.length ?? 0) + (userList?.length ?? 0);
     if (total === 0) continue;
-    const ordinal = state.ensurePathOrdinal(key);
-    let bucket = buckets.get(ordinal);
+    let bucket = buckets.get(key);
     if (bucket === void 0) {
-      bucket = [];
-      buckets.set(ordinal, bucket);
+      bucket = { key, ordinal: state.ensurePathOrdinal(key), errors: [], walked: false };
+      buckets.set(key, bucket);
     }
-    if (schemaList !== void 0) bucket.push(...schemaList);
-    if (blankList !== void 0) bucket.push(...blankList);
-    if (userList !== void 0) bucket.push(...userList);
+    if (schemaList !== void 0) bucket.errors.push(...schemaList);
+    if (blankList !== void 0) bucket.errors.push(...blankList);
+    if (userList !== void 0) bucket.errors.push(...userList);
   }
-  if (buckets.size === 0) return [];
-  if (buckets.size === 1) return [...buckets.values()][0];
-  return [...buckets.entries()].sort(([a], [b]) => a - b).flatMap(([, errs]) => errs);
+  return buckets;
 }
 const EMPTY_ELEMENTS = Object.freeze([]);
 
@@ -875,7 +916,7 @@ function liveContainerHasKey(state, segments, key) {
     return Number.isInteger(index) && index >= 0 && String(index) === key && value.has(index);
   }
   if (value instanceof Set) return false;
-  return Object.hasOwn(value, key);
+  return safeOwnHas(value, key);
 }
 function isArrayPath(state, segments) {
   if (segments.length === 0) return false;
@@ -1102,7 +1143,7 @@ function buildErrorsSurface(state, sweep) {
   });
 }
 function collectErrorsAt(state, key, segments, active, into) {
-  const cell = state.errorCells.get(key);
+  const cell = state.errorCells().get(key);
   if (active) {
     if (cell !== void 0) into.push(...cell.schema);
     if (state.blankPaths.has(key) && state.schema.isRequiredAtPath(segments)) {
@@ -1542,7 +1583,7 @@ function deleteKeysAtIndices(keys, del, arrayPath, indices) {
     del(hit.key);
   }
 }
-function createArrayIdentity(getArrayLength) {
+function createArrayIdentity(getArrayLength, onChange) {
   const tokens = /* @__PURE__ */ new Map();
   const baselines = /* @__PURE__ */ new Map();
   let counter = 0;
@@ -1554,7 +1595,13 @@ function createArrayIdentity(getArrayLength) {
       ids = [];
       tokens.set(arrayKey, ids);
     }
-    while (ids.length < expectedLen) ids.push(allocate());
+    if (ids.length < expectedLen) {
+      const baseline = baselines.get(arrayKey);
+      while (ids.length < expectedLen) {
+        const anchored = baseline?.[ids.length];
+        ids.push(anchored !== void 0 && !ids.includes(anchored) ? anchored : allocate());
+      }
+    }
     if (ids.length > expectedLen) ids.length = expectedLen;
     if (firstTrack) baselines.set(arrayKey, [...ids]);
     return ids;
@@ -1580,15 +1627,39 @@ function createArrayIdentity(getArrayLength) {
       const arrayKey = canonicalizePath(arraySegs).key;
       const ids = ensure(arrayKey, remap.oldLen);
       tokens.set(arrayKey, permuteList(ids, remap, allocate));
+      onChange([arraySegs]);
     },
     applyRemap(arrayPath, remap) {
       if (remap.moved.size === 0 && remap.vacated.size === 0 && remap.fresh.size === 0) return;
-      migrateMapSubtree(tokens, arrayPath, remap, (value) => value);
+      const moved = [];
+      for (const hit of collectKeysAtIndices(tokens.keys(), arrayPath, remapAffects(remap))) {
+        moved.push(hit.segments);
+      }
+      migrateMapSubtree(tokens, arrayPath, remap, (value, segments) => {
+        moved.push(segments);
+        return value;
+      });
       migrateMapSubtree(baselines, arrayPath, remap, (value) => value);
+      if (moved.length > 0) onChange(moved);
     },
     realign(arraySegs) {
       ensure(canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
     },
+    realignContaining(paths) {
+      if (tokens.size === 0 || paths.length === 0) return;
+      const resized = [];
+      for (const [arrayKey, ids] of tokens) {
+        const segs = segmentsForPathKey(arrayKey);
+        if (segs === null || !paths.some((path) => isPathPrefix(segs, path) || isPathPrefix(path, segs))) {
+          continue;
+        }
+        const len = getArrayLength(segs);
+        if (ids.length === len) continue;
+        ensure(arrayKey, len);
+        resized.push(segs);
+      }
+      if (resized.length > 0) onChange(resized);
+    },
     hasStructuralChangeUnder(prefix) {
       for (const arrayKey of tokens.keys()) {
         if (orderPristineForKey(arrayKey)) continue;
@@ -1599,15 +1670,39 @@ function createArrayIdentity(getArrayLength) {
       return false;
     },
     rebaselineAll() {
+      const rebased = [];
       for (const arrayKey of [...tokens.keys()]) {
         const segs = segmentsForPathKey(arrayKey);
         if (segs === null) continue;
         const ids = ensure(arrayKey, getArrayLength(segs));
         baselines.set(arrayKey, [...ids]);
+        rebased.push(segs);
       }
+      if (rebased.length > 0) onChange(rebased);
+    },
+    snapshot() {
+      return { tokens: copyLists(tokens), baselines: copyLists(baselines) };
+    },
+    restore(orders) {
+      const keys = /* @__PURE__ */ new Set([...tokens.keys(), ...orders.tokens.keys()]);
+      tokens.clear();
+      for (const [key, ids] of orders.tokens) tokens.set(key, [...ids]);
+      baselines.clear();
+      for (const [key, ids] of orders.baselines) baselines.set(key, [...ids]);
+      const restored = [];
+      for (const key of keys) {
+        const segs = segmentsForPathKey(key);
+        if (segs !== null) restored.push(segs);
+      }
+      if (restored.length > 0) onChange(restored);
     }
   };
 }
+function copyLists(lists) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, ids] of lists) out.set(key, [...ids]);
+  return out;
+}
 function createVariantMemory() {
   const memory = /* @__PURE__ */ new Map();
   return {
@@ -1674,6 +1769,8 @@ function createArrayBookkeeping(deps) {
     blankPaths,
     originalBlankPaths,
     authoredPaths,
+    removedPaths,
+    notifyStructure,
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -1681,15 +1778,40 @@ function createArrayBookkeeping(deps) {
     arrayIdentity,
     variantMemory,
     touchFieldRecord,
+    stampContainers,
+    stampBareContainers,
+    foldInteractionHistory,
     decFieldValidation
   } = deps;
   function migrateElementState(arrayPath, remap) {
     if (remap.moved.size === 0 && remap.vacated.size === 0) return;
+    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
+    migrateSetSubtree(authoredPaths, arrayPath, remap);
+    const removedMoved = [];
+    for (const hit of collectKeysAtIndices(removedPaths.keys(), arrayPath, remapAffects(remap))) {
+      removedMoved.push(hit.segments);
+    }
+    migrateMapSubtree(removedPaths, arrayPath, remap, (_, segments) => {
+      removedMoved.push(segments);
+      return segments;
+    });
+    if (remap.vacated.size > 0) {
+      const released = [];
+      for (const { key } of collectKeysAtIndices(
+        fields.keys(),
+        arrayPath,
+        (index) => remap.vacated.has(index)
+      )) {
+        const record = fields.get(key);
+        if (record !== void 0) released.push(record);
+      }
+      foldInteractionHistory(arrayPath, released);
+    }
     migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
       ...record,
       path: segments
     }));
-    migrateMapSubtree(errorCells, arrayPath, remap, (cell, segments) => ({
+    migrateMapSubtree(errorCells(), arrayPath, remap, (cell, segments) => ({
       schema: NO_ERRORS,
       user: cell.user.map((error) => ({ ...error, path: [...segments] }))
     }));
@@ -1698,21 +1820,37 @@ function createArrayBookkeeping(deps) {
       value: record.value
     }));
     migrateSetSubtree(blankPaths, arrayPath, remap);
-    migrateSetSubtree(originalBlankPaths, arrayPath, remap);
-    migrateSetSubtree(authoredPaths, arrayPath, remap);
     migrateMapSubtree(fieldValidatingSince, arrayPath, remap, (since) => since);
     migrateMapSubtree(fieldValidationCounts, arrayPath, remap, (count) => count);
+    migrateMapSubtree(fieldValidationState, arrayPath, remap, (entry, segments) => {
+      entry.key = keyForSegments(segments).key;
+      entry.path = segments;
+      return entry;
+    });
     arrayIdentity.applyRemap(arrayPath, remap);
+    if (removedMoved.length > 0) notifyStructure(removedMoved);
   }
-  function seedFreshElement(arrayPath, freshIndex) {
+  function seedFreshElement(arrayPath, freshIndex, now) {
     const elementPath = [...arrayPath, freshIndex];
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const patches = [];
     diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
+      patches.push(patch);
+    });
+    const bare = [];
+    patches.forEach((patch, index) => {
       if (patch.kind !== "added") return;
-      const { key } = canonicalizePath(patch.path);
+      if (isBarePatch(patch)) {
+        bare.push(index);
+        return;
+      }
+      const { key, segments } = canonicalizePath(patch.path);
       if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
-      touchFieldRecord(key, patch.path, { updatedAt: now });
+      touchFieldRecord(key, segments, { updatedAt: now });
     });
+    if (bare.length > 0) stampBareContainers(patches, bare, now);
+    else if (patches.length === 0 && hasAtPath(form.value, elementPath)) {
+      stampContainers([elementPath], now);
+    }
   }
   function abortValidationAtVacatedIndices(arrayPath, remap) {
     if (remap.vacated.size === 0) return;
@@ -1726,21 +1864,22 @@ function createArrayBookkeeping(deps) {
       if (entry === void 0) continue;
       if (entry.timer !== null) {
         clearTimeout(entry.timer);
-      } else if (!entry.settled) {
+      } else if (!entry.settled && !entry.released) {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
         decFieldValidation(hit.key);
+        entry.released = true;
       }
       entry.aborted = true;
       fieldValidationState.delete(hit.key);
     }
   }
   return {
-    applyStructuralOp(arrayPath, remap) {
+    applyStructuralOp(arrayPath, remap, now) {
+      abortValidationAtVacatedIndices(arrayPath, remap);
       migrateElementState(arrayPath, remap);
-      for (const freshIndex of remap.fresh) seedFreshElement(arrayPath, freshIndex);
+      for (const freshIndex of remap.fresh) seedFreshElement(arrayPath, freshIndex, now);
       const changed = changedIndices(remap);
-      evictSchemaVerdictsAtIndices(errorCells, arrayPath, changed);
-      abortValidationAtVacatedIndices(arrayPath, remap);
+      evictSchemaVerdictsAtIndices(errorCells(), arrayPath, changed);
       variantMemory.dropAtIndices(arrayPath, changed);
       arrayIdentity.applyOp(arrayPath, remap);
     }
@@ -2060,7 +2199,7 @@ function adapterThrowMessage(err) {
   return "Adapter validateAtPath threw a non-Error value";
 }
 function hasUserErrorEntries(state) {
-  for (const cell of state.errorCells.values()) {
+  for (const cell of state.errorCells().values()) {
     if (cell.user.length > 0) return true;
   }
   return false;
@@ -2171,9 +2310,9 @@ function reportRejection(store, path, kind, accepted) {
   if (kind === "string" && accepted.has("number")) {
     console.warn(
       `[attaform] Cannot write a string to '${dotted}': the schema expects ${expected}.
-  Fix: add type="number" to the input, OR use the .number modifier on v-register:
-    <input type="number" v-register="register('${dotted}')" />
+  Fix: use the .number modifier on v-register, OR add type="number" to a native input:
     <input v-register.number="register('${dotted}')" />
+    <input type="number" v-register="register('${dotted}')" />
   The write was a no-op.`
     );
     return;
@@ -2329,6 +2468,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
     const isRequired = state.schema.isRequiredAtPath(segments);
     const ariaDisplayState = getDisplayStateAt !== void 0 ? computed(() => getDisplayStateAt(segments)) : void 0;
     const markBlank = () => state.setValueAtPath(segments, slimDefault, withInstanceMeta({ blank: true }));
+    const commitFromHost = (value) => value === "" && !acceptsString || value === null && !slimTypes.has("null") || value === void 0 && !acceptsUndefined ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
     const internalRv = {
       innerRef,
       displayValue,
@@ -2345,7 +2485,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       },
       ensureDomBinding: (factory) => {
         var _a;
-        (_a = state.domBinding).value ?? (_a.value = factory(state));
+        return (_a = state.domBinding).value ?? (_a.value = factory(state));
       },
       registerElement: (element) => {
         const dom = state.domBinding.value;
@@ -2365,10 +2505,10 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       setValueWithInternalPath: (value, meta) => {
         return state.setValueAtPath(segments, value, withInstanceMeta(meta));
       },
-      setValueFromHost: (value) => {
+      commitFromHost,
+      setValueFromHost: (value, modifiers) => {
         state.markInteracted(segments);
-        const isBlankSignal = value === "" && !acceptsString || value === null && !slimTypes.has("null") || value === void 0 && !acceptsUndefined;
-        const accepted = isBlankSignal ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
+        const accepted = state.domBinding.value?.hostChannel.write(internalRv, value, modifiers) ?? commitFromHost(value);
         {
           const dedupeKey = `${formInstanceId}:${pathKey}`;
           const isWired = () => (state.domBinding.value?.elements.get(pathKey)?.elements.size ?? 0) > 0 || state.getFieldRecord(segments)?.connected === true;
@@ -2384,6 +2524,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         }
         return accepted;
       },
+      setValueFromHostInput: (payload, modifiers) => state.domBinding.value?.hostChannel.writeInput(internalRv, payload, modifiers) ?? false,
       // Called by the `vRegisterHintTransform` compile-time transform's wrapping
       // IIFE on every server-side render of `<element v-register="…">`.
       // Without it, every SSR'd FieldState serialises `connected: false`
@@ -2457,25 +2598,24 @@ function isUnset(value) {
   return value === unset;
 }
 
-function walkUnsetSentinels(values, schema) {
+function walkUnsetSentinels(values, schema, rootDefault) {
   const paths = [];
   if (values === void 0) {
-    const rootSlim = schema.getDefaultAtPath([]);
-    walkUnspecified(rootSlim, [], paths);
+    walkUnspecified(rootDefault, [], paths);
     return { cleanedValues: void 0, paths };
   }
-  const cleaned = walkCore(values, [], schema, paths, true);
+  const cleaned = walkCore(values, [], schema, paths, { rootDefault });
   return { cleanedValues: cleaned, paths };
 }
 function isRecursable(value) {
   return Array.isArray(value) || isPlainRecord(value);
 }
-function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
+function walkCore(input, segments, schema, paths, synthesis) {
   if (isUnset(input)) {
     return expandUnsetAt(segments, schema, paths);
   }
   if (input === void 0) {
-    if (synthesizeSchemaKeys) {
+    if (synthesis !== null) {
       const slim = schema.getDefaultAtPath(segments);
       return walkUnspecified(slim, segments, paths);
     }
@@ -2488,7 +2628,7 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     let mutated = false;
     for (let i = 0; i < input.length; i++) {
       const original = readConsumerIndex(input, i);
-      const walked = walkCore(original, [...segments, i], schema, paths, synthesizeSchemaKeys);
+      const walked = walkCore(original, [...segments, i], schema, paths, synthesis);
       out[i] = walked;
       if (walked !== original) mutated = true;
     }
@@ -2500,10 +2640,10 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     let keys = inputKeys;
     let mutated = false;
     let inputKeysSet = null;
-    if (synthesizeSchemaKeys) {
+    if (synthesis !== null) {
       inputKeysSet = new Set(inputKeys);
       const allKeys = new Set(inputKeys);
-      const slim = schema.getDefaultAtPath(segments);
+      const slim = segments.length === 0 ? synthesis.rootDefault : schema.getDefaultAtPath(segments);
       if (isPlainRecord(slim)) {
         for (const k of Object.keys(slim)) allKeys.add(k);
       }
@@ -2513,12 +2653,12 @@ function walkCore(input, segments, schema, paths, synthesizeSchemaKeys) {
     const out = {};
     for (const key of keys) {
       const orig = readConsumerProp(obj, key);
-      if (synthesizeSchemaKeys && orig === void 0 && inputKeysSet?.has(key) === true) {
+      if (synthesis !== null && orig === void 0 && inputKeysSet?.has(key) === true) {
         safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
-      const walked = walkCore(orig, [...segments, key], schema, paths, synthesizeSchemaKeys);
+      const walked = walkCore(orig, [...segments, key], schema, paths, synthesis);
       safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
@@ -2542,7 +2682,7 @@ function walkUnspecified(slim, segments, paths) {
 }
 function substituteUnsetSentinels(value, prefix, schema) {
   const paths = [];
-  const cleaned = walkCore(value, [...prefix], schema, paths, false);
+  const cleaned = walkCore(value, [...prefix], schema, paths, null);
   return { cleanedValues: cleaned, paths };
 }
 function isPrimitiveOrEmpty(value) {
@@ -2551,12 +2691,12 @@ function isPrimitiveOrEmpty(value) {
   return t === "string" || t === "number" || t === "boolean" || t === "bigint";
 }
 function isSlimNumericPrimitive(value) {
-  return value === 0 || value === 0n;
+  return value === 0 || typeof value === "bigint" && !value;
 }
 function blankForKind(slimDefault) {
   if (typeof slimDefault === "string") return "";
   if (typeof slimDefault === "number") return 0;
-  if (typeof slimDefault === "bigint") return 0n;
+  if (typeof slimDefault === "bigint") return typeof BigInt === "function" ? BigInt(0) : void 0;
   if (typeof slimDefault === "boolean") return false;
   if (slimDefault === null) return null;
   return void 0;
@@ -2707,7 +2847,18 @@ function buildFormApi(state, formInstanceId, options = {}) {
     void state.submitted.value;
     return metaBase;
   };
-  const pathSweep = state.pathSweep;
+  const releases = [];
+  const lease = (release) => {
+    releases.push(release);
+    return release;
+  };
+  onScopeDispose(() => {
+    for (const release of releases) release();
+  }, true);
+  const pathSweep = {
+    track: state.pathSweep.track,
+    onEvict: (evict) => lease(state.pathSweep.onEvict(evict))
+  };
   const getRootFieldStateAt = buildFieldStateAccessor(
     state,
     formInstanceId,
@@ -2765,7 +2916,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
       const walked2 = walkUnsetSentinels(
         next,
-        state.schema
+        state.schema,
+        state.schema.getDefaultAtPath([])
       );
       const ok2 = state.setValueAtPath([], walked2.cleanedValues, writeMeta());
       if (!ok2) return false;
@@ -2830,7 +2982,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const errorsProxy = buildErrorsSurface(state, pathSweep);
   function flattenUserErrors() {
     const all = [];
-    for (const cell of state.errorCells.values()) all.push(...cell.user);
+    for (const cell of state.errorCells().values()) all.push(...cell.user);
     return all;
   }
   function setErrors(arg1, arg2) {
@@ -2838,7 +2990,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (isScoped) {
       const { segments, key } = canonicalizePath(arg1);
       const input2 = arg2;
-      const resolved2 = typeof input2 === "function" ? input2([...state.errorCells.get(key)?.user ?? []]) : input2;
+      const resolved2 = typeof input2 === "function" ? input2([...state.errorCells().get(key)?.user ?? []]) : input2;
       state.setUserErrorsForPath(
         segments,
         normalizeErrorInputs(resolved2, segments, AttaformErrorCode.UserError)
@@ -2866,7 +3018,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const departAttempts = computed(() => state.departAttempts.value);
   const validating = computed(() => state.activeValidations.value > 0);
   const valid = computed(
-    () => state.firstValidationDone.value && state.errorCells.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
+    () => state.firstValidationDone.value && state.errorCells().size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
   );
   const history = options.history;
   const formHistory = history === void 0 ? inertHistory() : readonly(
@@ -2913,7 +3065,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
   const metaTarget = buildMetaProxy(META_KEYS, (key) => {
     if (key === "errorCount") return metaErrors.value.length;
-    if (Object.hasOwn(metaOwn, key)) return metaOwn[key];
+    if (safeOwnHas(metaOwn, key)) return metaOwn[key];
     return rootFieldState.value[key];
   });
   const formMeta = readonly(reactive(metaTarget));
@@ -2928,8 +3080,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
       );
       state.reset(walked.cleanedValues);
       for (const pathKey of walked.paths) {
-        state.blankPaths.add(pathKey);
         state.originalBlankPaths.add(pathKey);
+        state.blankPaths.add(pathKey);
       }
     }
   };
@@ -2982,7 +3134,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
     };
     return Object.freeze(view);
   });
-  const valuesProxy = buildValuesSurface(state.form, state.onFormChange);
+  const valuesProxy = buildValuesSurface(
+    state.form,
+    (listener) => lease(state.onFormChange(listener))
+  );
   const fieldStateProxy = buildFieldsSurface(state, getRootFieldStateAt, pathSweep);
   const needsLazyGate = state.defaultValuesFactory.value !== void 0 || state.hasSsrPrefetch;
   function gated(fn) {
@@ -3130,7 +3285,7 @@ function shortenSourceFrame(frame) {
 const SWEEP_SLICE = 8;
 function createDynamicPathSweep(deps) {
   const dynamicKeys = /* @__PURE__ */ new Set();
-  const evictors = [];
+  const evictors = /* @__PURE__ */ new Set();
   const isDynamicPath = (segments) => {
     for (let i = 0; i < segments.length; i++) {
       if (typeof segments[i] === "number") return true;
@@ -3161,7 +3316,10 @@ function createDynamicPathSweep(deps) {
       if (isDynamicPath(segments)) dynamicKeys.add(key);
     },
     onEvict(evict) {
-      evictors.push(evict);
+      evictors.add(evict);
+      return () => {
+        evictors.delete(evict);
+      };
     }
   };
 }
@@ -3365,7 +3523,7 @@ function mergeObjectKeys(target, source, path, schema) {
 async function runFactoryAndApply(st, factory) {
   try {
     const value = await factory();
-    walkAuthoredFromConstraints(value, [], st.authoredPaths);
+    if (st.hasPreprocessOrCoerce) walkAuthoredFromConstraints(value, [], st.authoredPaths);
     const full = mergeSparseHydration(
       toRaw(st.form.value),
       value,
@@ -3389,7 +3547,7 @@ async function runFactoryAndApply(st, factory) {
   }
 }
 function clearHydrationFailedEntry(st) {
-  const existing = st.errorCells.get(ROOT_PATH_KEY)?.schema;
+  const existing = st.errorCells().get(ROOT_PATH_KEY)?.schema;
   if (existing === void 0 || existing.length === 0) return;
   const filtered = existing.filter((e) => e.code !== AttaformErrorCode.HydrationFailed);
   if (filtered.length !== existing.length) {
@@ -3403,21 +3561,20 @@ function appendHydrationFailedEntry(st, error) {
     path: [...ROOT_PATH],
     code: AttaformErrorCode.HydrationFailed
   };
-  const existing = st.errorCells.get(ROOT_PATH_KEY)?.schema ?? [];
+  const existing = st.errorCells().get(ROOT_PATH_KEY)?.schema ?? [];
   st.setSchemaErrorsForPath([...ROOT_PATH], [...existing, entry]);
   return entry;
 }
 
-const isContainer = (value) => Array.isArray(value) || isPlainRecord(value);
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
   return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && typeof r.touched === "boolean" && typeof r.interacted === "boolean" && typeof r.blurredAfterInteraction === "boolean";
 }
-function withClearedHistoryFlags(record, now) {
+function withClearedHistoryFlags(record, updatedAt) {
   return {
     path: record.path,
-    updatedAt: now,
+    updatedAt,
     connected: record.connected,
     focused: record.focused,
     blurred: record.blurred,
@@ -3466,7 +3623,7 @@ function walkDuStubs(schema, value, path, warned) {
   if (du !== void 0) {
     const discValue = rec[du.discriminatorKey];
     if (discValue !== void 0 && !du.isVariantSelected(discValue)) {
-      const isKindBlank = discValue === "" || discValue === 0 || discValue === 0n || discValue === false || discValue === null;
+      const isKindBlank = discValue === "" || discValue === 0 || typeof discValue === "bigint" && !discValue || discValue === false || discValue === null;
       if (!isKindBlank && warned !== void 0 && true) {
         const dotted = path.map((s) => String(s)).join(".") || "(root)";
         const key = `${dotted}::${String(discValue)}`;
@@ -3537,24 +3694,38 @@ function walkAuthoredFromSchemaDiff(withDefaults, withoutDefaults, prefix, out)
     out.add(canonicalizePath(prefix).key);
   }
 }
-function computeBaselineResponse(schema, source) {
-  const completed = source === void 0 ? void 0 : mergeStructural(schema, [], source);
+function computeBaseline(schema, source, schemaDefaults) {
+  if (source === void 0) return schemaDefaults;
   return schema.getDefaultValues({
     useDefaultSchemaValues: true,
-    constraints: completed
+    constraints: mergeStructural(schema, [], source, schemaDefaults)
   });
 }
 function initialFirstValidationGate(schema) {
   return schema.needsAsyncValidation?.() !== true;
 }
-function seedOriginalsFromBaseline(st, baseline, ensureOrdinals) {
-  st.originals.clear();
+function seedOriginalsFromBaseline(st, baseline) {
+  const seeded = /* @__PURE__ */ new Map();
   diffAndApply({}, baseline, [], (patch) => {
-    if (patch.kind !== "added") return;
-    const { key } = canonicalizePath(patch.path);
-    st.originals.set(key, { segments: patch.path, value: patch.newValue });
-    if (ensureOrdinals) ensurePathOrdinal(st, key);
+    if (patch.kind === "added") seedBaseline(seeded, canonicalizePath(patch.path).key, patch);
   });
+  replaceOriginals(st, seeded);
+}
+function replaceOriginals(st, next) {
+  for (const [key, entry] of next) st.originals.set(key, entry);
+  for (const key of [...toRaw(st.originals).keys()]) {
+    if (!next.has(key)) st.originals.delete(key);
+  }
+}
+function seedBaseline(originals, key, patch) {
+  const value = patch.newValue;
+  if (!isDescendable(value)) {
+    originals.set(key, { segments: patch.path, value });
+    return false;
+  }
+  if (!(value instanceof Map))
+    originals.set(key, { segments: patch.path, value: Array.isArray(value) ? [] : {} });
+  return true;
 }
 function queueInitialAsyncValidation(st) {
   if (!st.ssr && st.schema.needsAsyncValidation?.() === true) {
@@ -3567,6 +3738,7 @@ function queueInitialAsyncValidation(st) {
   }
 }
 function rebuildAuthoredPaths(st, constraints, schemaWithDefaultsData) {
+  if (!st.hasPreprocessOrCoerce) return;
   st.authoredPaths.clear();
   if (constraints !== void 0) {
     walkAuthoredFromConstraints(constraints, [], st.authoredPaths);
@@ -3600,6 +3772,7 @@ function ensurePathOrdinal(st, key) {
   return ordinal;
 }
 function pathHasAsyncValidationByKey(st, key, segments) {
+  if (st.schema.needsAsyncValidation?.() === false) return false;
   const cached = st.pathAsyncCache.get(key);
   if (cached !== void 0) return cached;
   const candidates = st.schema.getSchemasAtPath(segments);
@@ -3714,8 +3887,18 @@ function settleTransforms(st, path) {
     st.transformWaiters.push({ key, resolve });
   });
 }
+function writeInstant(st) {
+  const clock = (/* @__PURE__ */ new Date()).toISOString();
+  if (clock > st.latestStamp) return clock;
+  const after = new Date(new Date(st.latestStamp).getTime() + 1);
+  return Number.isFinite(after.getTime()) ? after.toISOString() : clock;
+}
+function noteStamp(st, stamp) {
+  if (stamp !== null && stamp > st.latestStamp) st.latestStamp = stamp;
+}
 function touchFieldRecord(st, pathKey, path, patch) {
   const current = st.fields.get(pathKey);
+  if (patch.updatedAt !== void 0) noteStamp(st, patch.updatedAt);
   st.fields.set(pathKey, {
     path,
     updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
@@ -3734,19 +3917,188 @@ function touchFieldRecord(st, pathKey, path, patch) {
     blurredAfterInteraction: patch.blurredAfterInteraction ?? current?.blurredAfterInteraction ?? false
   });
 }
-function commitWritePatches(st, patches, meta) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+function stampContainers(st, containers, now) {
+  eachAncestorOnce(containers, (key, segments) => raiseStamp(st, key, segments, now));
+}
+function raiseStamp(st, key, segments, stamp) {
+  if ((st.fields.get(key)?.updatedAt ?? "") < stamp) {
+    touchFieldRecord(st, key, segments, { updatedAt: stamp });
+  }
+}
+function holdRemovedStamps(st, patches, next) {
+  const held = /* @__PURE__ */ new Map();
+  const hold = (path, depth, leaf) => noteHold(st, held, next, path, depth, leaf);
   for (const patch of patches) {
-    const { key } = canonicalizePath(patch.path);
-    if (!st.originals.has(key)) {
+    if (patch.kind === "added") continue;
+    const { oldValue, path } = patch;
+    if (Array.isArray(oldValue) || isPlainRecord(oldValue)) {
+      if (patch.kind === "changed") {
+        visitActiveLeafPaths(oldValue, path, (leaf) => hold(path, path.length, leaf));
+      }
+    } else if (patch.kind === "removed" ? !hasAtPath(next, path) : Array.isArray(patch.newValue) || isPlainRecord(patch.newValue)) {
+      hold(path, path.length - 1, path);
+    }
+  }
+  applyHolds(st, held);
+}
+function noteHold(st, held, next, path, depth, leaf) {
+  const { key: leafKey } = keyForSegments(leaf);
+  const stamp = toRaw(st.originals).has(leafKey) ? toRaw(st.fields).get(leafKey)?.updatedAt : null;
+  if (stamp === null || stamp === void 0) return;
+  let kept = false;
+  for (let at = depth; at >= 0; at--) {
+    const segments = path.slice(0, at);
+    if (!kept && !hasAtPath(next, segments)) continue;
+    kept = true;
+    const { key } = keyForSegments(segments);
+    const current = held.get(key);
+    if (current === void 0) held.set(key, { segments, stamp });
+    else if (stamp > current.stamp) current.stamp = stamp;
+  }
+}
+function applyHolds(st, held) {
+  for (const [key, { segments, stamp }] of held) raiseStamp(st, key, segments, stamp);
+}
+function stampBareContainers(st, patches, bare, now) {
+  for (const index of bare) {
+    const path = patches[index]?.path ?? [];
+    for (let depth = path.length; depth >= 0; depth--) {
+      const container = path.slice(0, depth);
+      if (depth < path.length && reachedBesides(patches, index, container)) break;
+      const { key, segments } = keyForSegments(container);
+      raiseStamp(st, key, segments, now);
+    }
+  }
+}
+function reachedBesides(patches, index, container) {
+  for (const step of [-1, 1]) {
+    for (let i = index + step; ; i += step) {
+      const patch = patches[i];
+      if (patch === void 0 || !isPathPrefix(container, patch.path)) break;
+      if (!isBarePatch(patch)) return true;
+    }
+  }
+  return false;
+}
+function eachAncestorOnce(paths, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    for (let depth = path.length; depth >= 0; depth--) {
+      const { key, segments } = keyForSegments(path.slice(0, depth));
+      if (seen.has(key)) break;
+      seen.add(key);
+      visit(key, segments);
+    }
+  }
+}
+function foldInteractionHistory(st, path, released) {
+  let touched = false;
+  let interacted = false;
+  let blurredAfterInteraction = false;
+  for (const record of released) {
+    touched || (touched = record.touched);
+    interacted || (interacted = record.interacted);
+    blurredAfterInteraction || (blurredAfterInteraction = record.blurredAfterInteraction);
+  }
+  if (!touched && !interacted && !blurredAfterInteraction) return;
+  for (let depth = path.length; depth >= 0; depth--) {
+    const { key, segments } = keyForSegments(path.slice(0, depth));
+    const current = st.fields.get(key);
+    touchFieldRecord(st, key, segments, {
+      touched: touched || current?.touched === true,
+      interacted: interacted || current?.interacted === true,
+      blurredAfterInteraction: blurredAfterInteraction || current?.blurredAfterInteraction === true
+    });
+  }
+}
+function releaseRemovedRecords(st, segments, raw) {
+  const released = [];
+  let depth = segments.length;
+  do {
+    const { key } = keyForSegments(segments.slice(0, depth));
+    abortValidationAt(st, key);
+    const record = st.fields.get(key);
+    if (record !== void 0) {
+      released.push(record);
+      if (record.connected) st.fields.set(key, withClearedHistoryFlags(record, null));
+      else st.fields.delete(key);
+    }
+    depth--;
+  } while (depth > 0 && !hasAtPath(raw, segments.slice(0, depth)));
+  const present = segments.slice(0, depth);
+  foldInteractionHistory(st, present, released);
+  return present;
+}
+function noteRemovedBaseline(st, key, segments, notify) {
+  if (st.originals.get(key)?.value === void 0) return;
+  st.removedPaths.set(key, segments);
+  notify.push(segments);
+}
+function trackForSweep(st, path, key) {
+  st.pathSweep.track(path, key);
+  for (let i = 1; i < path.length; i++) {
+    const ancestor = path.slice(0, i);
+    st.pathSweep.track(ancestor, canonicalizePath(ancestor).key);
+  }
+}
+function commitWritePatches(st, patches, meta, structuralOp, now) {
+  const arrayOpPath = structuralOp?.path;
+  const reshaped = [];
+  const removed = [];
+  const resizing = [];
+  const raw = toRaw(st.form.value);
+  const bareAt = [];
+  for (const [index, patch] of patches.entries()) {
+    const { key, segments } = canonicalizePath(patch.path);
+    const bare = isBarePatch(patch);
+    if (!bare && !st.originals.has(key)) {
       st.originals.set(key, { segments: patch.path, value: void 0 });
     }
-    touchFieldRecord(st, key, patch.path, { updatedAt: now });
-    st.pathSweep.track(patch.path, key);
-    for (let i = 1; i < patch.path.length; i++) {
-      const ancestor = patch.path.slice(0, i);
-      st.pathSweep.track(ancestor, canonicalizePath(ancestor).key);
+    const positional = arrayOpPath !== void 0 && segments.length > arrayOpPath.length && isPathPrefix(arrayOpPath, segments);
+    if (structuralOp === null && (patch.kind !== "changed" || typeof patch.oldValue === "object" || typeof patch.newValue === "object")) {
+      resizing.push(segments);
     }
+    if (!positional) {
+      if (patch.kind === "removed" && !hasAtPath(raw, segments)) {
+        reshaped.push(releaseRemovedRecords(st, segments, raw));
+        noteRemovedBaseline(st, key, segments, removed);
+      } else {
+        touchFieldRecord(st, key, segments, { updatedAt: now });
+        if (bare) bareAt.push(index);
+        if (patch.kind === "changed" && typeof patch.oldValue === "object" && patch.oldValue !== null) {
+          diffAndApply(patch.oldValue, void 0, segments, (gone) => {
+            if (!hasAtPath(raw, gone.path)) {
+              reshaped.push(releaseRemovedRecords(st, gone.path, raw));
+              const goneAt = canonicalizePath(gone.path);
+              noteRemovedBaseline(st, goneAt.key, goneAt.segments, removed);
+            }
+          });
+        }
+        if (patch.kind === "changed" && isDescendable(patch.newValue)) {
+          diffAndApply(void 0, patch.newValue, segments, (fresh) => {
+            const at = canonicalizePath(fresh.path);
+            trackForSweep(st, fresh.path, at.key);
+            if (fresh.kind === "added" && isDescendable(fresh.newValue)) {
+              reshaped.push(at.segments);
+              return;
+            }
+            if (!st.originals.has(at.key)) {
+              st.originals.set(at.key, { segments: fresh.path, value: void 0 });
+            }
+            touchFieldRecord(st, at.key, at.segments, { updatedAt: now });
+          });
+        }
+      }
+    }
+    trackForSweep(st, patch.path, key);
+  }
+  if (arrayOpPath !== void 0 && patches.length > 0) reshaped.push(arrayOpPath);
+  if (reshaped.length > 0) stampContainers(st, reshaped, now);
+  if (bareAt.length > 0) stampBareContainers(st, patches, bareAt, now);
+  if (removed.length > 0) pulseStructure(st.structureSignal, removed);
+  if (resizing.length > 0) st.arrayIdentity.realignContaining(resizing);
+  if (structuralOp !== null) {
+    st.arrayBookkeeping.applyStructuralOp(structuralOp.path, structuralOp.remap, now);
   }
   for (const listener of st.formChangeListeners) {
     try {
@@ -3756,33 +4108,41 @@ function commitWritePatches(st, patches, meta) {
     }
   }
 }
-function applyFormReplacementWithPath(st, next, meta, arrayOpPath) {
+function applyFormReplacementWithPath(st, next, meta, structuralOp, now) {
   const prev = st.form.value;
   if (Object.is(prev, next)) return;
   const patches = [];
   diffAndApply(prev, next, [], (patch) => {
     patches.push(patch);
   });
-  if (!applyChangedKeys(prev, next, arrayOpPath, [], patches)) {
+  holdRemovedStamps(st, patches, next);
+  const reconciled = callConsumerFn(
+    () => applyChangedKeys(prev, next, structuralOp?.path ?? null, [], patches),
+    null,
+    "stored-value"
+  );
+  if (reconciled === null) return;
+  if (!reconciled) {
     st.form.value = next;
   } else if (patches.some(
     (p) => p.path.length > 0 && typeof p.path[0] === "string" && isShadowedKey(p.path[0])
   )) {
     triggerRef(st.form);
   }
-  commitWritePatches(st, patches, meta);
+  commitWritePatches(st, patches, meta, structuralOp, now);
 }
 function applyFormReplacement(st, next, meta) {
-  applyFormReplacementWithPath(st, next, meta, null);
+  applyFormReplacementWithPath(st, next, meta, null, writeInstant(st));
 }
-function applyTargetedWrite(st, path, completedValue, meta) {
+function applyTargetedWrite(st, path, completedValue, meta, structuralOp, now) {
   const result = tryInPlaceLeafWrite(st.form.value, path, completedValue);
   if (!result.applied) {
     applyFormReplacementWithPath(
       st,
       setAtPathWithSchemaFill(st.form.value, st.schema, path, completedValue),
       meta,
-      meta?.arrayOp !== void 0 ? path : null
+      structuralOp,
+      now
     );
     return;
   }
@@ -3790,9 +4150,9 @@ function applyTargetedWrite(st, path, completedValue, meta) {
   diffAndApply(result.old, completedValue, path, (patch) => {
     patches.push(patch);
   });
-  commitWritePatches(st, patches, meta);
+  commitWritePatches(st, patches, meta, null, now);
 }
-function setValueAtPath(st, path, value, meta) {
+function setValueAtPath(st, path, value, meta, writeStamp) {
   if (st.effectiveDisabled.value) {
     if (!st.warnedDisabledWrite) {
       st.warnedDisabledWrite = true;
@@ -3871,7 +4231,8 @@ function setValueAtPath(st, path, value, meta) {
                 value,
                 variantDefault,
                 void 0,
-                meta
+                meta,
+                writeStamp
               );
             }
             return reshapeUnionVariant(
@@ -3881,7 +4242,8 @@ function setValueAtPath(st, path, value, meta) {
               value,
               { [last]: value },
               void 0,
-              meta
+              meta,
+              writeStamp
             );
           }
         }
@@ -3905,7 +4267,8 @@ function setValueAtPath(st, path, value, meta) {
               discValue,
               variantDefault,
               valueRecord,
-              meta
+              meta,
+              writeStamp
             );
           }
           return reshapeUnionVariant(
@@ -3915,10 +4278,20 @@ function setValueAtPath(st, path, value, meta) {
             discValue,
             { [discKey]: discValue },
             void 0,
-            meta
+            meta,
+            writeStamp
           );
         }
-        return reshapeUnionVariant(st, path, oldDiscValue, void 0, {}, void 0, meta);
+        return reshapeUnionVariant(
+          st,
+          path,
+          oldDiscValue,
+          void 0,
+          {},
+          void 0,
+          meta,
+          writeStamp
+        );
       }
     }
   }
@@ -3934,16 +4307,19 @@ function setValueAtPath(st, path, value, meta) {
       }
     }
   }
-  const wasAuthoredBefore = st.authoredPaths.has(pathKey);
-  if (arrayOpRemap !== null && Array.isArray(value)) {
-    if (path.length > 0) st.authoredPaths.add(pathKey);
-    for (const idx of arrayOpRemap.fresh) {
-      walkAuthoredFromConstraints(value[idx], [...path, idx], st.authoredPaths);
+  let newlyAuthored = false;
+  if (st.hasPreprocessOrCoerce) {
+    const wasAuthoredBefore = st.authoredPaths.has(pathKey);
+    if (arrayOpRemap !== null && Array.isArray(value)) {
+      if (path.length > 0) st.authoredPaths.add(pathKey);
+      for (const idx of arrayOpRemap.fresh) {
+        walkAuthoredFromConstraints(value[idx], [...path, idx], st.authoredPaths);
+      }
+    } else {
+      walkAuthoredFromConstraints(value, path, st.authoredPaths);
     }
-  } else {
-    walkAuthoredFromConstraints(value, path, st.authoredPaths);
+    newlyAuthored = !wasAuthoredBefore && st.authoredPaths.has(pathKey);
   }
-  const newlyAuthored = !wasAuthoredBefore && st.authoredPaths.has(pathKey);
   let completedValue;
   if (arrayOpRemap !== null && Array.isArray(value)) {
     for (const idx of arrayOpRemap.fresh) {
@@ -3965,16 +4341,17 @@ function setValueAtPath(st, path, value, meta) {
   if (arrayOpRemap === null && Array.isArray(value) && Array.isArray(currentValue)) {
     st.arrayIdentity.realign(path);
   }
-  applyTargetedWrite(st, path, completedValue, meta);
-  if (arrayOpRemap !== null) {
-    st.arrayBookkeeping.applyStructuralOp(path, arrayOpRemap);
-  } else if (Array.isArray(value) && Array.isArray(currentValue)) {
+  const now = writeStamp ?? writeInstant(st);
+  applyTargetedWrite(
+    st,
+    path,
+    completedValue,
+    meta,
+    arrayOpRemap !== null ? { path, remap: arrayOpRemap } : null,
+    now
+  );
+  if (arrayOpRemap === null && Array.isArray(value) && Array.isArray(currentValue)) {
     st.variantMemory.clearUnderPath(path);
-    st.arrayIdentity.realign(path);
-  } else if (isContainer(currentValue) && !isContainer(value)) {
-    if (subtreeHadRealBaseline(st, path, currentValue)) {
-      st.removedSubtrees.add(pathKey);
-    }
   }
   const effectiveModeAfterWrite = meta?.instance?.validateOn ?? st.fieldValidationMode;
   if (effectiveModeAfterWrite === "change") {
@@ -3982,7 +4359,7 @@ function setValueAtPath(st, path, value, meta) {
   }
   return true;
 }
-function reshapeUnionVariant(st, parentPath, oldDiscValue, newDiscValue, variantDefault, consumerOverrides, meta) {
+function reshapeUnionVariant(st, parentPath, oldDiscValue, newDiscValue, variantDefault, consumerOverrides, meta, writeStamp) {
   const sameDisc = Object.is(oldDiscValue, newDiscValue);
   const parentKey = canonicalizePath(parentPath).key;
   let baseline = variantDefault;
@@ -4048,7 +4425,7 @@ function reshapeUnionVariant(st, parentPath, oldDiscValue, newDiscValue, variant
       appliedSync = true;
     }
   }
-  applyFormReplacement(st, nextForm, meta);
+  applyFormReplacementWithPath(st, nextForm, meta, null, writeStamp ?? writeInstant(st));
   for (const k of newBlankPaths) st.blankPaths.add(k);
   if (reshapeMode === "change" && !appliedSync) {
     scheduleFieldValidation(st, parentPath, false, meta?.instance);
@@ -4069,7 +4446,9 @@ function scheduleFieldValidation(st, path, immediate, instance) {
     aborted: false,
     timer: null,
     settled: false,
-    released: false
+    released: false,
+    key,
+    path
   };
   st.fieldValidationState.set(key, fresh);
   const myEpoch = ++st.scheduleEpoch;
@@ -4080,19 +4459,20 @@ function scheduleFieldValidation(st, path, immediate, instance) {
     try {
       st.activeValidations.value += 1;
       activeIncremented = true;
-      incFieldValidation(st, key);
+      incFieldValidation(st, fresh.key);
     } catch (err) {
       if (activeIncremented) {
         st.activeValidations.value = Math.max(0, st.activeValidations.value - 1);
       }
       throw err;
     }
-    const subtreeScope = path.length > 0 && st.schema.hasContainerOrRootRefine?.() === false;
-    const scopePath = subtreeScope ? path : void 0;
-    const dataAtScope = subtreeScope ? getAtPath(st.form.value, path) : st.form.value;
-    const scopeKey = subtreeScope ? canonicalizePath(path).key : ROOT_PATH_KEY;
-    void Promise.resolve().then(() => st.schema.validateAtPath(dataAtScope, scopePath)).then((response) => {
+    const startPath = fresh.path;
+    const subtreeScope = startPath.length > 0 && st.schema.hasContainerOrRootRefine?.() === false;
+    const dataAtScope = subtreeScope ? getAtPath(st.form.value, startPath) : st.form.value;
+    void Promise.resolve().then(() => st.schema.validateAtPath(dataAtScope, subtreeScope ? startPath : void 0)).then((response) => {
       if (fresh.aborted) return;
+      const scopePath = subtreeScope ? fresh.path : void 0;
+      const scopeKey = subtreeScope ? fresh.key : ROOT_PATH_KEY;
       if (myEpoch <= st.lastCommittedEpoch) return;
       st.lastCommittedEpoch = myEpoch;
       if (effectiveMode === "blur") {
@@ -4103,14 +4483,14 @@ function scheduleFieldValidation(st, path, immediate, instance) {
       const filtered = filterAuthoredErrors(st, errors);
       const restamped = subtreeScope ? filtered.map((err) => ({
         ...err,
-        path: [...path, ...err.path]
+        path: [...scopePath ?? [], ...err.path]
       })) : filtered;
       applySchemaErrorsForSubtree(st, scopePath ?? [], restamped);
     }).catch(() => {
     }).finally(() => {
       if (!fresh.released) {
         st.activeValidations.value = Math.max(0, st.activeValidations.value - 1);
-        decFieldValidation(st, key);
+        decFieldValidation(st, fresh.key);
       }
       fresh.settled = true;
     });
@@ -4149,6 +4529,19 @@ function cancelFieldValidationUnder(st, prefix) {
     st.fieldValidationState.delete(key);
   }
 }
+function abortValidationAt(st, key) {
+  const entry = st.fieldValidationState.get(key);
+  if (entry === void 0) return;
+  if (entry.timer !== null) {
+    clearTimeout(entry.timer);
+  } else if (!entry.settled && !entry.released) {
+    st.activeValidations.value = Math.max(0, st.activeValidations.value - 1);
+    decFieldValidation(st, key);
+    entry.released = true;
+  }
+  entry.aborted = true;
+  st.fieldValidationState.delete(key);
+}
 function onFormChange(st, listener) {
   st.formChangeListeners.add(listener);
   return () => {
@@ -4200,22 +4593,38 @@ function getValueAtPath(st, path) {
   return getAtPath(st.form.value, path);
 }
 const ERROR_SOURCES = ["schema", "user"];
+function createErrorCells(schema, pristine) {
+  const raw = /* @__PURE__ */ new Map();
+  const cells = shallowReactive(raw);
+  return (seed) => {
+    const data = pristine;
+    if (data !== void 0) {
+      pristine = void 0;
+      if (seed) {
+        for (const [key, list] of groupErrorsByKey(schema.validateSync(data))) {
+          raw.set(key, { schema: list, user: NO_ERRORS });
+        }
+      }
+    }
+    return cells;
+  };
+}
 function setErrorChannelForKey(st, key, src, entries) {
-  const current = st.errorCells.get(key);
+  const current = st.errorCells().get(key);
   const schema = src === "schema" ? entries : current?.schema ?? NO_ERRORS;
   const user = src === "user" ? entries : current?.user ?? NO_ERRORS;
   if (schema.length === 0 && user.length === 0) {
-    if (current !== void 0) st.errorCells.delete(key);
+    if (current !== void 0) st.errorCells().delete(key);
     return;
   }
-  st.errorCells.set(key, { schema, user });
+  st.errorCells().set(key, { schema, user });
 }
 function replaceErrorChannel(st, src, entries) {
   const other = src === "schema" ? "user" : "schema";
   const grouped = groupErrorsByKey(entries);
-  for (const [key, cell] of st.errorCells) {
+  for (const [key, cell] of st.errorCells()) {
     if (cell[other].length === 0) {
-      st.errorCells.delete(key);
+      st.errorCells().delete(key);
       continue;
     }
     const fresh = grouped.get(key);
@@ -4240,8 +4649,9 @@ function clearErrorChannel(st, src, path) {
 function applySchemaErrorsForSubtree(st, path, entries) {
   const parentKey = canonicalizePath(path).key;
   const grouped = groupErrorsByKey(entries);
+  if (path.length === 0) st.skipErrorSeed();
   if (!grouped.has(parentKey)) setErrorChannelForKey(st, parentKey, "schema", NO_ERRORS);
-  for (const [existingKey, cell] of st.errorCells) {
+  for (const [existingKey, cell] of st.errorCells()) {
     if (existingKey === parentKey) continue;
     if (cell.schema.length === 0) continue;
     if (isPathKeyUnder(existingKey, path) && !grouped.has(existingKey)) {
@@ -4253,15 +4663,45 @@ function applySchemaErrorsForSubtree(st, path, entries) {
   }
 }
 function restoreErrorCells(st, entries) {
-  st.errorCells.clear();
+  st.skipErrorSeed().clear();
   for (const [key, cell] of entries) {
     if (cell.schema.length === 0 && cell.user.length === 0) continue;
-    st.errorCells.set(key, { schema: [...cell.schema], user: [...cell.user] });
+    st.errorCells().set(key, { schema: [...cell.schema], user: [...cell.user] });
+  }
+}
+function captureStructure(st) {
+  return {
+    identity: st.arrayIdentity.snapshot(),
+    originals: [...toRaw(st.originals)],
+    originalBlank: [...st.originalBlankPaths],
+    removed: [...st.removedPaths]
+  };
+}
+function restoreStructure(st, snapshot) {
+  const originals = new Map(snapshot.originals);
+  const raw = toRaw(st.form.value);
+  const held = /* @__PURE__ */ new Map();
+  for (const [key, { segments }] of toRaw(st.originals)) {
+    if (!originals.has(key) && hasAtPath(raw, segments)) {
+      noteHold(st, held, raw, segments, segments.length - 1, segments);
+    }
   }
+  applyHolds(st, held);
+  st.arrayIdentity.restore(snapshot.identity);
+  replaceOriginals(st, originals);
+  st.originalBlankPaths.clear();
+  for (const key of snapshot.originalBlank) st.originalBlankPaths.add(key);
+  const pulsed = [...st.removedPaths.values()];
+  st.removedPaths.clear();
+  for (const [key, segments] of snapshot.removed) {
+    st.removedPaths.set(key, segments);
+    pulsed.push(segments);
+  }
+  if (pulsed.length > 0) pulseStructure(st.structureSignal, pulsed);
 }
 function getErrorsForPath(st, path) {
   const { key } = canonicalizePath(path);
-  const cell = st.errorCells.get(key);
+  const cell = st.errorCells().get(key);
   const blankForKey = st.derivedBlankErrors.value.get(key);
   if (cell === void 0 && blankForKey === void 0) {
     return [];
@@ -4283,6 +4723,7 @@ function noteDomConnected(st, path) {
 }
 function noteDomDisconnected(st, path) {
   const { key } = canonicalizePath(path);
+  if (!st.fields.has(key)) return;
   touchFieldRecord(st, key, path, { connected: false, focused: null, blurred: null });
 }
 function markConnectedOptimistically(st, path) {
@@ -4346,7 +4787,7 @@ function touchAtPath(st, segments) {
   const formValue = st.form.value;
   let touchedAny = false;
   for (const [leafKey, entry] of st.originals) {
-    if (!isPathPrefix(segments, entry.segments)) continue;
+    if (!isPathPrefix(segments, entry.segments) || isDescendable(entry.value)) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
     touchedAny = true;
     const current = st.fields.get(leafKey);
@@ -4364,7 +4805,7 @@ function interactAtPath(st, segments) {
   const formValue = st.form.value;
   let interactedAny = false;
   for (const [leafKey, entry] of st.originals) {
-    if (!isPathPrefix(segments, entry.segments)) continue;
+    if (!isPathPrefix(segments, entry.segments) || isDescendable(entry.value)) continue;
     if (!hasAtPath(formValue, entry.segments)) continue;
     interactedAny = true;
     const current = st.fields.get(leafKey);
@@ -4423,7 +4864,14 @@ function adoptResolvedDefaults(st, value) {
       st.schema
     )
   );
-  seedOriginalsFromBaseline(st, computeBaselineResponse(st.schema, st.defaultValues).data, false);
+  seedOriginalsFromBaseline(
+    st,
+    computeBaseline(
+      st.schema,
+      st.defaultValues,
+      st.schema.getDefaultValues({ useDefaultSchemaValues: true })
+    )
+  );
 }
 function reset(st, nextDefaultValues) {
   const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
@@ -4432,33 +4880,35 @@ function reset(st, nextDefaultValues) {
     st.schema
   );
   st.defaultValues = structuralSnapshot(resetSource);
-  const resetResponse = computeBaselineResponse(st.schema, resetSource);
-  const next = resetResponse.data;
+  const next = computeBaseline(
+    st.schema,
+    resetSource,
+    st.schema.getDefaultValues({ useDefaultSchemaValues: true })
+  );
   rebuildAuthoredPaths(st, resetSource, next);
-  applyFormReplacement(st, next);
-  st.arrayIdentity.rebaselineAll();
-  st.removedSubtrees.clear();
-  seedOriginalsFromBaseline(st, next, false);
   if (nextDefaultValues !== void 0) {
     const mentioned = /* @__PURE__ */ new Set();
     walkAuthoredFromConstraints(nextDefaultValues, [], mentioned);
     for (const key of mentioned) st.originalBlankPaths.delete(key);
   }
+  const now = writeInstant(st);
+  applyFormReplacementWithPath(st, next, void 0, null, now);
+  st.arrayIdentity.rebaselineAll();
+  if (st.removedPaths.size > 0) {
+    const cleared = [...st.removedPaths.values()];
+    st.removedPaths.clear();
+    pulseStructure(st.structureSignal, cleared);
+  }
+  seedOriginalsFromBaseline(st, next);
   st.blankPaths.clear();
   for (const key of st.originalBlankPaths) {
     st.blankPaths.add(key);
   }
-  st.errorCells.clear();
-  if (!resetResponse.success) {
-    replaceErrorChannel(st, "schema", resetResponse.errors);
-  }
-  const syncResult = st.schema.validateAtPath(st.form.value, void 0, { sync: true });
-  if (!(syncResult instanceof Promise) && !syncResult.success) {
-    applySchemaErrorsForSubtree(st, [], syncResult.errors);
-  }
+  st.skipErrorSeed().clear();
+  replaceErrorChannel(st, "schema", st.schema.validateSync(next));
   st.firstValidationDone.value = initialFirstValidationGate(st.schema);
   queueInitialAsyncValidation(st);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  noteStamp(st, now);
   for (const [pathKey, record] of st.fields) {
     st.fields.set(pathKey, withClearedHistoryFlags(record, now));
   }
@@ -4487,6 +4937,7 @@ function reset(st, nextDefaultValues) {
 }
 function resetField(st, path) {
   const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
+  const now = writeInstant(st);
   st.variantMemory.clearUnderPath(targetSegments);
   cancelFieldValidationUnder(st, targetSegments);
   cancelTransformsUnder(st, targetSegments);
@@ -4495,9 +4946,21 @@ function resetField(st, path) {
     if (segs === null) continue;
     if (isPathPrefix(targetSegments, segs)) st.pathSnapshots.delete(snapKey);
   }
+  const cleared = [];
+  for (const [fieldKey, record] of Array.from(st.fields.entries())) {
+    if (!isPathPrefix(targetSegments, record.path)) continue;
+    st.fields.set(fieldKey, withClearedHistoryFlags(record, record.updatedAt));
+    cleared.push(fieldKey);
+  }
   const leafEntry = st.originals.get(targetKey);
   if (leafEntry !== void 0) {
-    const wrote = setValueAtPath(st, targetSegments, leafEntry.value);
+    const wrote = setValueAtPath(
+      st,
+      targetSegments,
+      structuralSnapshot(leafEntry.value),
+      void 0,
+      now
+    );
     if (!wrote) {
       console.error(
         `[attaform] resetField: leaf write rejected for path '${targetKey}'. Originals contain a value that doesn't satisfy the slim primitive shape. This is a bug in the construction pipeline.` 
@@ -4515,10 +4978,10 @@ function resetField(st, path) {
       if (subtree === void 0) {
         subtree = typeof relative[0] === "number" ? [] : {};
       }
-      subtree = setAtPath(subtree, relative, entry.value);
+      subtree = setAtPath(subtree, relative, structuralSnapshot(entry.value));
     }
     if (anyMatch) {
-      const wroteSubtree = setValueAtPath(st, targetSegments, subtree);
+      const wroteSubtree = setValueAtPath(st, targetSegments, subtree, void 0, now);
       if (!wroteSubtree) {
         console.error(
           `[attaform] resetField: subtree write rejected at path '${targetKey}'. Originals contain values that don't satisfy the slim primitive shape. This is a bug in the construction pipeline.` 
@@ -4527,12 +4990,18 @@ function resetField(st, path) {
     }
   }
   deleteErrorCellsUnderPrefix(st, targetSegments);
-  for (const [fieldKey, record] of Array.from(st.fields.entries())) {
-    if (isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(st, fieldKey);
+  const raw = toRaw(st.form.value);
+  for (const fieldKey of cleared) {
+    const record = st.fields.get(fieldKey);
+    if (record === void 0 || !hasAtPath(raw, record.path)) continue;
+    raiseStamp(st, fieldKey, record.path, now);
+  }
+  if (cleared.length > 0 && hasAtPath(raw, targetSegments)) {
+    stampContainers(st, [targetSegments], now);
   }
 }
 function deleteErrorCellsUnderPrefix(st, prefix) {
-  for (const [errorKey, cell] of st.errorCells) {
+  for (const [errorKey, cell] of st.errorCells()) {
     for (const src of ERROR_SOURCES) {
       const first = cell[src][0];
       if (first !== void 0 && isPathPrefix(prefix, first.path)) {
@@ -4541,36 +5010,35 @@ function deleteErrorCellsUnderPrefix(st, prefix) {
     }
   }
 }
-function clearFieldRecordFlags(st, pathKey) {
-  const record = st.fields.get(pathKey);
-  if (record === void 0) return;
-  st.fields.set(pathKey, withClearedHistoryFlags(record, (/* @__PURE__ */ new Date()).toISOString()));
-}
 function isPristineAtPathByKey(st, key, segments) {
   if (st.blankPaths.has(key) !== st.originalBlankPaths.has(key)) return false;
   const entry = st.originals.get(key);
   if (entry === void 0) return true;
   return Object.is(getAtPath(st.form.value, segments), entry.value);
 }
-function hasStructuralChangeUnder(st, path) {
+function hasStructuralChangeUnder(st, path, key) {
+  subscribeStructure(st.structureSignal, key);
   return st.arrayIdentity.hasStructuralChangeUnder(path);
 }
-function subtreeHadRealBaseline(st, prefix, removedValue) {
-  let had = false;
-  diffAndApply(removedValue, void 0, prefix, (patch) => {
-    if (had || patch.kind !== "removed") return;
-    const record = st.originals.get(canonicalizePath(patch.path).key);
-    if (record?.value !== void 0) had = true;
+function pulseStructure(signal, paths) {
+  const keys = signal.keys;
+  if (keys === null) return;
+  eachAncestorOnce(paths, (key) => {
+    keys.add(key);
+    keys.delete(key);
   });
-  return had;
 }
-function hasRemovedSubtreeUnder(st, prefix) {
-  if (st.removedSubtrees.size === 0) return false;
-  for (const key of st.removedSubtrees) {
-    const segments = segmentsForPathKey(key);
-    if (segments === null) continue;
+function subscribeStructure(signal, key) {
+  signal.keys ?? (signal.keys = shallowReactive(/* @__PURE__ */ new Set()));
+  void signal.keys.has(key);
+}
+function hasRemovedSubtreeUnder(st, prefix, key) {
+  subscribeStructure(st.structureSignal, key);
+  if (st.removedPaths.size === 0) return false;
+  const raw = toRaw(st.form.value);
+  for (const segments of st.removedPaths.values()) {
     if (!isPathPrefix(prefix, segments)) continue;
-    if (isContainer(getAtPath(toRaw(st.form.value), segments))) continue;
+    if (hasAtPath(raw, segments)) continue;
     return true;
   }
   return false;
@@ -4597,8 +5065,8 @@ function createFormStore(options) {
   const fieldValidatingSince = reactive(/* @__PURE__ */ new Map());
   const displayEngine = createDisplayEngine(ssr);
   cleanupHooks.push(() => displayEngine.dispose());
-  const schemaResponse = computeBaselineResponse(schema, defaultValues);
-  const schemaInitialData = schemaResponse.data;
+  const ownDefaultValues = structuralSnapshot(defaultValues);
+  const schemaInitialData = computeBaseline(schema, ownDefaultValues, options.schemaDefaults);
   const authoredPaths = /* @__PURE__ */ new Set();
   const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
   const hasDU = schema.hasDiscriminatedUnions?.() !== false;
@@ -4606,15 +5074,23 @@ function createFormStore(options) {
     warn: true
   }) : initialData;
   const form = ref(stubbedInitialData);
-  const arrayIdentity = createArrayIdentity((arraySegs) => {
-    const v = getAtPath(toRaw(form.value), arraySegs);
-    return Array.isArray(v) ? v.length : 0;
-  });
+  const structureSignal = { keys: null };
+  const arrayIdentity = createArrayIdentity(
+    (arraySegs) => {
+      const v = getAtPath(toRaw(form.value), arraySegs);
+      return Array.isArray(v) ? v.length : 0;
+    },
+    (arrayPaths) => pulseStructure(structureSignal, arrayPaths)
+  );
   const fields = shallowReactive(/* @__PURE__ */ new Map());
   const domBinding = shallowRef(null);
-  const errorCells = shallowReactive(/* @__PURE__ */ new Map());
+  const errorStore = createErrorCells(
+    schema,
+    hydration === void 0 ? schemaInitialData : void 0
+  );
+  const errorCells = () => errorStore(true);
   const originals = shallowReactive(/* @__PURE__ */ new Map());
-  const removedSubtrees = /* @__PURE__ */ new Set();
+  const removedPaths = /* @__PURE__ */ new Map();
   const blankPaths = reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
   const seededBlankPaths = hydration !== void 0 ? (hydration.blankPaths ?? []).map((dotted) => canonicalizePath(dotted).key) : options.initialBlankPaths ?? [];
@@ -4636,7 +5112,7 @@ function createFormStore(options) {
     return result;
   });
   const errorPathIndex = computed(
-    () => buildErrorPathIndex(errorCells, derivedBlankErrors.value)
+    () => buildErrorPathIndex(errorCells(), derivedBlankErrors.value)
   );
   const submitting = ref(false);
   const activeSubmissions = ref(0);
@@ -4723,6 +5199,8 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     authoredPaths,
+    removedPaths,
+    notifyStructure: (paths) => pulseStructure(structureSignal, paths),
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -4730,6 +5208,9 @@ function createFormStore(options) {
     arrayIdentity,
     variantMemory,
     touchFieldRecord: (pathKey, path, patch) => touchFieldRecord(st, pathKey, path, patch),
+    stampContainers: (containers, now) => stampContainers(st, containers, now),
+    stampBareContainers: (patches, bare, now) => stampBareContainers(st, patches, bare, now),
+    foldInteractionHistory: (path, released) => foldInteractionHistory(st, path, released),
     decFieldValidation: (key) => decFieldValidation(st, key)
   });
   const bind = (fn) => (...args) => fn(st, ...args);
@@ -4776,18 +5257,16 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     // --- kernel-internal state ---
-    // A defensive copy. `getDefaultValues` building a fresh tree is an adapter
-    // implementation detail, not a contract, and this field is durable state
-    // that every `reset()` reads, so it must not depend on one. The copy also
-    // stops a consumer holding a reference to the literal they passed from
-    // mutating the form's defaults from outside. `reset()` snapshots for a
-    // harder reason, where an alias IS reachable.
-    defaultValues: structuralSnapshot(defaultValues),
+    // The copy taken above, which also stops a consumer holding a reference to
+    // the literal they passed from mutating the form's defaults from outside.
+    // `reset()` snapshots for a harder reason, where an alias IS reachable.
+    defaultValues: ownDefaultValues,
     ssrPrefetch,
     rememberVariants,
     fieldValidationMode,
     fieldValidationDebounceMs,
     hasDU,
+    hasPreprocessOrCoerce: schema.hasPreprocessOrCoerce?.() !== false,
     fieldValidationState,
     formChangeListeners,
     submitSuccessListeners,
@@ -4795,7 +5274,8 @@ function createFormStore(options) {
     cleanupHooks,
     authoredPaths,
     arrayIdentity,
-    removedSubtrees,
+    removedPaths,
+    structureSignal,
     variantMemory,
     pathOrdinals,
     pathSnapshots,
@@ -4803,7 +5283,9 @@ function createFormStore(options) {
     transformRuns,
     transformWaiters,
     arrayBookkeeping,
+    skipErrorSeed: () => errorStore(false),
     nextOrdinal: 0,
+    latestStamp: "",
     scheduleEpoch: 0,
     lastCommittedEpoch: 0,
     transformTokenSeq: 0,
@@ -4841,6 +5323,8 @@ function createFormStore(options) {
     ),
     clearUserErrors: (path) => clearErrorChannel(st, "user", path),
     restoreErrorCells: bind(restoreErrorCells),
+    captureStructure: bind(captureStructure),
+    restoreStructure: bind(restoreStructure),
     getErrorsForPath: bind(getErrorsForPath),
     ensurePathOrdinal: bind(ensurePathOrdinal),
     noteDomConnected: bind(noteDomConnected),
@@ -4870,7 +5354,26 @@ function createFormStore(options) {
     dispose: bind(dispose)
   };
   rebuildAuthoredPaths(st, defaultValues, schemaInitialData);
-  seedOriginalsFromBaseline(st, schemaInitialData, true);
+  const initStamp = (/* @__PURE__ */ new Date()).toISOString();
+  diffAndApply({}, schemaInitialData, [], (patch) => {
+    if (patch.kind !== "added") return;
+    const { key } = canonicalizePath(patch.path);
+    if (seedBaseline(originals, key, patch)) return;
+    ensurePathOrdinal(st, key);
+    if (hydration === void 0) {
+      fields.set(key, {
+        path: patch.path,
+        updatedAt: initStamp,
+        connected: false,
+        focused: null,
+        blurred: null,
+        touched: false,
+        interacted: false,
+        blurredAfterInteraction: false
+      });
+    }
+  });
+  if (fields.size > 0) noteStamp(st, initStamp);
   if (hydration !== void 0) {
     for (const [rawKey, record] of hydration.fields) {
       if (typeof rawKey !== "string" || !isHydratedFieldRecord(record)) {
@@ -4878,6 +5381,7 @@ function createFormStore(options) {
         continue;
       }
       fields.set(rawKey, record);
+      noteStamp(st, record.updatedAt);
     }
     for (const [rawKey, errs] of hydration.schemaErrors) {
       if (typeof rawKey !== "string" || !isHydratedValidationErrorArray(errs)) {
@@ -4893,25 +5397,6 @@ function createFormStore(options) {
       }
       setErrorChannelForKey(st, rawKey, "user", errs);
     }
-  } else {
-    const initStamp = (/* @__PURE__ */ new Date()).toISOString();
-    diffAndApply({}, initialData, [], (patch) => {
-      if (patch.kind !== "added") return;
-      const { key } = canonicalizePath(patch.path);
-      fields.set(key, {
-        path: patch.path,
-        updatedAt: initStamp,
-        connected: false,
-        focused: null,
-        blurred: null,
-        touched: false,
-        interacted: false,
-        blurredAfterInteraction: false
-      });
-    });
-    if (!schemaResponse.success) {
-      replaceErrorChannel(st, "schema", schemaResponse.errors);
-    }
   }
   queueInitialAsyncValidation(st);
   return st;
@@ -5009,9 +5494,11 @@ const HISTORY_MODULE_KEY = "history";
 function buildFreshState(key, schema, configuration, registry) {
   const pending = registry.pendingHydration.get(key);
   if (pending !== void 0) registry.pendingHydration.delete(key);
+  const schemaDefaults = schema.getDefaultValues({ useDefaultSchemaValues: true });
   const walked = walkUnsetSentinels(
     configuration.defaultValues,
-    schema
+    schema,
+    schemaDefaults
   );
   let initialBlankPaths;
   if (pending === void 0) {
@@ -5021,6 +5508,7 @@ function buildFreshState(key, schema, configuration, registry) {
     formKey: key,
     schema,
     defaultValues: walked.cleanedValues,
+    schemaDefaults,
     hydration: pending,
     ssr: registry.ssr,
     ...pickDefined({
@@ -5084,6 +5572,7 @@ function resolveFormKey(key) {
 }
 
 let injectedInstanceCounter = 0;
+const sharedApis = /* @__PURE__ */ new WeakMap();
 function injectForm(input) {
   const key = typeof input === "string" ? input : input?.key;
   const ssrAccessed = typeof input === "object" && input !== null ? input.__ssrAccessed === true : false;
@@ -5106,12 +5595,37 @@ function injectForm(input) {
     apiOptions.history = history;
   }
   const ambientInstanceId = getCurrentInstance() !== null ? inject(kFormInstanceId, null) : null;
-  const formInstanceId = ambientInstanceId ?? (getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
-  return buildFormApi(
+  const api = ambientInstanceId !== null ? shareApi(state, ambientInstanceId, apiOptions) : buildFormApi(
     state,
-    formInstanceId,
+    getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`,
     apiOptions
   );
+  return api;
+}
+function shareApi(state, formInstanceId, options) {
+  let instances = sharedApis.get(state);
+  if (instances === void 0) {
+    instances = /* @__PURE__ */ new Map();
+    sharedApis.set(state, instances);
+  }
+  const byInstance = instances;
+  let shared = byInstance.get(formInstanceId);
+  if (shared === void 0) {
+    const scope = effectScope(true);
+    const api = scope.run(() => buildFormApi(state, formInstanceId, options));
+    if (api === void 0) return buildFormApi(state, formInstanceId, options);
+    shared = { api, scope, users: 0 };
+    byInstance.set(formInstanceId, shared);
+  }
+  const entry = shared;
+  entry.users += 1;
+  onScopeDispose(() => {
+    entry.users -= 1;
+    if (entry.users > 0) return;
+    entry.scope.stop();
+    byInstance.delete(formInstanceId);
+  });
+  return entry.api;
 }
 function resolveState(key, registry) {
   if (key !== void 0) {
@@ -5206,22 +5720,23 @@ function useRegister(options) {
   const capturedRegisterValue = shallowRef(void 0);
   const refreshAndStripBridgeAttrs = () => {
     const rawAttrs = instance.attrs;
+    const parentBinding = instance.vnode.dirs?.find(
+      (dir) => dir.dir?.[V_REGISTER_MARKER] === true
+    );
     if ("registerValue" in rawAttrs) {
       capturedRegisterValue.value = rawAttrs["registerValue"];
       delete rawAttrs["registerValue"];
-      if (capturedRegisterValue.value !== void 0) armDomBinding(capturedRegisterValue.value);
-    } else {
-      const dirs = instance.vnode.dirs;
-      if (dirs !== null && dirs !== void 0) {
-        for (const dir of dirs) {
-          const marked = dir.dir?.[V_REGISTER_MARKER];
-          if (marked === true) {
-            capturedRegisterValue.value = dir.value;
-            if (capturedRegisterValue.value !== void 0)
-              armDomBinding(capturedRegisterValue.value);
-            break;
-          }
-        }
+    } else if (parentBinding !== void 0) {
+      capturedRegisterValue.value = parentBinding.value;
+    }
+    const captured = capturedRegisterValue.value;
+    if (captured !== void 0) {
+      armDomBinding(captured);
+      if (parentBinding !== void 0) {
+        recordInheritedModifiers(
+          captured,
+          withInheritedModifiers(parentBinding.value, parentBinding.modifiers)
+        );
       }
     }
     if ("value" in rawAttrs) delete rawAttrs["value"];
@@ -5347,11 +5862,11 @@ const NOOP_SUCCESS = {
   data: EMPTY_VALUE,
   errors: void 0
 };
-const NOOP_DEFAULTS = NOOP_SUCCESS;
 let NOOP_SCHEMA;
 function buildNoopWizardSchema() {
   NOOP_SCHEMA ?? (NOOP_SCHEMA = {
-    getDefaultValues: () => NOOP_DEFAULTS,
+    getDefaultValues: () => EMPTY_VALUE,
+    validateSync: () => [],
     getDefaultAtPath: () => void 0,
     getEmptyValueAtPath: () => void 0,
     isPreprocessOrCoerceLeaf: () => false,
@@ -5367,7 +5882,8 @@ function buildNoopWizardSchema() {
     isLeafAtPath: () => false,
     isRequiredAtPath: () => false,
     getUnionDiscriminatorAtPath: () => void 0,
-    hasDiscriminatedUnions: () => false
+    hasDiscriminatedUnions: () => false,
+    hasPreprocessOrCoerce: () => false
   });
   return NOOP_SCHEMA;
 }
@@ -5443,7 +5959,7 @@ function buildWizardStatusesProxy(statuses) {
     // resolves to `undefined` (consistent with property-access).
     resolveCall: (arg) => statuses[String(arg)]?.value,
     ownKeys: () => Object.keys(statuses),
-    hasKey: (key) => Object.hasOwn(statuses, key)
+    hasKey: (key) => safeOwnHas(statuses, key)
   });
 }
 
@@ -6371,7 +6887,7 @@ function useWizard(options) {
     for (const key of keys) {
       const store = registry.forms.get(key);
       if (store === void 0) continue;
-      for (const cell of store.errorCells.values()) {
+      for (const cell of store.errorCells().values()) {
         for (const err of cell.user) out.push(toWizardAggregateError(err, key));
       }
     }