attaform 0.31.0 → 0.31.2

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

@@ -1,82 +1,10 @@
 import { computed, readonly, toRaw, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, reactive, shallowReactive, shallowRef, toValue, watch, triggerRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, onBeforeMount, onBeforeUpdate, onMounted, nextTick } from 'vue';
-import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.C4shmwyJ.mjs';
-import { c as armDomBinding, r as recordInheritedModifiers, w as withInheritedModifiers } from './attaform.DxKQsqFZ.mjs';
+import { e as ensureAttaformInstalled, u as useRegistry, d as kFormContext, f as kFormInstanceId, b as kAttaformWizardActiveStepResolver, i as kAttaformAncestorWizard } from './attaform.CdA9bfRv.mjs';
+import { c as armDomBinding, r as recordInheritedModifiers, w as withInheritedModifiers } from './attaform.T0YjhjPU.mjs';
 import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
-import { A as ANONYMOUS_FORM_KEY_PREFIX, i as isShadowedKey, d as safeOwnHas, a as safeOwnRead, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray, r as readConsumerIndex, b as safeAssign, h as consumerKeys, j as readConsumerProp, k as diffAndApply, p as pickDefined, s as structuralSnapshot, n as normalizeNumericOption, l as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, m as consumerSymbolKeys, o as applyChangedKeys, R as RESERVED_KEY_PREFIX, q as DEFAULT_MAX_RECURSION_DEPTH, c as callConsumerFn, t as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.8mfKZCwH.mjs';
-import { i as isPathPrefix, e as canonicalizePath, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, s as segmentsForPathKey, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform.CdZIEf7_.mjs';
-
-const AttaformErrorCode = {
-  /** A required field is in the blank set: no value was supplied. */
-  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",
-  /**
-   * Default code stamped on a manual error set through `form.setErrors`
-   * when the caller omits an explicit `code`. The `setErrors` input is
-   * lenient (`code` optional), so this is the fallback that keeps every
-   * produced `ValidationError` carrying a stable, branchable identifier.
-   * Override it per error by passing your own `code` (`api:…`, `auth:…`).
-   */
-  UserError: "atta:user-error",
-  /**
-   * Stamped on a `ValidationError` synthesized from a throw or rejection
-   * out of a `handleSubmit` `onSubmit` callback. The raw error also lands
-   * on `form.meta.submitError` (a raw-`Error` inspection channel); this
-   * code marks the copy piped into the user-error layer so the failure
-   * also surfaces on `form.errors` / `meta.ownErrors` / `firstOwnError`
-   * where the UI already reads. A throw carrying its own `path` / `code`
-   * keeps them; a bare `Error` or a non-Error throw defaults here at the
-   * form-level path `[]`.
-   */
-  SubmitError: "atta:submit-error",
-  /**
-   * Synthesized by `wizard.handleSubmit` when the whole-wizard submit
-   * would otherwise succeed but a `gate()` step is still uncleared. A
-   * gate clears only on its member form's clean submit (confirmation), so
-   * a downstream step that happens to be valid-by-default must not let the
-   * wizard finish past an unconfirmed prerequisite. Emitted at the gate
-   * form's key (path `[]`) so the aggregate error pipeline routes focus to
-   * the gate, and `done` never latches.
-   */
-  GateNotCleared: "atta:gate-not-cleared"
-};
-function makeBlankRequiredError(segments) {
-  return {
-    message: "No value supplied",
-    path: [...segments],
-    code: AttaformErrorCode.NoValueSupplied
-  };
-}
-const NO_ERRORS = Object.freeze([]);
+import { a as ANONYMOUS_FORM_KEY_PREFIX, g as getAtPath, i as isPlainRecord, h as hasAtPath, b as makeBlankRequiredError, A as AttaformErrorCode, p as pickDefined, c as buildFieldArrayApi, s as structuralSnapshot, n as normalizeNumericOption, d as DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS, e as diffAndApply, f as mergeStructural, N as NO_ERRORS, j as createArrayBookkeeping, k as createVariantMemory, l as createArrayIdentity, o as isDescendable, q as migrateFieldRecords, r as setAtPath, t as remapForOp, u as isBarePatch, v as applyChangedKeys, w as cloneVariantSnapshot, x as setAtPathWithSchemaFill, y as tryInPlaceLeafWrite, R as RESERVED_KEY_PREFIX, z as DEFAULT_MAX_RECURSION_DEPTH, B as ANONYMOUS_WIZARD_KEY_PREFIX } from './attaform.CgyyJVuq.mjs';
+import { e as canonicalizePath, i as isPathPrefix, f as pathsEqual, k as keyForSegments, m as mapSegmentKeys, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, j as groupErrorsByKey, s as segmentsForPathKey, n as normalizeErrorInput, h as SET_MEMBER_SEGMENT, R as ROOT_PATH, l as normalizeErrorInputs, a as InvalidUseFormConfigError, d as ReservedFormKeyError } from './attaform.BhtAZysa.mjs';
+import { r as readConsumerIndex, c as consumerKeys, b as readConsumerProp, d as safeOwnHas, i as isShadowedKey, s as safeAssign, a as safeOwnRead, h as callConsumerFn, j as consumerExtensible, k as consumerSymbolKeys } from './attaform.BNUhW4qC.mjs';
 
 function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
@@ -142,7 +70,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) {
@@ -176,323 +104,6 @@ function humanize(segment) {
   }).join(" ");
 }
 
