attaform 0.31.0 → 0.31.2

package/dist/dev/shared/attaform-dev.G-3XDl9F.mjs

@@ -0,0 +1,1192 @@
+import { toRaw } from 'vue';
+import { s as safeAssign, a as safeOwnRead, r as readConsumerIndex, c as consumerKeys, b as readConsumerProp, i as isShadowedKey, d as safeOwnHas, e as consumerHas, f as spreadConsumerRecord, g as copyConsumerArray } from './attaform-dev.DoG8mZTq.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix, s as segmentsForPathKey, e as canonicalizePath, k as keyForSegments } from './attaform-dev.04aupFBW.mjs';
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
+const RESERVED_KEY_PREFIX = "__atta:";
+const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
+const DEFAULT_MAX_RECURSION_DEPTH = 64;
+function normalizeNumericOption(config) {
+  const { value, source, min, defaultValue } = config;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    {
+      console.warn(
+        `[attaform] ${source} must be a non-negative finite integer; got ${String(value)}. Falling back to ${String(defaultValue)}.`
+      );
+    }
+    return defaultValue;
+  }
+  return Math.max(min, Math.floor(value));
+}
+function pickDefined(bag) {
+  const out = {};
+  for (const key of Object.keys(bag)) {
+    if (bag[key] !== void 0) out[key] = bag[key];
+  }
+  return out;
+}
+
+function isDescendable(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  if (value instanceof Map) return mapSegmentKeys(value) !== null;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function isBarePatch(patch) {
+  return patch.kind === "added" ? isDescendable(patch.newValue) : patch.kind === "removed" && isDescendable(patch.oldValue);
+}
+function appendSegment(prefix, segment) {
+  const next = new Array(prefix.length + 1);
+  for (let i = 0; i < prefix.length; i++) {
+    const s = prefix[i];
+    next[i] = s;
+  }
+  next[prefix.length] = segment;
+  return next;
+}
+function diffAndApply(oldValue, newValue, prefix, visit) {
+  if (Object.is(oldValue, newValue)) return;
+  const oldIsDescendable = isDescendable(oldValue);
+  const newIsDescendable = isDescendable(newValue);
+  if (oldValue === void 0 && newIsDescendable) {
+    walkDescendable(newValue, prefix, visit, true);
+    return;
+  }
+  if (oldIsDescendable && newValue === void 0) {
+    walkDescendable(oldValue, prefix, visit, false);
+    return;
+  }
+  if (oldIsDescendable && newIsDescendable) {
+    const oldIsMap = oldValue instanceof Map;
+    const newIsMap = newValue instanceof Map;
+    if (oldIsMap && newIsMap) {
+      diffMapsLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (oldIsMap !== newIsMap) {
+      visit({ kind: "changed", path: prefix, oldValue, newValue });
+      return;
+    }
+    const oldIsArray = Array.isArray(oldValue);
+    const newIsArray = Array.isArray(newValue);
+    if (oldIsArray && newIsArray) {
+      diffArraysLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (!oldIsArray && !newIsArray) {
+      diffObjectsLockstep(
+        oldValue,
+        newValue,
+        prefix,
+        visit
+      );
+      return;
+    }
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldIsDescendable && !newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (!oldIsDescendable && newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldValue === void 0) {
+    visit({ kind: "added", path: prefix, newValue });
+    return;
+  }
+  if (newValue === void 0) {
+    visit({ kind: "removed", path: prefix, oldValue });
+    return;
+  }
+  visit({ kind: "changed", path: prefix, oldValue, newValue });
+}
+function walkDescendable(value, prefix, visit, arrived) {
+  let reported = false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      diffSlot(readConsumerIndex(value, i), appendSegment(prefix, i), visit, arrived);
+    }
+    reported = value.length > 0;
+  } else if (value instanceof Map) {
+    for (const [key, entry] of value) {
+      diffSlot(entry, appendSegment(prefix, key), visit, arrived);
+    }
+    reported = value.size > 0;
+  } else {
+    const rec = value;
+    for (const k of consumerKeys(rec)) {
+      const entry = readConsumerProp(rec, k);
+      if (entry === void 0) continue;
+      reported = true;
+      if (arrived) diffAndApply(void 0, entry, appendSegment(prefix, k), visit);
+      else diffAndApply(entry, void 0, appendSegment(prefix, k), visit);
+    }
+  }
+  if (!reported) visit(presencePatch(arrived, prefix, value));
+}
+function diffSlot(entry, path, visit, arrived) {
+  if (entry === void 0) visit(presencePatch(arrived, path, entry));
+  else if (arrived) diffAndApply(void 0, entry, path, visit);
+  else diffAndApply(entry, void 0, path, visit);
+}
+function presencePatch(arrived, path, value) {
+  return arrived ? { kind: "added", path, newValue: value } : { kind: "removed", path, oldValue: value };
+}
+function diffMapsLockstep(oldMap, newMap, prefix, visit) {
+  for (const [key, entry] of newMap) {
+    const path = appendSegment(prefix, key);
+    if (oldMap.has(key)) diffAndApply(oldMap.get(key), entry, path, visit);
+    else diffSlot(entry, path, visit, true);
+  }
+  for (const [key, entry] of oldMap) {
+    if (!newMap.has(key)) diffSlot(entry, appendSegment(prefix, key), visit, false);
+  }
+}
+function diffArraysLockstep(oldArr, newArr, prefix, visit) {
+  const min = Math.min(oldArr.length, newArr.length);
+  for (let i = 0; i < min; i++) {
+    diffAndApply(
+      readConsumerIndex(oldArr, i),
+      readConsumerIndex(newArr, i),
+      appendSegment(prefix, i),
+      visit
+    );
+  }
+  for (let i = min; i < newArr.length; i++) {
+    diffSlot(readConsumerIndex(newArr, i), appendSegment(prefix, i), visit, true);
+  }
+  for (let i = min; i < oldArr.length; i++) {
+    diffSlot(readConsumerIndex(oldArr, i), appendSegment(prefix, i), visit, false);
+  }
+}
+function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const k of consumerKeys(oldRec)) {
+    seen.add(k);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
+  }
+  for (const k of consumerKeys(newRec)) {
+    if (seen.has(k)) continue;
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
+  }
+}
+function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
+  if (!isDescendable(target) || !isDescendable(source)) return false;
+  if (target instanceof Map || source instanceof Map) return false;
+  const targetIsArray = Array.isArray(target);
+  const sourceIsArray = Array.isArray(source);
+  if (targetIsArray !== sourceIsArray) return false;
+  const depth = currentPath.length;
+  const changedFirstSegments = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    if (patch.path.length === depth) return false;
+    changedFirstSegments.add(patch.path[depth]);
+  }
+  if (targetIsArray) {
+    const t = target;
+    const s = source;
+    if (arrayOpPath === null || pathsEqual(currentPath, arrayOpPath)) {
+      if (t.length > s.length) t.length = s.length;
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        t[i] = s[i];
+      }
+    } else {
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        const childPath = appendSegment(currentPath, i);
+        const curEl = t[i];
+        const nextEl = s[i];
+        if (isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(
+          curEl,
+          nextEl,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
+    }
+  } else {
+    const t = target;
+    const s = source;
+    const sourceKeys = new Set(Object.keys(s));
+    for (const k of Object.keys(t)) {
+      if (!sourceKeys.has(k)) delete t[k];
+    }
+    for (const k of changedFirstSegments) {
+      const key = String(k);
+      const nextVal = safeOwnRead(s, key);
+      if (arrayOpPath !== null) {
+        const curVal = safeOwnRead(t, key);
+        const childPath = appendSegment(currentPath, key);
+        if (isDescendable(curVal) && isDescendable(nextVal) && applyChangedKeys(
+          curVal,
+          nextVal,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+      }
+      safeAssign(t, key, nextVal);
+    }
+  }
+  return true;
+}
+function structuralSnapshot(value) {
+  if (!isDescendable(value)) return value;
+  if (value instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) out2.set(k, structuralSnapshot(v));
+    return out2;
+  }
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      out2[i] = structuralSnapshot(value[i]);
+    }
+    return out2;
+  }
+  const src = value;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    safeAssign(out, k, structuralSnapshot(safeOwnRead(src, k)));
+  }
+  return out;
+}
+
+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([]);
+
+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 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 elementIndexAfter(key, head) {
+  if (!key.startsWith(head)) return null;
+  let index = 0;
+  let at = head.length;
+  for (let code = key.charCodeAt(at); code >= 48 && code <= 57; code = key.charCodeAt(++at)) {
+    index = index * 10 + code - 48;
+  }
+  return at > head.length ? index : null;
+}
+function collectKeysAtIndices(keys, arrayPath, member) {
+  const { key: arrayKey } = keyForSegments(arrayPath);
+  const head = arrayPath.length === 0 ? "[" : `${arrayKey.slice(0, -1)},`;
+  const hits = [];
+  for (const key of keys) {
+    const index = elementIndexAfter(key, head);
+    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) {
+  relocateHits(
+    map,
+    collectKeysAtIndices(toRaw(map).keys(), arrayPath, remapAffects(remap)),
+    arrayPath,
+    remap,
+    rewriteValue
+  );
+}
+function relocateHits(map, hits, arrayPath, remap, rewriteValue) {
+  if (hits.length === 0) return;
+  const idxPos = arrayPath.length;
+  const snapshots = [];
+  const raw = toRaw(map);
+  for (const hit of hits) {
+    const value = raw.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(toRaw(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) {
+  const raw = toRaw(errorCells);
+  for (const hit of collectKeysAtIndices(raw.keys(), arrayPath, (index) => indices.has(index))) {
+    const cell = raw.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();
+  const baselineSlots = /* @__PURE__ */ new WeakMap();
+  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] ?? "";
+    },
+    baselineIndexOf(arraySegs, index) {
+      const len = getArrayLength(arraySegs);
+      if (index < 0 || index >= len) return -1;
+      const arrayKey = canonicalizePath(arraySegs).key;
+      const token = ensure(arrayKey, len)[index];
+      const baseline = baselines.get(arrayKey);
+      if (token === void 0 || baseline === void 0) return -1;
+      let slots = baselineSlots.get(baseline);
+      if (slots === void 0) {
+        slots = new Map(baseline.map((id, i) => [id, i]));
+        baselineSlots.set(baseline, slots);
+      }
+      return slots.get(token) ?? -1;
+    },
+    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;
+    },
+    rebaseline(covers) {
+      const rebased = [];
+      for (const arrayKey of [...tokens.keys()]) {
+        const segs = segmentsForPathKey(arrayKey);
+        if (segs === null || !covers(segs)) 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 migrateFieldRecords(fields, arrayPath, remap, release) {
+  const raw = toRaw(fields);
+  const hits = collectKeysAtIndices(raw.keys(), arrayPath, remapAffects(remap));
+  if (remap.vacated.size > 0) {
+    const released = [];
+    for (const { key, index } of hits) {
+      const record = remap.vacated.has(index) ? raw.get(key) : void 0;
+      if (record !== void 0) released.push(record);
+    }
+    release(arrayPath, released);
+  }
+  relocateHits(fields, hits, arrayPath, remap, (record, segments) => ({
+    ...record,
+    path: segments
+  }));
+}
+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;
+    });
+    migrateFieldRecords(fields, arrayPath, remap, foldInteractionHistory);
+    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 });
+    }
+  };
+}
+
+export { AttaformErrorCode as A, ANONYMOUS_WIZARD_KEY_PREFIX as B, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, NO_ERRORS as N, RESERVED_KEY_PREFIX as R, ANONYMOUS_FORM_KEY_PREFIX as a, makeBlankRequiredError as b, buildFieldArrayApi as c, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as d, diffAndApply as e, mergeStructural as f, getAtPath as g, hasAtPath as h, isPlainRecord as i, createArrayBookkeeping as j, createVariantMemory as k, createArrayIdentity as l, migrateMapSubtree as m, normalizeNumericOption as n, isDescendable as o, pickDefined as p, migrateFieldRecords as q, setAtPath as r, structuralSnapshot as s, remapForOp as t, isBarePatch as u, applyChangedKeys as v, cloneVariantSnapshot as w, setAtPathWithSchemaFill as x, tryInPlaceLeafWrite as y, DEFAULT_MAX_RECURSION_DEPTH as z };