attaform 0.31.1 → 0.31.2

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

@@ -1,82 +1,9 @@
 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 { 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-dev.G-3XDl9F.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. */
-  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 { R as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, d as armDomBinding, r as recordInheritedModifiers, w as withInheritedModifiers } from './attaform-dev.CKSqs_xQ.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-dev.04aupFBW.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, l as reportConsumerThrow } from './attaform-dev.DoG8mZTq.mjs';
 
 function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
@@ -176,323 +103,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 +238,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;
@@ -745,7 +354,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
   return {
     base: {
       value,
-      original,
+      original: state.getOriginalAtPath(segments),
       pristine,
       dirty,
       focused,
@@ -1451,504 +1060,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, onChange) {
-  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);
-    }
-    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;
-  }
-  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));
-      onChange([arraySegs]);
-    },
-    applyRemap(arrayPath, remap) {
-      if (remap.moved.size === 0 && remap.vacated.size === 0 && remap.fresh.size === 0) return;
-      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;
-        const segs = segmentsForPathKey(arrayKey);
-        if (segs === null) continue;
-        if (isPathPrefix(prefix, segs)) return true;
-      }
-      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 {
-    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,
-    removedPaths,
-    notifyStructure,
-    fieldValidationCounts,
-    fieldValidatingSince,
-    fieldValidationState,
-    activeValidations,
-    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) => ({
-      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);
-    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, now) {
-    const elementPath = [...arrayPath, freshIndex];
-    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;
-      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, 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;
-    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 && !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, now) {
-      abortValidationAtVacatedIndices(arrayPath, remap);
-      migrateElementState(arrayPath, remap);
-      for (const freshIndex of remap.fresh) seedFreshElement(arrayPath, freshIndex, now);
-      const changed = changedIndices(remap);
-      evictSchemaVerdictsAtIndices(errorCells(), arrayPath, changed);
-      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 });
-    }
-  };
-}
-
 const warnedNoScopeStores = /* @__PURE__ */ new WeakSet() ;
 function isErrorInputLike(value) {
   if (value instanceof Error) return true;
@@ -3522,7 +2633,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),
@@ -3648,7 +2759,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);
@@ -3662,7 +2773,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) {
@@ -4001,6 +3112,7 @@ function foldInteractionHistory(st, path, released) {
     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);
@@ -4592,6 +3704,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();
@@ -4677,7 +3817,7 @@ function captureStructure(st) {
     removed: [...st.removedPaths]
   };
 }
-function restoreStructure(st, snapshot) {
+function restoreStructure(st, snapshot, remaps, returning) {
   const originals = new Map(snapshot.originals);
   const raw = toRaw(st.form.value);
   const held = /* @__PURE__ */ new Map();
@@ -4697,6 +3837,24 @@ function restoreStructure(st, snapshot) {
     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) {
@@ -4783,6 +3941,27 @@ 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;
   let touchedAny = false;
@@ -4794,6 +3973,7 @@ function touchAtPath(st, segments) {
     if (current?.touched === true) continue;
     touchFieldRecord(st, leafKey, entry.segments, { touched: true });
   }
+  if (markBareContainers(st, segments, false)) touchedAny = true;
   if (!touchedAny && true) {
     console.warn(
       `[attaform] form.touch(): no fields resolved at path ${JSON.stringify(segments)}. Check the path matches an existing field or container.`
@@ -4818,6 +3998,7 @@ function interactAtPath(st, segments) {
       blurredAfterInteraction: true
     });
   }
+  if (markBareContainers(st, segments, true)) interactedAny = true;
   if (!interactedAny && true) {
     console.warn(
       `[attaform] form.interact(): no fields resolved at path ${JSON.stringify(segments)}. Check the path matches an existing field or container.`
@@ -4864,14 +4045,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(
@@ -4882,7 +4080,7 @@ 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);
@@ -4892,13 +4090,14 @@ function reset(st, nextDefaultValues) {
     for (const key of mentioned) st.originalBlankPaths.delete(key);
   }
   const now = writeInstant(st);
-  applyFormReplacementWithPath(st, next, void 0, null, now);
-  st.arrayIdentity.rebaselineAll();
+  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) {
@@ -5261,6 +4460,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,
@@ -5298,6 +4499,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),
@@ -7262,4 +6464,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 };