-const NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
-function mapKeyForSegment(map, segment, declared) {
-  if (map.has(segment)) return segment;
-  if (typeof segment !== "number") return segment;
-  const asString = String(segment);
-  if (map.has(asString)) return asString;
-  return declared === "string" ? asString : segment;
-}
-function isRebuildableContainer(root, segment) {
-  if (root === null || root === void 0 || typeof root !== "object") return true;
-  return typeof segment === "number" ? Array.isArray(root) : isPlainRecord(root);
-}
-function descendStep(value, segment) {
-  if (value === null || value === void 0) return NOT_FOUND;
-  if (typeof value !== "object") return NOT_FOUND;
-  if (Array.isArray(value)) {
-    if (typeof segment !== "number") return NOT_FOUND;
-    if (!(segment in value)) return NOT_FOUND;
-    return value[segment];
-  }
-  if (value instanceof Map) {
-    const key2 = mapKeyForSegment(value, segment);
-    if (!value.has(key2)) return NOT_FOUND;
-    return value.get(key2);
-  }
-  const record = value;
-  const key = typeof segment === "number" ? String(segment) : segment;
-  if (isShadowedKey(key)) {
-    if (!safeOwnHas(record, key)) return NOT_FOUND;
-    return safeOwnRead(record, key);
-  }
-  if (!(key in record)) return NOT_FOUND;
-  return record[key];
-}
-function getAtPath(root, path) {
-  if (path.length === 0) return root;
-  try {
-    let current = root;
-    for (const segment of path) {
-      const next = descendStep(current, segment);
-      if (next === NOT_FOUND) return void 0;
-      current = next;
-    }
-    return current;
-  } catch {
-    return void 0;
-  }
-}
-function hasAtPath(root, path) {
-  if (path.length === 0) return true;
-  try {
-    return hasAtPathUnguarded(root, path);
-  } catch {
-    return false;
-  }
-}
-function hasAtPathUnguarded(root, path) {
-  let current = root;
-  for (let i = 0; i < path.length - 1; i++) {
-    const segment = path[i];
-    const next = descendStep(current, segment);
-    if (next === NOT_FOUND) return false;
-    current = next;
-  }
-  const last = path[path.length - 1];
-  if (current === null || current === void 0) return false;
-  if (typeof current !== "object") return false;
-  if (Array.isArray(current)) {
-    return typeof last === "number" && consumerHas(current, last);
-  }
-  if (current instanceof Map) {
-    return current.has(mapKeyForSegment(current, last));
-  }
-  const key = typeof last === "number" ? String(last) : last;
-  if (isShadowedKey(key)) return safeOwnHas(current, key);
-  return consumerHas(current, key);
-}
-function isPlainRecord(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
-}
-const NO_SCHEMA_DEFAULTS = /* @__PURE__ */ new Set();
-const NO_SCHEMA_FILL = {
-  getDefaultAtPath: () => void 0,
-  arrayShapeAtPath: () => null,
-  getSlimPrimitiveTypesAtPath: () => NO_SCHEMA_DEFAULTS,
-  entryKeyKindAtPath: () => void 0
-};
-function setAtPath(root, path, value) {
-  return setAtPathWithSchemaFill(root, NO_SCHEMA_FILL, path, value);
-}
-const NO_IN_PLACE = { applied: false };
-function tryInPlaceLeafWrite(root, path, value) {
-  if (path.length === 0) return NO_IN_PLACE;
-  try {
-    return descendAndWrite(root, path, value);
-  } catch {
-    return NO_IN_PLACE;
-  }
-}
-function descendAndWrite(root, path, value) {
-  let node = root;
-  for (let i = 0; i < path.length; i++) {
-    const seg = path[i];
-    if (node instanceof Map) return NO_IN_PLACE;
-    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 mergeStructural(schema, path, consumer, defaultValue = schema.getDefaultAtPath(path)) {
-  const scratch = path.slice();
-  return mergeStructuralImpl(schema, scratch, consumer, defaultValue);
-}
-function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
-  if (consumer === void 0) {
-    if (schema.getSlimPrimitiveTypesAtPath(scratch).has("undefined")) {
-      return void 0;
-    }
-    return defaultValue;
-  }
-  if (consumer === null) return null;
-  if (Array.isArray(consumer)) {
-    return mergeStructuralArray(schema, scratch, consumer);
-  }
-  if (consumer instanceof Map) {
-    return mergeStructuralMap(schema, scratch, consumer);
-  }
-  if (isPlainRecord(consumer)) {
-    if (!isPlainRecord(defaultValue)) {
-      return consumer;
-    }
-    const out = spreadConsumerRecord(consumer);
-    const filledAny = fillMissingKeysFromDefault(schema, scratch, consumer, defaultValue, out);
-    const recursedAny = recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out);
-    return filledAny || recursedAny ? out : consumer;
-  }
-  return consumer;
-}
-function mergeStructuralMap(schema, scratch, consumer) {
-  if (consumer.size === 0) return consumer;
-  let entryDefault;
-  let entryDefaultRead = false;
-  let out = null;
-  for (const [key, entry] of consumer) {
-    if (typeof key !== "string" && typeof key !== "number") continue;
-    scratch.push(key);
-    if (!entryDefaultRead) {
-      entryDefault = schema.getDefaultAtPath(scratch);
-      entryDefaultRead = true;
-    }
-    const merged = mergeStructuralImpl(schema, scratch, entry, entryDefault);
-    scratch.pop();
-    if (merged === entry) continue;
-    out ?? (out = new Map(consumer));
-    out.set(key, merged);
-  }
-  return out ?? consumer;
-}
-function mergeStructuralArray(schema, scratch, consumer) {
-  const shape = schema.arrayShapeAtPath(scratch);
-  const isTuple = typeof shape === "number";
-  const targetLen = isTuple ? shape : consumer.length;
-  let cachedElementDefault;
-  let cachedElementDefaultRead = false;
-  let mutated = targetLen > consumer.length;
-  const out = copyConsumerArray(consumer);
-  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 ? readConsumerIndex(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;
-}
-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 filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
-      scratch.pop();
-      if (filled !== void 0) {
-        safeAssign(out, key, filled);
-        mutated = true;
-      }
-    }
-  }
-  return mutated;
-}
-function recurseIntoConsumerKeys(schema, scratch, consumer, defaultValue, out) {
-  let mutated = false;
-  for (const key of consumerKeys(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;
-  return setAtPathWithSchemaFillImpl(root, schema, fullPath, value, 0);
-}
-function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
-  if (startIdx >= fullPath.length) return value;
-  const head = fullPath[startIdx];
-  const isLeafStep = startIdx === fullPath.length - 1;
-  if (root instanceof Map) {
-    const next = new Map(root);
-    const key = mapKeyForSegment(root, head, schema.entryKeyKindAtPath(fullPath.slice(0, startIdx)));
-    if (isLeafStep) {
-      next.set(key, value);
-      return next;
-    }
-    let childRoot2 = next.get(key);
-    if (childRoot2 === void 0 || childRoot2 !== null && typeof childRoot2 !== "object") {
-      childRoot2 = schema.getDefaultAtPath(fullPath.slice(0, startIdx + 1));
-    }
-    next.set(key, setAtPathWithSchemaFillImpl(childRoot2, schema, fullPath, value, startIdx + 1));
-    return next;
-  }
-  if (!isRebuildableContainer(root, head)) return root;
-  if (typeof head === "number") {
-    const arr = Array.isArray(root) ? [...root] : [];
-    const prefix = fullPath.slice(0, startIdx);
-    if (arr.length < head) {
-      const scratch = prefix.slice();
-      const shape = schema.arrayShapeAtPath(scratch);
-      const tupleLike = typeof shape === "number";
-      let cachedArrayDefault;
-      if (!tupleLike) {
-        scratch.push(0);
-        cachedArrayDefault = schema.getDefaultAtPath(scratch);
-        scratch.pop();
-      }
-      while (arr.length < head) {
-        const idx = arr.length;
-        if (tupleLike) {
-          scratch.push(idx);
-          arr.push(schema.getDefaultAtPath(scratch));
-          scratch.pop();
-        } else {
-          arr.push(cachedArrayDefault);
-        }
-      }
-    }
-    if (isLeafStep) {
-      arr[head] = value;
-      return arr;
-    }
-    let childRoot2 = arr[head];
-    if (childRoot2 === void 0 || childRoot2 !== null && typeof childRoot2 !== "object") {
-      childRoot2 = schema.getDefaultAtPath([...prefix, head]);
-    }
-    arr[head] = setAtPathWithSchemaFillImpl(childRoot2, schema, fullPath, value, startIdx + 1);
-    return arr;
-  }
-  const rec = isPlainRecord(root) ? { ...root } : {};
-  if (isLeafStep) {
-    safeAssign(rec, head, value);
-    return rec;
-  }
-  const existing = safeOwnRead(rec, head);
-  let childRoot;
-  if (existing === void 0 || existing !== null && typeof existing !== "object") {
-    const intermPath = [...fullPath.slice(0, startIdx + 1)];
-    const intermDefault = schema.getDefaultAtPath(intermPath);
-    childRoot = intermDefault;
-  } else {
-    childRoot = existing;
-  }
-  safeAssign(
-    rec,
-    head,
-    setAtPathWithSchemaFillImpl(childRoot, schema, fullPath, value, startIdx + 1)
-  );
-  return rec;
-}
-
 function isUnderStubAncestor(state, segments) {
   for (let i = 0; i < segments.length; i++) {
     const ancestorPath = segments.slice(0, i);
@@ -628,7 +239,6 @@ function visitActiveLeafPaths(value, base, visit) {
 function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   const formValue = state.form.value;
   const value = getAtPath(formValue, segments);
-  const original = state.originals.get(key)?.value;
   let pristine = true;
   let blank = true;
   let dirty = false;
@@ -646,6 +256,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);
@@ -655,6 +266,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;
@@ -689,22 +302,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;
@@ -726,6 +345,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;
@@ -734,7 +355,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   return {
     base: {
       value,
-      original,
+      original: state.getOriginalAtPath(segments),
       pristine,
       dirty,
       focused,
@@ -817,9 +438,41 @@ 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 buckets = /* @__PURE__ */ new Map();
@@ -832,19 +485,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([]);
 
@@ -876,7 +526,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;
@@ -1402,406 +1052,6 @@ function buildValuesSurface(form, onFormChange) {
   });
 }
 
-function remapForOp(op, oldLen) {
-  const moved = /* @__PURE__ */ new Map();
-  const vacated = /* @__PURE__ */ new Set();
-  const fresh = /* @__PURE__ */ new Set();
-  let newLen = oldLen;
-  switch (op.kind) {
-    case "insert":
-      for (let i = op.index; i < oldLen; i++) moved.set(i, i + 1);
-      fresh.add(op.index);
-      newLen = oldLen + 1;
-      break;
-    case "remove":
-      vacated.add(op.index);
-      for (let i = op.index + 1; i < oldLen; i++) moved.set(i, i - 1);
-      newLen = Math.max(0, oldLen - 1);
-      break;
-    case "move":
-      if (op.from !== op.to) {
-        moved.set(op.from, op.to);
-        if (op.from < op.to) {
-          for (let i = op.from + 1; i <= op.to; i++) moved.set(i, i - 1);
-        } else {
-          for (let i = op.to; i < op.from; i++) moved.set(i, i + 1);
-        }
-      }
-      break;
-    case "swap":
-      if (op.a !== op.b) {
-        moved.set(op.a, op.b);
-        moved.set(op.b, op.a);
-      }
-      break;
-    case "replace-at":
-      vacated.add(op.index);
-      fresh.add(op.index);
-      break;
-  }
-  return { moved, vacated, fresh, oldLen, newLen };
-}
-function changedIndices(remap) {
-  const changed = new Set(remap.vacated);
-  for (const [from, to] of remap.moved) {
-    changed.add(from);
-    changed.add(to);
-  }
-  for (const index of remap.fresh) changed.add(index);
-  return changed;
-}
-function permuteList(list, remap, fill) {
-  const claimed = new Array(remap.newLen);
-  for (let i = 0; i < remap.oldLen; i++) {
-    if (remap.vacated.has(i)) continue;
-    const to = remap.moved.get(i) ?? i;
-    if (to < remap.newLen) claimed[to] = list[i];
-  }
-  const next = [];
-  for (let i = 0; i < remap.newLen; i++) {
-    next.push(claimed[i] ?? fill());
-  }
-  return next;
-}
-function elementIndexUnder(arrayPath, key, idxPos) {
-  const segments = segmentsForPathKey(key);
-  if (segments === null) return null;
-  if (!isPathPrefix(arrayPath, segments)) return null;
-  if (segments.length <= idxPos) return null;
-  const index = segments[idxPos];
-  return typeof index === "number" ? index : null;
-}
-function collectKeysAtIndices(keys, arrayPath, member) {
-  const idxPos = arrayPath.length;
-  const hits = [];
-  for (const key of keys) {
-    const index = elementIndexUnder(arrayPath, key, idxPos);
-    if (index === null || !member(index)) continue;
-    const segments = segmentsForPathKey(key);
-    if (segments === null) continue;
-    hits.push({ key, segments: [...segments], index });
-  }
-  return hits;
-}
-function remapAffects(remap) {
-  return (index) => remap.moved.has(index) || remap.vacated.has(index) || remap.fresh.has(index);
-}
-function migrateMapSubtree(map, arrayPath, remap, rewriteValue) {
-  const hits = collectKeysAtIndices(map.keys(), arrayPath, remapAffects(remap));
-  if (hits.length === 0) return;
-  const idxPos = arrayPath.length;
-  const snapshots = [];
-  for (const hit of hits) {
-    const value = map.get(hit.key);
-    if (value !== void 0) snapshots.push({ ...hit, value });
-  }
-  for (const snap of snapshots) map.delete(snap.key);
-  for (const snap of snapshots) {
-    const target = remap.moved.get(snap.index);
-    if (target === void 0) continue;
-    const relocated = snap.segments.slice();
-    relocated[idxPos] = target;
-    map.set(canonicalizePath(relocated).key, rewriteValue(snap.value, relocated));
-  }
-}
-function migrateSetSubtree(set, arrayPath, remap) {
-  const hits = collectKeysAtIndices(set, arrayPath, remapAffects(remap));
-  if (hits.length === 0) return;
-  const idxPos = arrayPath.length;
-  for (const hit of hits) set.delete(hit.key);
-  for (const hit of hits) {
-    const target = remap.moved.get(hit.index);
-    if (target === void 0) continue;
-    const relocated = hit.segments.slice();
-    relocated[idxPos] = target;
-    set.add(canonicalizePath(relocated).key);
-  }
-}
-function evictSchemaVerdictsAtIndices(errorCells, arrayPath, indices) {
-  for (const hit of collectKeysAtIndices(
-    [...errorCells.keys()],
-    arrayPath,
-    (index) => indices.has(index)
-  )) {
-    const cell = errorCells.get(hit.key);
-    if (cell === void 0) continue;
-    if (cell.user.length === 0) errorCells.delete(hit.key);
-    else if (cell.schema.length > 0) errorCells.set(hit.key, { schema: NO_ERRORS, user: cell.user });
-  }
-}
-function deleteKeysAtIndices(keys, del, arrayPath, indices) {
-  for (const hit of collectKeysAtIndices(keys, arrayPath, (index) => indices.has(index))) {
-    del(hit.key);
-  }
-}
-function createArrayIdentity(getArrayLength) {
-  const tokens = /* @__PURE__ */ new Map();
-  const baselines = /* @__PURE__ */ new Map();
-  let counter = 0;
-  const allocate = () => `k${(counter++).toString(36)}`;
-  function ensure(arrayKey, expectedLen) {
-    let ids = tokens.get(arrayKey);
-    const firstTrack = ids === void 0;
-    if (ids === void 0) {
-      ids = [];
-      tokens.set(arrayKey, ids);
-    }
-    while (ids.length < expectedLen) ids.push(allocate());
-    if (ids.length > expectedLen) ids.length = expectedLen;
-    if (firstTrack) baselines.set(arrayKey, [...ids]);
-    return ids;
-  }
-  function orderPristineForKey(arrayKey) {
-    const baseline = baselines.get(arrayKey);
-    const current = tokens.get(arrayKey);
-    if (baseline === void 0 || current === void 0) return true;
-    if (baseline.length !== current.length) return false;
-    for (let i = 0; i < current.length; i++) {
-      if (current[i] !== baseline[i]) return false;
-    }
-    return true;
-  }
-  return {
-    tokenAt(arraySegs, index) {
-      const len = getArrayLength(arraySegs);
-      if (index < 0 || index >= len) return "";
-      const ids = ensure(canonicalizePath(arraySegs).key, len);
-      return ids[index] ?? "";
-    },
-    applyOp(arraySegs, remap) {
-      const arrayKey = canonicalizePath(arraySegs).key;
-      const ids = ensure(arrayKey, remap.oldLen);
-      tokens.set(arrayKey, permuteList(ids, remap, allocate));
-    },
-    applyRemap(arrayPath, remap) {
-      if (remap.moved.size === 0 && remap.vacated.size === 0 && remap.fresh.size === 0) return;
-      migrateMapSubtree(tokens, arrayPath, remap, (value) => value);
-      migrateMapSubtree(baselines, arrayPath, remap, (value) => value);
-    },
-    realign(arraySegs) {
-      ensure(canonicalizePath(arraySegs).key, getArrayLength(arraySegs));
-    },
-    hasStructuralChangeUnder(prefix) {
-      for (const arrayKey of tokens.keys()) {
-        if (orderPristineForKey(arrayKey)) continue;
-        const segs = segmentsForPathKey(arrayKey);
-        if (segs === null) continue;
-        if (isPathPrefix(prefix, segs)) return true;
-      }
-      return false;
-    },
-    rebaselineAll() {
-      for (const arrayKey of [...tokens.keys()]) {
-        const segs = segmentsForPathKey(arrayKey);
-        if (segs === null) continue;
-        const ids = ensure(arrayKey, getArrayLength(segs));
-        baselines.set(arrayKey, [...ids]);
-      }
-    }
-  };
-}
-function createVariantMemory() {
-  const memory = /* @__PURE__ */ new Map();
-  return {
-    clear() {
-      memory.clear();
-    },
-    clearUnderPath(parentPath) {
-      for (const memKey of [...memory.keys()]) {
-        const segs = segmentsForPathKey(memKey);
-        if (segs === null) continue;
-        if (isPathPrefix(parentPath, segs)) memory.delete(memKey);
-      }
-    },
-    dropAtIndices(arrayPath, indices) {
-      deleteKeysAtIndices([...memory.keys()], (key) => memory.delete(key), arrayPath, indices);
-    },
-    recordOutgoing(unionKey, discValue, snapshot) {
-      let perUnion = memory.get(unionKey);
-      if (perUnion === void 0) {
-        perUnion = /* @__PURE__ */ new Map();
-        memory.set(unionKey, perUnion);
-      }
-      perUnion.set(discValue, snapshot);
-    },
-    lookupIncoming(unionKey, discValue) {
-      return memory.get(unionKey)?.get(discValue);
-    }
-  };
-}
-function cloneVariantSnapshot(value) {
-  if (value === null || typeof value !== "object") return value;
-  const raw = toRaw(value);
-  if (raw instanceof Date) return new Date(raw.getTime());
-  if (raw instanceof Map) {
-    const out2 = /* @__PURE__ */ new Map();
-    for (const [k, v] of raw.entries()) out2.set(cloneVariantSnapshot(k), cloneVariantSnapshot(v));
-    return out2;
-  }
-  if (raw instanceof Set) {
-    const out2 = /* @__PURE__ */ new Set();
-    for (const v of raw) out2.add(cloneVariantSnapshot(v));
-    return out2;
-  }
-  if (raw instanceof RegExp) return new RegExp(raw.source, raw.flags);
-  if (Array.isArray(raw)) {
-    const out2 = new Array(raw.length);
-    for (let i = 0; i < raw.length; i++) out2[i] = cloneVariantSnapshot(raw[i]);
-    return out2;
-  }
-  if (!isPlainRecord(raw)) return raw;
-  const src = raw;
-  const out = {};
-  for (const k of consumerKeys(src)) {
-    safeAssign(out, k, cloneVariantSnapshot(readConsumerProp(src, k)));
-  }
-  return out;
-}
-function createArrayBookkeeping(deps) {
-  const {
-    form,
-    fields,
-    errorCells,
-    originals,
-    blankPaths,
-    originalBlankPaths,
-    authoredPaths,
-    fieldValidationCounts,
-    fieldValidatingSince,
-    fieldValidationState,
-    activeValidations,
-    arrayIdentity,
-    variantMemory,
-    touchFieldRecord,
-    decFieldValidation
-  } = deps;
-  function migrateElementState(arrayPath, remap) {
-    if (remap.moved.size === 0 && remap.vacated.size === 0) return;
-    migrateMapSubtree(fields, arrayPath, remap, (record, segments) => ({
-      ...record,
-      path: segments
-    }));
-    migrateMapSubtree(errorCells(), arrayPath, remap, (cell, segments) => ({
-      schema: NO_ERRORS,
-      user: cell.user.map((error) => ({ ...error, path: [...segments] }))
-    }));
-    migrateMapSubtree(originals, arrayPath, remap, (record, segments) => ({
-      segments,
-      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);
-    arrayIdentity.applyRemap(arrayPath, remap);
-  }
-  function seedFreshElement(arrayPath, freshIndex) {
-    const elementPath = [...arrayPath, freshIndex];
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    diffAndApply(void 0, getAtPath(form.value, elementPath), elementPath, (patch) => {
-      if (patch.kind !== "added") return;
-      const { key } = canonicalizePath(patch.path);
-      if (!originals.has(key)) originals.set(key, { segments: patch.path, value: void 0 });
-      touchFieldRecord(key, patch.path, { updatedAt: now });
-    });
-  }
-  function abortValidationAtVacatedIndices(arrayPath, remap) {
-    if (remap.vacated.size === 0) return;
-    const hits = collectKeysAtIndices(
-      [...fieldValidationState.keys()],
-      arrayPath,
-      (index) => remap.vacated.has(index)
-    );
-    for (const hit of hits) {
-      const entry = fieldValidationState.get(hit.key);
-      if (entry === void 0) continue;
-      if (entry.timer !== null) {
-        clearTimeout(entry.timer);
-      } else if (!entry.settled) {
-        activeValidations.value = Math.max(0, activeValidations.value - 1);
-        decFieldValidation(hit.key);
-      }
-      entry.aborted = true;
-      fieldValidationState.delete(hit.key);
-    }
-  }
-  return {
-    applyStructuralOp(arrayPath, remap) {
-      migrateElementState(arrayPath, remap);
-      for (const freshIndex of remap.fresh) seedFreshElement(arrayPath, freshIndex);
-      const changed = changedIndices(remap);
-      evictSchemaVerdictsAtIndices(errorCells(), arrayPath, changed);
-      abortValidationAtVacatedIndices(arrayPath, remap);
-      variantMemory.dropAtIndices(arrayPath, changed);
-      arrayIdentity.applyOp(arrayPath, remap);
-    }
-  };
-}
-function buildFieldArrayApi(state) {
-  function readArray(path) {
-    const segments = canonicalizePath(path).segments;
-    const current = state.getValueAtPath(segments);
-    return Array.isArray(current) ? current.slice() : [];
-  }
-  function writeArray(path, next, arrayOp) {
-    const { segments } = canonicalizePath(path);
-    const meta = {
-      ...arrayOp !== void 0 ? { arrayOp } : {}
-    };
-    return state.setValueAtPath(segments, next, meta);
-  }
-  return {
-    append(path, value) {
-      const next = readArray(path);
-      next.push(value);
-      return writeArray(path, next, { kind: "insert", index: next.length - 1 });
-    },
-    prepend(path, value) {
-      const next = readArray(path);
-      next.unshift(value);
-      return writeArray(path, next, { kind: "insert", index: 0 });
-    },
-    insert(path, index, value) {
-      const next = readArray(path);
-      const preLen = next.length;
-      const insertIndex = index < 0 ? Math.max(0, preLen + index) : Math.min(index, preLen);
-      next.splice(insertIndex, 0, value);
-      return writeArray(path, next, { kind: "insert", index: insertIndex });
-    },
-    remove(path, index) {
-      const next = readArray(path);
-      if (index < 0 || index >= next.length) return false;
-      next.splice(index, 1);
-      return writeArray(path, next, { kind: "remove", index });
-    },
-    swap(path, a, b) {
-      const next = readArray(path);
-      if (a < 0 || a >= next.length) return false;
-      if (b < 0 || b >= next.length) return false;
-      if (a === b) return false;
-      const tmp = next[a];
-      next[a] = next[b];
-      next[b] = tmp;
-      return writeArray(path, next, { kind: "swap", a, b });
-    },
-    move(path, from, to) {
-      const next = readArray(path);
-      if (from < 0 || from >= next.length) return false;
-      const [item] = next.splice(from, 1);
-      const clampedTo = Math.max(0, Math.min(to, next.length));
-      next.splice(clampedTo, 0, item);
-      return writeArray(path, next, { kind: "move", from, to: clampedTo });
-    },
-    replace(path, index, value) {
-      const next = readArray(path);
-      if (index < 0 || index >= next.length) return false;
-      next[index] = value;
-      return writeArray(path, next, { kind: "replace-at", index });
-    }
-  };
-}
-
 function isErrorInputLike(value) {
   if (value instanceof Error) return true;
   if (typeof value !== "object" || value === null) return false;
@@ -2461,12 +1711,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;
@@ -2835,7 +2085,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));
@@ -2850,8 +2100,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);
       }
     }
   };
@@ -3260,7 +2510,7 @@ function mergeObjectKeys(target, source, path, schema) {
 
 async function runFactoryAndApply(st, factory) {
   try {
-    const value = await factory();
+    const value = structuralSnapshot(await factory());
     if (st.hasPreprocessOrCoerce) walkAuthoredFromConstraints(value, [], st.authoredPaths);
     const full = mergeSparseHydration(
       toRaw(st.form.value),
@@ -3304,16 +2554,15 @@ function appendHydrationFailedEntry(st, error) {
   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,
@@ -3371,7 +2620,7 @@ function walkDuStubs(schema, value, path, warned) {
 function stripSymbolsDeep(value) {
   if (value === null || typeof value !== "object") return value;
   if (Array.isArray(value)) {
-    let mutated2 = false;
+    let mutated2 = !consumerExtensible(value);
     const out2 = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
       const original = readConsumerIndex(value, i);
@@ -3385,7 +2634,7 @@ function stripSymbolsDeep(value) {
   if (proto !== Object.prototype && proto !== null) return value;
   const symKeys = consumerSymbolKeys(value);
   const stringKeys = consumerKeys(value);
-  let mutated = symKeys.length > 0;
+  let mutated = symKeys.length > 0 || !consumerExtensible(value);
   const out = {};
   const src = value;
   for (const k of stringKeys) {
@@ -3428,14 +2677,27 @@ function initialFirstValidationGate(schema) {
   return schema.needsAsyncValidation?.() !== true;
 }
 function seedOriginalsFromBaseline(st, baseline) {
-  st.originals.clear();
+  const seeded = /* @__PURE__ */ new Map();
   diffAndApply({}, baseline, [], (patch) => {
-    if (patch.kind !== "added") return;
-    st.originals.set(canonicalizePath(patch.path).key, {
-      segments: patch.path,
-      value: patch.newValue
-    });
+    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) {
@@ -3597,8 +2859,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,
@@ -3617,19 +2889,189 @@ 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;
+  st.noteReleased?.(released);
+  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 {
@@ -3639,33 +3081,39 @@ 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);
+  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;
   }
@@ -3673,9 +3121,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) {
     return false;
   }
@@ -3748,7 +3196,8 @@ function setValueAtPath(st, path, value, meta) {
                 value,
                 variantDefault,
                 void 0,
-                meta
+                meta,
+                writeStamp
               );
             }
             return reshapeUnionVariant(
@@ -3758,7 +3207,8 @@ function setValueAtPath(st, path, value, meta) {
               value,
               { [last]: value },
               void 0,
-              meta
+              meta,
+              writeStamp
             );
           }
         }
@@ -3782,7 +3232,8 @@ function setValueAtPath(st, path, value, meta) {
               discValue,
               variantDefault,
               valueRecord,
-              meta
+              meta,
+              writeStamp
             );
           }
           return reshapeUnionVariant(
@@ -3792,10 +3243,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
+        );
       }
     }
   }
@@ -3845,16 +3306,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") {
@@ -3862,7 +3324,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;
@@ -3928,7 +3390,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);
@@ -3949,7 +3411,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;
@@ -3960,19 +3424,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") {
@@ -3983,14 +3448,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;
     });
@@ -4029,6 +3494,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 () => {
@@ -4079,6 +3557,34 @@ function dispose(st) {
 function getValueAtPath(st, path) {
   return getAtPath(st.form.value, path);
 }
+function freezeBaseline(value) {
+  if (Object.isFrozen(value)) return value;
+  if (Array.isArray(value)) {
+    for (const item of value) freezeBaseline(item);
+    return Object.freeze(value);
+  }
+  if (isPlainRecord(value)) {
+    for (const k of Object.keys(value)) freezeBaseline(safeOwnRead(value, k));
+    return Object.freeze(value);
+  }
+  return value;
+}
+function getOriginalAtPath(st, path) {
+  let node = st.baselineValue;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (Array.isArray(node)) {
+      const at = typeof segment === "number" ? st.arrayIdentity.baselineIndexOf(path.slice(0, i), segment) : -1;
+      if (at < 0) return void 0;
+      node = node[at];
+    } else if (isPlainRecord(node) && typeof segment === "string") {
+      node = safeOwnRead(node, segment);
+    } else {
+      return void 0;
+    }
+  }
+  return freezeBaseline(node);
+}
 const ERROR_SOURCES = ["schema", "user"];
 function createErrorCells(schema, pristine) {
   const raw = /* @__PURE__ */ new Map();
@@ -4156,6 +3662,54 @@ function restoreErrorCells(st, entries) {
     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, remaps, returning) {
+  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);
+  }
+  for (const [segments, remap] of remaps) {
+    migrateFieldRecords(st.fields, segments, remap, (path, released) => {
+      let stamp = "";
+      for (const { updatedAt } of released) {
+        if (updatedAt !== null && updatedAt > stamp) stamp = updatedAt;
+      }
+      if (stamp !== "") eachAncestorOnce([path], (key, at) => raiseStamp(st, key, at, stamp));
+      foldInteractionHistory(st, path, released);
+    });
+  }
+  for (const record of returning) {
+    st.fields.set(canonicalizePath(record.path).key, {
+      ...record,
+      connected: false,
+      focused: null,
+      blurred: null
+    });
+  }
+  if (pulsed.length > 0) pulseStructure(st.structureSignal, pulsed);
+}
 function getErrorsForPath(st, path) {
   const { key } = canonicalizePath(path);
   const cell = st.errorCells().get(key);
@@ -4180,6 +3734,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) {
@@ -4239,22 +3794,44 @@ function markInteracted(st, path) {
   if (st.fields.get(key)?.interacted === true) return;
   touchFieldRecord(st, key, path, { interacted: true });
 }
+function markBareContainers(st, segments, ladder) {
+  const value = getAtPath(toRaw(st.form.value), segments);
+  if (!isDescendable(value)) return false;
+  const bare = [];
+  diffAndApply(void 0, value, segments, (patch) => {
+    if (isBarePatch(patch)) bare.push(patch.path);
+  });
+  eachAncestorOnce(bare, (key, path) => {
+    const current = st.fields.get(key);
+    if (current?.touched === true && (!ladder || current.interacted && current.blurredAfterInteraction)) {
+      return;
+    }
+    touchFieldRecord(
+      st,
+      key,
+      path,
+      ladder ? { touched: true, interacted: true, blurredAfterInteraction: true } : { touched: true }
+    );
+  });
+  return bare.length > 0;
+}
 function touchAtPath(st, segments) {
   const formValue = st.form.value;
   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;
     const current = st.fields.get(leafKey);
     if (current?.touched === true) continue;
     touchFieldRecord(st, leafKey, entry.segments, { touched: true });
   }
+  if (markBareContainers(st, segments, false)) ;
 }
 function interactAtPath(st, segments) {
   if (st.effectiveDisabled.value) return false;
   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);
@@ -4267,6 +3844,7 @@ function interactAtPath(st, segments) {
       blurredAfterInteraction: true
     });
   }
+  if (markBareContainers(st, segments, true)) interactedAny = true;
   return interactedAny;
 }
 function rehydrate(st) {
@@ -4308,14 +3886,31 @@ function adoptResolvedDefaults(st, value) {
       st.schema
     )
   );
-  seedOriginalsFromBaseline(
-    st,
-    computeBaseline(
-      st.schema,
-      st.defaultValues,
-      st.schema.getDefaultValues({ useDefaultSchemaValues: true })
-    )
+  st.baselineValue = computeBaseline(
+    st.schema,
+    st.defaultValues,
+    st.schema.getDefaultValues({ useDefaultSchemaValues: true })
   );
+  seedOriginalsFromBaseline(st, st.baselineValue);
+  st.arrayIdentity.rebaseline((segments) => holdsListAt(value, segments));
+  const dropped = [];
+  for (const [key, segments] of st.removedPaths) {
+    if (st.originals.get(key)?.value !== void 0) continue;
+    st.removedPaths.delete(key);
+    dropped.push(segments);
+  }
+  if (dropped.length > 0) pulseStructure(st.structureSignal, dropped);
+}
+function holdsListAt(value, segments) {
+  let node = value;
+  for (const segment of segments) {
+    if (Array.isArray(node)) return true;
+    if (!isPlainRecord(node) || typeof segment !== "string" || !safeOwnHas(node, segment)) {
+      return false;
+    }
+    node = safeOwnRead(node, segment);
+  }
+  return Array.isArray(node);
 }
 function reset(st, nextDefaultValues) {
   const resetSource = nextDefaultValues === void 0 ? st.defaultValues : mergeSparseHydration(
@@ -4326,19 +3921,25 @@ function reset(st, nextDefaultValues) {
   st.defaultValues = structuralSnapshot(resetSource);
   const next = computeBaseline(
     st.schema,
-    resetSource,
+    st.defaultValues,
     st.schema.getDefaultValues({ useDefaultSchemaValues: true })
   );
   rebuildAuthoredPaths(st, resetSource, next);
-  applyFormReplacement(st, next);
-  st.arrayIdentity.rebaselineAll();
-  st.removedSubtrees.clear();
-  seedOriginalsFromBaseline(st, next);
   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, structuralSnapshot(next), void 0, null, now);
+  st.arrayIdentity.rebaseline(() => true);
+  if (st.removedPaths.size > 0) {
+    const cleared = [...st.removedPaths.values()];
+    st.removedPaths.clear();
+    pulseStructure(st.structureSignal, cleared);
+  }
+  st.baselineValue = next;
+  seedOriginalsFromBaseline(st, next);
   st.blankPaths.clear();
   for (const key of st.originalBlankPaths) {
     st.blankPaths.add(key);
@@ -4347,7 +3948,7 @@ function reset(st, nextDefaultValues) {
   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));
   }
@@ -4376,6 +3977,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);
@@ -4384,9 +3986,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] AF11 attaform.dev/e/af11 '${targetKey}'`
@@ -4404,10 +4018,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] AF12 attaform.dev/e/af12 '${targetKey}'`
@@ -4416,8 +4030,14 @@ 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) {
@@ -4430,36 +4050,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;
@@ -4495,10 +4114,14 @@ 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 errorStore = createErrorCells(
@@ -4507,7 +4130,7 @@ function createFormStore(options) {
   );
   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 ?? [];
@@ -4608,6 +4231,8 @@ function createFormStore(options) {
     blankPaths,
     originalBlankPaths,
     authoredPaths,
+    removedPaths,
+    notifyStructure: (paths) => pulseStructure(structureSignal, paths),
     fieldValidationCounts,
     fieldValidatingSince,
     fieldValidationState,
@@ -4615,6 +4240,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);
@@ -4665,6 +4293,8 @@ function createFormStore(options) {
     // 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,
+    // The form holds a copy of it, or the hydration payload.
+    baselineValue: schemaInitialData,
     ssrPrefetch,
     rememberVariants,
     fieldValidationMode,
@@ -4678,7 +4308,8 @@ function createFormStore(options) {
     cleanupHooks,
     authoredPaths,
     arrayIdentity,
-    removedSubtrees,
+    removedPaths,
+    structureSignal,
     variantMemory,
     pathOrdinals,
     pathSnapshots,
@@ -4688,6 +4319,7 @@ function createFormStore(options) {
     arrayBookkeeping,
     skipErrorSeed: () => errorStore(false),
     nextOrdinal: 0,
+    latestStamp: "",
     scheduleEpoch: 0,
     lastCommittedEpoch: 0,
     transformTokenSeq: 0,
@@ -4700,6 +4332,7 @@ function createFormStore(options) {
     applyFormReplacement: bind(applyFormReplacement),
     setValueAtPath: bind(setValueAtPath),
     getValueAtPath: bind(getValueAtPath),
+    getOriginalAtPath: bind(getOriginalAtPath),
     arrayElementKey: bind(arrayElementKey),
     reset: bind(reset),
     resetField: bind(resetField),
@@ -4725,6 +4358,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),
@@ -4758,7 +4393,7 @@ function createFormStore(options) {
   diffAndApply({}, schemaInitialData, [], (patch) => {
     if (patch.kind !== "added") return;
     const { key } = canonicalizePath(patch.path);
-    originals.set(key, { segments: patch.path, value: patch.newValue });
+    if (seedBaseline(originals, key, patch)) return;
     ensurePathOrdinal(st, key);
     if (hydration === void 0) {
       fields.set(key, {
@@ -4773,12 +4408,14 @@ function createFormStore(options) {
       });
     }
   });
+  if (fields.size > 0) noteStamp(st, initStamp);
   if (hydration !== void 0) {
     for (const [rawKey, record] of hydration.fields) {
       if (typeof rawKey !== "string" || !isHydratedFieldRecord(record)) {
         continue;
       }
       fields.set(rawKey, record);
+      noteStamp(st, record.updatedAt);
     }
     for (const [rawKey, errs] of hydration.schemaErrors) {
       if (typeof rawKey !== "string" || !isHydratedValidationErrorArray(errs)) {
@@ -5282,7 +4919,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)
   });
 }
 
@@ -6432,4 +6069,4 @@ function escapeForInlineScript(json) {
   });
 }
 
-export { AttaformErrorCode as A, injectWizard as a, isUnset as b, useAbstractForm as c, useRegister as d, escapeForInlineScript as e, useWizard as f, gate as g, getAtPath as h, injectForm as i, humanize as j, isPlainRecord as k, lazy as l, slimKindOf as s, unset as u };
+export { injectWizard as a, isUnset as b, useAbstractForm as c, useRegister as d, escapeForInlineScript as e, useWizard as f, gate as g, humanize as h, injectForm as i, lazy as l, slimKindOf as s, unset as u };