attaform 0.0.1 → 0.14.0

package/dist/shared/attaform.BRTxpA3q.mjs

@@ -0,0 +1,3283 @@
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, readonly, reactive, shallowRef, provide, getCurrentInstance, useId, toRaw, inject } from 'vue';
+import { c as canonicalizePath, s as segmentsForPathKey } from './attaform.Cc93zNzD.mjs';
+import { _ as __DEV__, c as SubmitErrorHandlerError, A as AnonPersistError, m as captureUserCallSite, j as enforceSensitiveCheck, n as createPersistOptInRegistry, e as useRegistry, o as kFormContext, p as kFormInstanceId, b as ReservedFormKeyError } from './attaform.al_rpt7_.mjs';
+
+const NOT_FOUND = Symbol("NOT_FOUND");
+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 < 0 || segment >= value.length) return NOT_FOUND;
+    return value[segment];
+  }
+  const record = value;
+  const key = typeof segment === "number" ? String(segment) : segment;
+  if (!(key in record)) return NOT_FOUND;
+  return record[key];
+}
+function getAtPath(root, path) {
+  if (path.length === 0) return root;
+  let current = root;
+  for (const segment of path) {
+    const next = descendStep(current, segment);
+    if (next === NOT_FOUND) return void 0;
+    current = next;
+  }
+  return current;
+}
+function hasAtPath(root, path) {
+  if (path.length === 0) return true;
+  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" && last >= 0 && last < current.length;
+  }
+  const key = typeof last === "number" ? String(last) : last;
+  return key in current;
+}
+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;
+}
+function setAtPath(root, path, value) {
+  return setAtPathOffset(root, path, value, 0);
+}
+function setAtPathOffset(root, path, value, offset) {
+  if (offset >= path.length) return value;
+  const head = path[offset];
+  const nextOffset = offset + 1;
+  if (typeof head === "number") {
+    const arr = Array.isArray(root) ? [...root] : [];
+    while (arr.length <= head) arr.push(void 0);
+    arr[head] = setAtPathOffset(arr[head], path, value, nextOffset);
+    return arr;
+  }
+  const rec = isPlainRecord(root) ? { ...root } : {};
+  rec[head] = setAtPathOffset(rec[head], path, value, nextOffset);
+  return rec;
+}
+function deleteAtPath(root, path) {
+  return deleteAtPathOffset(root, path, 0);
+}
+function deleteAtPathOffset(root, path, offset) {
+  if (offset >= path.length) return void 0;
+  const head = path[offset];
+  const isLeafStep = offset === path.length - 1;
+  const nextOffset = offset + 1;
+  if (typeof head === "number") {
+    if (!Array.isArray(root)) return root;
+    if (head < 0 || head >= root.length) return root;
+    if (isLeafStep) {
+      const arr2 = [...root];
+      arr2.splice(head, 1);
+      return arr2;
+    }
+    const arr = [...root];
+    arr[head] = deleteAtPathOffset(arr[head], path, nextOffset);
+    return arr;
+  }
+  if (!isPlainRecord(root)) return root;
+  if (isLeafStep) {
+    const rec2 = { ...root };
+    delete rec2[head];
+    return rec2;
+  }
+  if (!(head in root)) return root;
+  const rec = { ...root };
+  rec[head] = deleteAtPathOffset(rec[head], path, nextOffset);
+  return rec;
+}
+function resolveArrayShape(schema, scratch) {
+  const shape = schema.arrayShapeAtPath(scratch);
+  if (shape !== void 0) return shape;
+  const TUPLE_PROBE_INDEX = 1e6;
+  scratch.push(TUPLE_PROBE_INDEX);
+  const probe = schema.getDefaultAtPath(scratch);
+  scratch.pop();
+  if (probe !== void 0) return null;
+  let n = 0;
+  while (n < 1024) {
+    scratch.push(n);
+    const v = schema.getDefaultAtPath(scratch);
+    scratch.pop();
+    if (v === void 0) break;
+    n++;
+  }
+  return n;
+}
+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) return defaultValue;
+  if (consumer === null) return null;
+  if (Array.isArray(consumer)) {
+    const shape = resolveArrayShape(schema, scratch);
+    const isTuple = typeof shape === "number";
+    const targetLen = isTuple ? shape : consumer.length;
+    let cachedElementDefault;
+    let cachedElementDefaultRead = false;
+    let mutated = targetLen > consumer.length;
+    const out = consumer.slice();
+    while (out.length < targetLen) out.push(void 0);
+    for (let i = 0; i < targetLen; i++) {
+      scratch.push(i);
+      let elemDefault;
+      if (isTuple) {
+        elemDefault = schema.getDefaultAtPath(scratch);
+      } else {
+        if (!cachedElementDefaultRead) {
+          cachedElementDefault = schema.getDefaultAtPath(scratch);
+          cachedElementDefaultRead = true;
+        }
+        elemDefault = cachedElementDefault;
+      }
+      const consumerElem = i < consumer.length ? consumer[i] : void 0;
+      const merged = mergeStructuralImpl(schema, scratch, consumerElem, elemDefault);
+      scratch.pop();
+      if (merged !== consumerElem) {
+        out[i] = merged;
+        mutated = true;
+      }
+    }
+    return mutated ? out : consumer;
+  }
+  if (isPlainRecord(consumer)) {
+    if (!isPlainRecord(defaultValue)) {
+      return consumer;
+    }
+    let mutated = false;
+    const out = { ...consumer };
+    for (const key of Object.keys(defaultValue)) {
+      if (!(key in consumer) || consumer[key] === void 0) {
+        const defAtKey = defaultValue[key];
+        scratch.push(key);
+        const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
+        scratch.pop();
+        if (filled !== void 0) {
+          out[key] = filled;
+          mutated = true;
+        }
+      }
+    }
+    for (const key of Object.keys(consumer)) {
+      scratch.push(key);
+      const merged = mergeStructuralImpl(schema, scratch, consumer[key], defaultValue[key]);
+      scratch.pop();
+      if (merged !== consumer[key]) {
+        out[key] = merged;
+        mutated = true;
+      }
+    }
+    return mutated ? out : consumer;
+  }
+  return consumer;
+}
+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 (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 = resolveArrayShape(schema, 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) {
+    rec[head] = value;
+    return rec;
+  }
+  const existing = 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;
+  }
+  rec[head] = setAtPathWithSchemaFillImpl(childRoot, schema, fullPath, value, startIdx + 1);
+  return rec;
+}
+
+const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+function keyToSegment(key) {
+  return INTEGER_SEGMENT.test(key) ? Number(key) : key;
+}
+function buildSurfaceProxy(opts) {
+  const containerCache = /* @__PURE__ */ new Map();
+  const leafViewCache = /* @__PURE__ */ new Map();
+  const existsCache = /* @__PURE__ */ new Map();
+  function schemaHasPath(segs) {
+    const cacheKey = JSON.stringify(segs);
+    const cached = existsCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    const result = opts.schema.getSlimPrimitiveTypesAtPath(segs).size > 0;
+    existsCache.set(cacheKey, result);
+    return result;
+  }
+  function descendOrTerminate(segs) {
+    const isLeaf = opts.schema.isLeafAtPath(segs);
+    if (isLeaf) {
+      if (opts.leafKeys !== void 0) return leafViewProxyAt(segs);
+      return opts.resolveLeaf(segs);
+    }
+    return containerProxyAt(segs);
+  }
+  function navigateTo(input) {
+    if (input === void 0) return rootProxy;
+    const { segments } = canonicalizePath(input);
+    return descendOrTerminate(segments);
+  }
+  function containerProxyAt(segments) {
+    const cacheKey = JSON.stringify(segments);
+    const existing = containerCache.get(cacheKey);
+    if (existing !== void 0) return existing;
+    const snapshotContainer = () => opts.materializeContainer === void 0 ? {} : opts.materializeContainer(segments);
+    const containerToJSON = () => snapshotContainer();
+    const containerToString = () => JSON.stringify(snapshotContainer());
+    function containerValueOf() {
+      return this;
+    }
+    const containerToPrimitive = (hint) => hint === "number" ? NaN : containerToString();
+    const target = (() => {
+    });
+    const proxy = new Proxy(target, {
+      apply(_, __, args) {
+        const arg = args[0];
+        if (arg === void 0) return proxy;
+        return navigateTo(arg);
+      },
+      get(_, key) {
+        if (typeof key === "symbol") {
+          if (key === Symbol.toPrimitive) return containerToPrimitive;
+          return Reflect.get(target, key);
+        }
+        if (typeof key !== "string") return void 0;
+        if (key === "toJSON") return containerToJSON;
+        const childSegs = [...segments, keyToSegment(key)];
+        if (key === "toString" || key === "valueOf") {
+          if (!schemaHasPath(childSegs)) {
+            return key === "toString" ? containerToString : containerValueOf;
+          }
+        }
+        return descendOrTerminate(childSegs);
+      },
+      has(_, key) {
+        if (typeof key === "symbol") return Reflect.has(target, key);
+        return true;
+      },
+      // Containers are descend-only — `JSON.stringify(form.fields.address)`
+      // returns `{}` (no leaf keys to enumerate). Consumers who want
+      // structural data use `form.values.<container>` instead.
+      ownKeys: () => [],
+      getOwnPropertyDescriptor: () => void 0,
+      // Block writes at the proxy boundary. Mutations go through
+      // `setValue`, the directive, or the field-array helpers.
+      set: () => false,
+      deleteProperty: () => false,
+      defineProperty: () => false
+    });
+    containerCache.set(cacheKey, proxy);
+    return proxy;
+  }
+  function leafViewProxyAt(segments) {
+    const cacheKey = JSON.stringify(segments);
+    const existing = leafViewCache.get(cacheKey);
+    if (existing !== void 0) return existing;
+    const leafKeys = opts.leafKeys;
+    const readLeafKey = opts.readLeafKey;
+    if (leafKeys === void 0 || readLeafKey === void 0) {
+      throw new Error("leafViewProxyAt called without leafKeys/readLeafKey configured");
+    }
+    const snapshotLeaf = () => {
+      const leaf = opts.resolveLeaf(segments);
+      const snapshot = {};
+      for (const leafKey of leafKeys) {
+        snapshot[leafKey] = readLeafKey(leaf, leafKey);
+      }
+      return snapshot;
+    };
+    const leafToString = () => JSON.stringify(snapshotLeaf());
+    function leafValueOf() {
+      return this;
+    }
+    const leafToPrimitive = (hint) => hint === "number" ? NaN : leafToString();
+    const target = (() => {
+    });
+    const proxy = new Proxy(target, {
+      apply(_, __, args) {
+        const arg = args[0];
+        if (arg === void 0) return opts.resolveLeaf(segments);
+        return navigateTo(arg);
+      },
+      get(_, key) {
+        if (typeof key === "symbol") {
+          if (key === Symbol.toPrimitive) return leafToPrimitive;
+          return Reflect.get(target, key);
+        }
+        if (typeof key !== "string") return void 0;
+        if (key === "toString") return leafToString;
+        if (key === "valueOf") return leafValueOf;
+        if (key === "toJSON") return snapshotLeaf;
+        if (leafKeys.has(key)) {
+          const leaf = opts.resolveLeaf(segments);
+          return readLeafKey(leaf, key);
+        }
+        return descendOrTerminate([...segments, keyToSegment(key)]);
+      },
+      has(_, key) {
+        if (typeof key === "symbol") return Reflect.has(target, key);
+        if (typeof key === "string" && leafKeys.has(key)) return true;
+        return true;
+      },
+      // Iteration: leaf-views expose the leaf-key set so
+      // `JSON.stringify(form.fields.email)` produces the expected
+      // FieldStateView snapshot (matching the legacy
+      // `JSON.stringify(form.getFieldState('email').value)` shape).
+      ownKeys: () => Array.from(leafKeys),
+      getOwnPropertyDescriptor(_, key) {
+        if (typeof key !== "string") return void 0;
+        if (!leafKeys.has(key)) return void 0;
+        const leaf = opts.resolveLeaf(segments);
+        return {
+          configurable: true,
+          enumerable: true,
+          value: readLeafKey(leaf, key),
+          writable: false
+        };
+      },
+      set: () => false,
+      deleteProperty: () => false,
+      defineProperty: () => false
+    });
+    leafViewCache.set(cacheKey, proxy);
+    return proxy;
+  }
+  const rootProxy = containerProxyAt([]);
+  return rootProxy;
+}
+
+function buildErrorsProxy(state) {
+  return buildSurfaceProxy({
+    schema: state.schema,
+    resolveLeaf: (path) => {
+      if (!hasAtPath(state.form.value, path)) return void 0;
+      const { key } = canonicalizePath(path);
+      const schemaForKey = state.schemaErrors.get(key);
+      const blankForKey = state.derivedBlankErrors.value.get(key);
+      const userForKey = state.userErrors.get(key);
+      const merged = [];
+      if (schemaForKey !== void 0) merged.push(...schemaForKey);
+      if (blankForKey !== void 0) merged.push(...blankForKey);
+      if (userForKey !== void 0) merged.push(...userForKey);
+      return merged.length === 0 ? void 0 : merged;
+    },
+    // No leafKeys — at a leaf, the resolved value (the merged array or
+    // undefined) IS the terminal.
+    materializeContainer: (segments) => materializeErrors(state, segments)
+  });
+}
+function materializeErrors(state, containerSegments) {
+  const liveContainer = getAtPath(state.form.value, containerSegments);
+  const tree = Array.isArray(liveContainer) ? [] : {};
+  const collect = (store) => {
+    entries: for (const [pathKey, errors] of store) {
+      if (errors.length === 0) continue;
+      const fullPath = segmentsForPathKey(pathKey);
+      if (fullPath === null) continue;
+      if (fullPath.length <= containerSegments.length) continue;
+      for (let i = 0; i < containerSegments.length; i++) {
+        if (fullPath[i] !== containerSegments[i]) continue entries;
+      }
+      if (!hasAtPath(state.form.value, fullPath)) continue;
+      placeAt(tree, fullPath.slice(containerSegments.length), errors);
+    }
+  };
+  collect(state.schemaErrors);
+  collect(state.derivedBlankErrors.value);
+  collect(state.userErrors);
+  return tree;
+}
+function placeAt(tree, path, errors) {
+  if (path.length === 0) return;
+  let cursor = tree;
+  for (let i = 0; i < path.length - 1; i++) {
+    const seg = path[i];
+    const nextSeg = path[i + 1];
+    const key = typeof seg === "number" ? String(seg) : seg;
+    const cursorRecord2 = cursor;
+    let child = cursorRecord2[key];
+    if (child === null || child === void 0 || typeof child !== "object") {
+      child = typeof nextSeg === "number" ? [] : {};
+      cursorRecord2[key] = child;
+    }
+    cursor = child;
+  }
+  const lastSeg = path[path.length - 1];
+  const lastKey = typeof lastSeg === "number" ? String(lastSeg) : lastSeg;
+  const cursorRecord = cursor;
+  const existing = cursorRecord[lastKey];
+  cursorRecord[lastKey] = Array.isArray(existing) ? [...existing, ...errors] : errors;
+}
+
+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) {
+    const { segments, key } = canonicalizePath(path);
+    return state.setValueAtPath(segments, next, {
+      persist: state.persistOptIns.hasAnyOptInForPath(key)
+    });
+  }
+  return {
+    append(path, value) {
+      const next = readArray(path);
+      next.push(value);
+      return writeArray(path, next);
+    },
+    prepend(path, value) {
+      const next = readArray(path);
+      next.unshift(value);
+      return writeArray(path, next);
+    },
+    insert(path, index, value) {
+      const next = readArray(path);
+      next.splice(index, 0, value);
+      return writeArray(path, next);
+    },
+    remove(path, index) {
+      const next = readArray(path);
+      if (index < 0 || index >= next.length) return false;
+      next.splice(index, 1);
+      return writeArray(path, next);
+    },
+    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);
+    },
+    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);
+    },
+    replace(path, index, value) {
+      const next = readArray(path);
+      if (index < 0 || index >= next.length) return false;
+      next[index] = value;
+      return writeArray(path, next);
+    }
+  };
+}
+
+function buildFieldStateAccessor(state) {
+  return function getFieldState(pathInput) {
+    const { segments, key } = canonicalizePath(pathInput);
+    return computed(() => {
+      const record = state.fields.get(key);
+      const value = state.getValueAtPath(segments);
+      const original = state.originals.get(key)?.value;
+      const pristine = state.isPristineAtPath(segments);
+      const schemaForKey = state.schemaErrors.get(key);
+      const blankForKey = state.derivedBlankErrors.value.get(key);
+      const userForKey = state.userErrors.get(key);
+      const errors = [];
+      if (schemaForKey !== void 0) errors.push(...schemaForKey);
+      if (blankForKey !== void 0) errors.push(...blankForKey);
+      if (userForKey !== void 0) errors.push(...userForKey);
+      return {
+        value,
+        original,
+        pristine,
+        dirty: !pristine,
+        focused: record?.focused ?? null,
+        blurred: record?.blurred ?? null,
+        touched: record?.touched ?? null,
+        isConnected: record?.isConnected ?? false,
+        updatedAt: record?.updatedAt ?? null,
+        errors,
+        path: segments,
+        blank: state.blankPaths.has(key)
+      };
+    });
+  };
+}
+
+const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
+  "value",
+  "original",
+  "pristine",
+  "dirty",
+  "focused",
+  "blurred",
+  "touched",
+  "isConnected",
+  "updatedAt",
+  "errors",
+  "path",
+  "blank"
+]);
+function buildFieldStateProxy(state) {
+  const getFieldStateAt = buildFieldStateAccessor(state);
+  const snapshotFieldStateAt = (path) => {
+    const view = getFieldStateAt(path).value;
+    const snapshot = {};
+    for (const k of FIELD_STATE_KEYS) snapshot[k] = view[k];
+    return snapshot;
+  };
+  return buildSurfaceProxy({
+    schema: state.schema,
+    resolveLeaf: (path) => getFieldStateAt(path),
+    leafKeys: FIELD_STATE_KEYS,
+    readLeafKey: (computed, key) => computed.value[key],
+    materializeContainer: (segments) => materializeFields(state, segments, snapshotFieldStateAt)
+  });
+}
+function materializeFields(state, containerSegments, snapshotFieldStateAt) {
+  const liveValue = getAtPath(state.form.value, containerSegments);
+  return walk$2(liveValue, containerSegments, state.schema, snapshotFieldStateAt);
+}
+function walk$2(value, basePath, schema, snapshotFieldStateAt) {
+  if (schema.isLeafAtPath(basePath)) return snapshotFieldStateAt(basePath);
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((_, i) => walk$2(value[i], [...basePath, i], schema, snapshotFieldStateAt));
+  }
+  const result = {};
+  for (const key of Object.keys(value)) {
+    result[key] = walk$2(
+      value[key],
+      [...basePath, key],
+      schema,
+      snapshotFieldStateAt
+    );
+  }
+  return result;
+}
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 300;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 50;
+const PERSISTENCE_KEY_PREFIX = "attaform:";
+const RESERVED_KEY_PREFIX = "__atta:";
+const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
+
+const PERSISTENCE_MODULE_KEY = "persistence";
+async function getStorageAdapter(storage) {
+  if (typeof storage === "object") return storage;
+  switch (storage) {
+    case "local": {
+      const { createLocalStorageAdapter } = await import('../chunks/local-storage.mjs');
+      return createLocalStorageAdapter();
+    }
+    case "session": {
+      const { createSessionStorageAdapter } = await import('../chunks/session-storage.mjs');
+      return createSessionStorageAdapter();
+    }
+    case "indexeddb": {
+      const { createIndexedDbAdapter } = await import('../chunks/indexeddb.mjs');
+      return createIndexedDbAdapter();
+    }
+  }
+}
+const PERSISTED_ENVELOPE_VERSION = 4;
+function readPersistedPayload(value) {
+  if (value === null || value === void 0 || typeof value !== "object") return null;
+  const envelope = value;
+  if (typeof envelope.v !== "number") return null;
+  if (envelope.v !== PERSISTED_ENVELOPE_VERSION) {
+    warnVersionMismatch(envelope.v);
+    return null;
+  }
+  if (envelope.data === void 0 || typeof envelope.data !== "object") return null;
+  return envelope;
+}
+const warnedVersions = __DEV__ ? /* @__PURE__ */ new Set() : null;
+function warnVersionMismatch(observedVersion) {
+  if (warnedVersions === null) return;
+  if (warnedVersions.has(observedVersion)) return;
+  warnedVersions.add(observedVersion);
+  console.warn(
+    `[attaform] Dropping persisted draft \u2014 envelope v=${observedVersion}, but this version of the library expects v=${PERSISTED_ENVELOPE_VERSION}. The persisted shape changed across releases; older drafts can't be restored. New drafts saved this session will use the current envelope.`
+  );
+}
+function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
+  const transientList = blankPaths !== void 0 && blankPaths.size > 0 ? [...blankPaths] : void 0;
+  if (include === "form") {
+    if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
+    return {
+      v: PERSISTED_ENVELOPE_VERSION,
+      data: { form, blankPaths: transientList }
+    };
+  }
+  return {
+    v: PERSISTED_ENVELOPE_VERSION,
+    data: {
+      form,
+      schemaErrors: [...schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
+      userErrors: [...userErrors.entries()].map(([k, v]) => [k, [...v]]),
+      ...transientList !== void 0 ? { blankPaths: transientList } : {}
+    }
+  };
+}
+function createDebouncedWriter(write, debounceMs) {
+  let timer = null;
+  let pending = null;
+  function schedule() {
+    if (timer !== null) clearTimeout(timer);
+    if (debounceMs === 0) {
+      pending = write().finally(() => {
+        pending = null;
+      });
+      return;
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      pending = write().finally(() => {
+        pending = null;
+      });
+    }, debounceMs);
+  }
+  async function flush() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+      pending = write().finally(() => {
+        pending = null;
+      });
+    }
+    if (pending !== null) await pending;
+  }
+  function cancel() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  return { schedule, flush, cancel };
+}
+function resolveStorageKeyBase(config, formKey) {
+  return config.key ?? `${PERSISTENCE_KEY_PREFIX}${formKey}`;
+}
+async function cleanupOrphanKeys(adapter, base, currentKey) {
+  let keys;
+  try {
+    keys = await adapter.listKeys(base);
+  } catch {
+    return;
+  }
+  for (const key of keys) {
+    if (key === currentKey) continue;
+    if (key === base || key.startsWith(`${base}:`)) {
+      void adapter.removeItem(key).catch(() => void 0);
+    }
+  }
+}
+const STANDARD_STORAGE_KINDS = ["local", "session", "indexeddb"];
+function normalizePersistConfig(input) {
+  if (typeof input === "string") return { storage: input };
+  if ("storage" in input) return input;
+  return { storage: input };
+}
+async function sweepAllOrphansAcrossStandardStores(base) {
+  for (const kind of STANDARD_STORAGE_KINDS) {
+    try {
+      const adapter = await getStorageAdapter(kind);
+      const keys = await adapter.listKeys(base);
+      for (const key of keys) {
+        if (key === base || key.startsWith(`${base}:`)) {
+          void adapter.removeItem(key).catch(() => void 0);
+        }
+      }
+    } catch {
+    }
+  }
+}
+async function sweepNonConfiguredStandardStoresForOrphans(configured, base) {
+  const configuredKind = typeof configured === "string" ? configured : null;
+  for (const kind of STANDARD_STORAGE_KINDS) {
+    if (kind === configuredKind) continue;
+    try {
+      const adapter = await getStorageAdapter(kind);
+      const keys = await adapter.listKeys(base);
+      for (const key of keys) {
+        if (key === base || key.startsWith(`${base}:`)) {
+          void adapter.removeItem(key).catch(() => void 0);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function pluckPaths(form, pathKeys) {
+  let sparse = void 0;
+  for (const pathKey of pathKeys) {
+    const segments = segmentsForPathKey(pathKey);
+    if (segments === null) continue;
+    const value = getAtPath(form, segments);
+    if (value === void 0) continue;
+    sparse = setAtPath(sparse ?? {}, segments, value);
+  }
+  return sparse ?? {};
+}
+function filterErrorsByPaths(errors, pathKeys) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of errors) {
+    if (pathKeys.has(key)) out.set(key, value);
+  }
+  return out;
+}
+function mergeSparseHydration(schemaDefaults, sparse, schema) {
+  return mergeDeep(schemaDefaults, sparse, [], schema);
+}
+function mergeDeep(target, source, path, schema) {
+  if (source === void 0) return target;
+  if (source === null || typeof source !== "object") return source;
+  if (Array.isArray(source)) return source;
+  if (!isPlainRecord(source)) return source;
+  let mergeTarget = target;
+  if (schema !== void 0) {
+    const du = schema.getUnionDiscriminatorAtPath(path);
+    if (du !== void 0) {
+      const sourceDisc = source[du.discriminatorKey];
+      const targetDisc = isPlainRecord(target) ? target[du.discriminatorKey] : void 0;
+      if (sourceDisc !== void 0 && !Object.is(sourceDisc, targetDisc)) {
+        const variantDefault = du.getVariantDefault(sourceDisc);
+        if (isPlainRecord(variantDefault)) {
+          mergeTarget = variantDefault;
+        }
+      }
+    }
+  }
+  const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
+  for (const key of Object.keys(source)) {
+    out[key] = mergeDeep(out[key], source[key], [...path, key], schema);
+  }
+  return out;
+}
+
+const AttaformErrorCode = {
+  /** A required field is in the blank set — user hasn't supplied a value. */
+  NoValueSupplied: "atta:no-value-supplied",
+  /** The schema adapter's `validateAtPath` threw synchronously. */
+  AdapterThrew: "atta:adapter-threw",
+  /** The supplied path didn't resolve to any node in the schema. */
+  PathNotFound: "atta:path-not-found"
+};
+
+const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+function buildProcessForm(state, formInstanceId, options = {}) {
+  const invalidPolicy = options.onInvalidSubmit ?? "none";
+  function validate(pathInput) {
+    const result = ref({
+      pending: true,
+      errors: void 0,
+      success: false,
+      formKey: state.formKey
+    });
+    let gen = 0;
+    async function kickoff(data, path, captured) {
+      state.activeValidations.value += 1;
+      result.value = {
+        pending: true,
+        errors: void 0,
+        success: false,
+        formKey: state.formKey
+      };
+      try {
+        const refinement = await runRefinementValidation(data, path);
+        if (captured !== gen) return;
+        result.value = settled(composeWithDerivedBlank(refinement, path));
+      } catch (err) {
+        if (captured !== gen) return;
+        result.value = {
+          pending: false,
+          errors: [
+            {
+              message: adapterThrowMessage(err),
+              path: [],
+              formKey: state.formKey,
+              code: AttaformErrorCode.AdapterThrew
+            }
+          ],
+          success: false,
+          formKey: state.formKey
+        };
+      } finally {
+        state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
+      }
+    }
+    const stop = watchEffect(() => {
+      const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
+      const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
+      const localGen = ++gen;
+      queueMicrotask(() => {
+        void kickoff(dataAtPath, segments, localGen);
+      });
+    });
+    if (getCurrentScope() !== void 0) {
+      onScopeDispose(stop);
+    } else if (__DEV__ && warnedNoScopeStores !== null && !warnedNoScopeStores.has(state)) {
+      warnedNoScopeStores.add(state);
+      console.warn(
+        "[attaform] validate() called outside a Vue effect scope; its reactive watcher will leak until the form is garbage-collected. Fix: call validate() inside setup() / a child component, or wrap the call in `effectScope().run(...)`."
+      );
+    }
+    return result;
+  }
+  async function validateAsync(pathInput) {
+    const segments = pathInput === void 0 ? void 0 : toSegments(pathInput);
+    const dataAtPath = segments === void 0 ? state.form.value : state.getValueAtPath(segments);
+    state.activeValidations.value += 1;
+    try {
+      const refinement = await runRefinementValidation(dataAtPath, segments);
+      return stripData(composeWithDerivedBlank(refinement, segments));
+    } finally {
+      state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
+    }
+  }
+  async function runRefinementValidation(data, path) {
+    return await state.schema.validateAtPath(data, path);
+  }
+  function composeWithDerivedBlank(refinement, scope) {
+    const blankErrors = collectScopedBlankErrors(state, scope);
+    if (blankErrors.length === 0) return refinement;
+    if (refinement.success) {
+      return {
+        data: void 0,
+        errors: blankErrors,
+        success: false,
+        formKey: state.formKey
+      };
+    }
+    return { ...refinement, errors: [...refinement.errors, ...blankErrors] };
+  }
+  const handleSubmit = (onSubmit, onError) => {
+    const submitHandler = async (event) => {
+      if (event !== void 0 && "preventDefault" in event && typeof event.preventDefault === "function") {
+        event.preventDefault();
+      }
+      const genAtEntry = state.submissionGeneration.value;
+      state.activeSubmissions.value += 1;
+      state.isSubmitting.value = true;
+      state.submitError.value = null;
+      state.cancelFieldValidation();
+      state.activeValidations.value += 1;
+      let validationSettled = false;
+      try {
+        const refinement = await runRefinementValidation(state.form.value, void 0);
+        const merged = composeWithDerivedBlank(refinement, void 0);
+        state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
+        validationSettled = true;
+        const generationStillValid = state.submissionGeneration.value === genAtEntry;
+        if (!merged.success) {
+          if (generationStillValid) {
+            if (refinement.success) {
+              state.clearSchemaErrors();
+            } else {
+              state.setAllSchemaErrors(refinement.errors);
+            }
+          }
+          if (generationStillValid) {
+            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+          }
+          if (onError !== void 0) {
+            try {
+              await onError(merged.errors);
+            } catch (cause) {
+              throw new SubmitErrorHandlerError("User-provided onError threw", { cause });
+            }
+          }
+          return;
+        }
+        if (generationStillValid) {
+          state.clearSchemaErrors();
+        }
+        await onSubmit(merged.data);
+        state.emitSubmitSuccess();
+      } catch (err) {
+        if (state.submissionGeneration.value === genAtEntry) {
+          state.submitError.value = err;
+        }
+        throw err;
+      } finally {
+        if (!validationSettled) {
+          state.activeValidations.value = Math.max(0, state.activeValidations.value - 1);
+        }
+        state.activeSubmissions.value = Math.max(0, state.activeSubmissions.value - 1);
+        if (state.submissionGeneration.value === genAtEntry) {
+          state.isSubmitting.value = state.activeSubmissions.value > 0;
+          state.submitCount.value += 1;
+        }
+      }
+    };
+    return submitHandler;
+  };
+  return { validate, validateAsync, handleSubmit };
+}
+function toSegments(pathInput) {
+  return canonicalizePath(pathInput).segments;
+}
+function settled(response) {
+  if (response.success) {
+    return { pending: false, errors: void 0, success: true, formKey: response.formKey };
+  }
+  return { pending: false, errors: response.errors, success: false, formKey: response.formKey };
+}
+function stripData(response) {
+  if (response.success) {
+    return { errors: void 0, success: true, formKey: response.formKey };
+  }
+  return { errors: response.errors, success: false, formKey: response.formKey };
+}
+function adapterThrowMessage(err) {
+  if (err instanceof Error) return `Adapter validateAtPath threw: ${err.message}`;
+  return "Adapter validateAtPath threw a non-Error value";
+}
+function collectScopedBlankErrors(state, scope) {
+  const derived = state.derivedBlankErrors.value;
+  if (derived.size === 0) return [];
+  const errors = [];
+  for (const [pathKey, entries] of derived) {
+    if (scope !== void 0) {
+      const segments = segmentsForPathKey(pathKey);
+      if (segments === null) continue;
+      if (!pathStartsWith(segments, scope)) continue;
+    }
+    errors.push(...entries);
+  }
+  return errors;
+}
+function pathStartsWith(target, prefix) {
+  if (prefix.length > target.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (!Object.is(target[i], prefix[i])) return false;
+  }
+  return true;
+}
+function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
+  if (policy === "none") return;
+  const target = state.getFirstErrorElement(formInstanceId);
+  if (target === null) return;
+  if (policy === "scroll-to-first-error") {
+    target.element.scrollIntoView();
+    return;
+  }
+  if (policy === "focus-first-error") {
+    target.element.focus();
+    return;
+  }
+  target.element.scrollIntoView();
+  target.element.focus({ preventScroll: true });
+}
+
+function extractSchemaFields(schema) {
+  try {
+    const root = schema.getDefaultAtPath([]);
+    if (root !== null && typeof root === "object" && !Array.isArray(root)) {
+      return Object.keys(root);
+    }
+  } catch {
+  }
+  return [];
+}
+
+const warnedRejections = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function shouldWarnOnce$1(store, key) {
+  if (warnedRejections === null) return false;
+  let set = warnedRejections.get(store);
+  if (set === void 0) {
+    set = /* @__PURE__ */ new Set();
+    warnedRejections.set(store, set);
+  }
+  if (set.has(key)) return false;
+  set.add(key);
+  return true;
+}
+function slimKindOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  const t = typeof value;
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "function":
+      return "function";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return "object";
+  }
+}
+function isLeafValue(value) {
+  if (value === null || value === void 0) return true;
+  if (Array.isArray(value)) return false;
+  if (isPlainRecord(value)) return false;
+  return true;
+}
+function isSlimPrimitiveValid(schema, store, path, value) {
+  return walk$1(schema, store, path, value);
+}
+function walk$1(schema, store, path, value) {
+  const accepted = schema.getSlimPrimitiveTypesAtPath(path);
+  const kind = isLeafValue(value) ? slimKindOf(value) : Array.isArray(value) ? "array" : "object";
+  if (!accepted.has(kind)) {
+    reportRejection(store, path, kind, accepted);
+    return false;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if (!walk$1(schema, store, [...path, i], value[i])) return false;
+    }
+    return true;
+  }
+  if (isPlainRecord(value)) {
+    for (const key of Object.keys(value)) {
+      if (!walk$1(schema, store, [...path, key], value[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return true;
+}
+function reportRejection(store, path, kind, accepted) {
+  if (!__DEV__) return;
+  const dotted = path.map((s) => String(s)).join(".") || "(root)";
+  const key = `${dotted}::${kind}`;
+  if (!shouldWarnOnce$1(store, key)) return;
+  if (accepted.size === 0) {
+    console.warn(
+      `[attaform] Cannot write to '${dotted}' \u2014 this path is not in your schema.
+  Fix: check for a typo in register('${dotted}'); it should match a leaf key in your schema.
+  (If the path resolves to a never-typed schema, it explicitly admits no values \u2014 relax the schema if intentional.)
+  The write was a no-op.`
+    );
+    return;
+  }
+  const expected = formatExpectedKinds(accepted);
+  if (kind === "string" && accepted.has("number")) {
+    console.warn(
+      `[attaform] Cannot write a string to '${dotted}' \u2014 the schema expects ${expected}.
+  Fix: add type="number" to the input, OR use the .number modifier on v-register:
+    <input type="number" v-register="register('${dotted}')" />
+    <input v-register.number="register('${dotted}')" />
+  The write was a no-op.`
+    );
+    return;
+  }
+  console.warn(
+    `[attaform] Cannot write a ${kind} to '${dotted}' \u2014 the schema expects ${expected}.
+  The write was a no-op.`
+  );
+}
+function formatExpectedKinds(accepted) {
+  const list = [...accepted].sort();
+  if (list.length === 1) return list[0];
+  if (list.length === 2) return `${list[0]} or ${list[1]}`;
+  return `one of: ${list.join(", ")}`;
+}
+
+function defineCoercion(entry) {
+  return entry;
+}
+const IDENTITY = (v) => v;
+const EMPTY_INDEX = /* @__PURE__ */ new Map();
+const defaultCoercionRules = [
+  defineCoercion({
+    input: "string",
+    output: "number",
+    transform: (s) => {
+      const trimmed = s.trim();
+      if (trimmed === "") return { coerced: false };
+      const n = Number(trimmed);
+      if (!Number.isFinite(n)) return { coerced: false };
+      return { coerced: true, value: n };
+    }
+  }),
+  defineCoercion({
+    input: "string",
+    output: "boolean",
+    transform: (s) => {
+      const normalized = s.trim().toLowerCase();
+      if (normalized === "true") return { coerced: true, value: true };
+      if (normalized === "false") return { coerced: true, value: false };
+      return { coerced: false };
+    }
+  })
+];
+function resolveCoercionIndex(config) {
+  if (config === false) return EMPTY_INDEX;
+  const rules = config === void 0 || config === true ? defaultCoercionRules : config;
+  return indexRules(rules);
+}
+function indexRules(rules) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const entry of rules) {
+    const candidate = entry;
+    if (candidate === null || typeof candidate !== "object" || typeof candidate.transform !== "function") {
+      if (__DEV__) {
+        console.warn("[attaform] coercion entry missing or invalid `transform` \u2014 skipped.");
+      }
+      continue;
+    }
+    const key = `${entry.input}->${entry.output}`;
+    if (idx.has(key) && __DEV__) {
+      console.warn(`[attaform] duplicate coercion rule for '${key}' \u2014 last entry wins.`);
+    }
+    idx.set(key, entry);
+  }
+  return idx;
+}
+function buildCoerceFn(schema, segments, index) {
+  if (index === EMPTY_INDEX) return IDENTITY;
+  if (index.size === 0) return IDENTITY;
+  const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
+  const elementAccepted = accepted.has("array") || accepted.has("set") ? schema.getSlimPrimitiveTypesAtPath([...segments, 0]) : void 0;
+  return (value) => coerceValue(value, accepted, elementAccepted, index);
+}
+function buildElementCoerceFn(schema, segments, index) {
+  if (index === EMPTY_INDEX) return void 0;
+  if (index.size === 0) return void 0;
+  const accepted = schema.getSlimPrimitiveTypesAtPath(segments);
+  if (!accepted.has("array") && !accepted.has("set")) return void 0;
+  const elementAccepted = schema.getSlimPrimitiveTypesAtPath([...segments, 0]);
+  return (value) => coerceScalar(value, elementAccepted, index);
+}
+function pickScalarTarget(accepted) {
+  if (accepted.has("string")) return null;
+  if (accepted.has("number")) return "number";
+  if (accepted.has("boolean")) return "boolean";
+  if (accepted.has("bigint")) return "bigint";
+  return null;
+}
+const warnedCoerce = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+const sharedWarnStore = {};
+function shouldWarnOnce(key) {
+  if (warnedCoerce === null) return false;
+  let set = warnedCoerce.get(sharedWarnStore);
+  if (set === void 0) {
+    set = /* @__PURE__ */ new Set();
+    warnedCoerce.set(sharedWarnStore, set);
+  }
+  if (set.has(key)) return false;
+  set.add(key);
+  return true;
+}
+function coerceScalar(value, accepted, index) {
+  if (accepted.size === 0) return value;
+  const sourceKind = slimKindOf(value);
+  if (accepted.has(sourceKind)) return value;
+  const target = pickScalarTarget(accepted);
+  if (target === null) return value;
+  const entry = index.get(`${sourceKind}->${target}`);
+  if (entry === void 0) return value;
+  let result;
+  try {
+    result = entry.transform(value);
+  } catch (err) {
+    if (__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::throw`)) {
+      console.warn(
+        `[attaform] coercion '${entry.input}->${entry.output}' threw \u2014 write passes through.`,
+        err
+      );
+    }
+    return value;
+  }
+  if (!result.coerced) return value;
+  const returnedKind = slimKindOf(result.value);
+  if (returnedKind !== entry.output) {
+    if (__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::wrong-kind:${returnedKind}`)) {
+      console.warn(
+        `[attaform] coercion '${entry.input}->${entry.output}' produced a ${returnedKind} \u2014 write passes through.`
+      );
+    }
+    return value;
+  }
+  if (entry.output === "number" && !Number.isFinite(result.value)) {
+    if (__DEV__ && shouldWarnOnce(`${entry.input}->${entry.output}::nan`)) {
+      console.warn(
+        `[attaform] coercion '${entry.input}->${entry.output}' produced a non-finite number \u2014 write passes through.`
+      );
+    }
+    return value;
+  }
+  return result.value;
+}
+function coerceArrayMembers(arr, elementAccepted, index) {
+  let changed = false;
+  const out = [];
+  for (const el of arr) {
+    const next = coerceScalar(el, elementAccepted, index);
+    if (next !== el) changed = true;
+    out.push(next);
+  }
+  return changed ? out : arr;
+}
+function coerceSetMembers(set, elementAccepted, index) {
+  let changed = false;
+  const out = [];
+  for (const el of set) {
+    const next = coerceScalar(el, elementAccepted, index);
+    if (next !== el) changed = true;
+    out.push(next);
+  }
+  return changed ? new Set(out) : set;
+}
+function coerceValue(value, accepted, elementAccepted, index) {
+  if (Array.isArray(value)) {
+    if (!accepted.has("array") || elementAccepted === void 0) return value;
+    return coerceArrayMembers(value, elementAccepted, index);
+  }
+  if (value instanceof Set) {
+    if (!accepted.has("set") || elementAccepted === void 0) return value;
+    return coerceSetMembers(value, elementAccepted, index);
+  }
+  return coerceScalar(value, accepted, index);
+}
+
+const EMPTY_TRANSFORMS = Object.freeze([]);
+const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
+const attaformListenersSymbol = Symbol.for("attaform:focus-listeners");
+function attachFocusListeners(state, segments, element) {
+  const target = element;
+  if (target[attaformListenersSymbol] !== void 0) return;
+  const handleFocus = () => state.markFocused(segments, true);
+  const handleBlur = () => state.markFocused(segments, false);
+  element.addEventListener("focus", handleFocus);
+  element.addEventListener("blur", handleBlur);
+  target[attaformListenersSymbol] = { handleFocus, handleBlur };
+}
+function detachFocusListeners(element) {
+  const target = element;
+  const listeners = target[attaformListenersSymbol];
+  if (listeners === void 0) return;
+  element.removeEventListener("focus", listeners.handleFocus);
+  element.removeEventListener("blur", listeners.handleBlur);
+  delete target[attaformListenersSymbol];
+}
+function buildRegister(state, formInstanceId) {
+  const lastTypedFormByPath = /* @__PURE__ */ new Map();
+  return function register(pathInput, options) {
+    const { segments, key: pathKey } = canonicalizePath(pathInput);
+    const innerRef = computed(() => state.getValueAtPath(segments));
+    let lastTypedForm = lastTypedFormByPath.get(pathKey);
+    if (lastTypedForm === void 0) {
+      lastTypedForm = ref(null);
+      lastTypedFormByPath.set(pathKey, lastTypedForm);
+    }
+    const displayValue = computed(() => {
+      if (state.blankPaths.has(pathKey)) return "";
+      const raw = state.getValueAtPath(segments);
+      if (raw === null || raw === void 0) return "";
+      const typed = lastTypedForm.value;
+      if (typed !== null && typeof raw === "number" && parseFloat(typed) === raw) {
+        return typed;
+      }
+      return String(raw);
+    });
+    const slimDefault = state.schema.getDefaultAtPath(segments);
+    const persist = options?.persist === true;
+    const acknowledgeSensitive = options?.acknowledgeSensitive === true;
+    const transforms = options?.transforms ?? EMPTY_TRANSFORMS;
+    const coerce = buildCoerceFn(
+      state.schema,
+      segments,
+      state.coerceIndex
+    );
+    const coerceElement = buildElementCoerceFn(
+      state.schema,
+      segments,
+      state.coerceIndex
+    );
+    if (persist && !state.isSSR && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
+      throw new AnonPersistError({
+        cause: "register-without-config",
+        schemaFields: extractSchemaFields(state.schema),
+        callSite: captureUserCallSite()
+      });
+    }
+    return {
+      innerRef,
+      displayValue,
+      lastTypedForm,
+      markBlank: () => {
+        return state.setValueAtPath(segments, slimDefault, {
+          blank: true,
+          persist
+        });
+      },
+      registerElement: (element) => {
+        if (!INTERACTIVE_TAG_NAMES.has(element.tagName)) return;
+        const added = state.registerElement(segments, element, formInstanceId);
+        if (added) attachFocusListeners(state, segments, element);
+      },
+      deregisterElement: (element) => {
+        detachFocusListeners(element);
+        state.deregisterElement(segments, element);
+      },
+      setValueWithInternalPath: (value, meta) => {
+        return state.setValueAtPath(segments, value, meta);
+      },
+      // Called by the `vRegisterHint` compile-time transform's wrapping
+      // IIFE on every server-side render of `<element v-register="…">`.
+      // Without it, every SSR'd FieldState serialises `isConnected: false`
+      // (because Vue skips directive lifecycle during SSR) and the client
+      // briefly shows that stale flag until hydration runs the directive's
+      // `created` hook. The mark only takes effect when `state.isSSR` is
+      // true; on the client this is a no-op so the directive lifecycle
+      // remains the source of truth.
+      markConnectedOptimistically: () => {
+        state.markConnectedOptimistically(segments);
+      },
+      // --- Persistence opt-in (internal; the directive is the only
+      // legitimate consumer) ---
+      path: pathKey,
+      persist,
+      acknowledgeSensitive,
+      persistOptIns: state.persistOptIns,
+      transforms,
+      coerce,
+      ...coerceElement !== void 0 ? { coerceElement } : {}
+    };
+  };
+}
+
+const unset = Symbol.for("attaform/unset");
+function isUnset(value) {
+  return value === unset;
+}
+
+function walkUnsetSentinels(values, schema) {
+  const paths = [];
+  if (values === void 0) {
+    const rootSlim = schema.getDefaultAtPath([]);
+    walkUnspecified(rootSlim, [], paths);
+    return { cleanedValues: void 0, paths };
+  }
+  const cleaned = walk(values, [], schema, paths);
+  return { cleanedValues: cleaned, paths };
+}
+function walk(input, segments, schema, paths) {
+  if (isUnset(input)) {
+    const slim = schema.getDefaultAtPath(segments);
+    if (!isPrimitiveOrEmpty(slim)) {
+      warnNonPrimitiveLeaf(segments, slim);
+      return walkUnspecified(slim, segments, paths);
+    }
+    paths.push(canonicalizePath(segments).key);
+    return slim;
+  }
+  if (input === void 0) {
+    const slim = schema.getDefaultAtPath(segments);
+    return walkUnspecified(slim, segments, paths);
+  }
+  if (input === null) return null;
+  if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    const out = new Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      out[i] = walk(input[i], [...segments, i], schema, paths);
+    }
+    return out;
+  }
+  if (typeof input === "object") {
+    const slim = schema.getDefaultAtPath(segments);
+    const allKeys = new Set(Object.keys(input));
+    if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !(slim instanceof Date) && !(slim instanceof RegExp) && !(slim instanceof Map) && !(slim instanceof Set)) {
+      for (const k of Object.keys(slim)) allKeys.add(k);
+    }
+    const out = {};
+    for (const key of allKeys) {
+      out[key] = walk(input[key], [...segments, key], schema, paths);
+    }
+    return out;
+  }
+  return input;
+}
+function walkUnspecified(slim, segments, paths) {
+  if (isPrimitiveOrEmpty(slim)) {
+    if (isNumericPrimitive(slim)) {
+      paths.push(canonicalizePath(segments).key);
+    }
+    return slim;
+  }
+  if (slim instanceof Date || slim instanceof RegExp || slim instanceof Map || slim instanceof Set || typeof slim === "function") {
+    return slim;
+  }
+  if (Array.isArray(slim)) return slim;
+  if (slim !== null && typeof slim === "object") {
+    const out = {};
+    for (const key of Object.keys(slim)) {
+      out[key] = walkUnspecified(slim[key], [...segments, key], paths);
+    }
+    return out;
+  }
+  return slim;
+}
+function isPrimitiveOrEmpty(value) {
+  if (value === null || value === void 0) return true;
+  const t = typeof value;
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint";
+}
+function isNumericPrimitive(value) {
+  const t = typeof value;
+  return t === "number" || t === "bigint";
+}
+const warnedNonPrimitivePaths = __DEV__ ? /* @__PURE__ */ new Set() : null;
+function warnNonPrimitiveLeaf(segments, slim) {
+  if (warnedNonPrimitivePaths === null) return;
+  const dotted = segments.map(String).join(".");
+  if (warnedNonPrimitivePaths.has(dotted)) return;
+  warnedNonPrimitivePaths.add(dotted);
+  const slimType = slim === null ? "null" : slim instanceof Date ? "Date" : typeof slim;
+  console.warn(
+    `[attaform] \`unset\` at "${dotted || "<root>"}" is a no-op \u2014 unset only works at primitive leaves (string / number / boolean / bigint, plus their optional / nullable variants), got "${slimType}". The slim default was written but the path is NOT marked blank. (TypeScript catches this at compile time; this warn covers plain-JS callers.)`
+  );
+}
+
+function buildValuesProxy(form) {
+  const inner = computed(() => readonly(form.value));
+  const target = (() => {
+  });
+  return new Proxy(target, {
+    apply(_, __, args) {
+      const arg = args[0];
+      if (arg === void 0) return inner.value;
+      const { segments } = canonicalizePath(arg);
+      let cursor = inner.value;
+      for (const seg of segments) {
+        if (cursor === null || cursor === void 0) return void 0;
+        cursor = cursor[seg];
+      }
+      return cursor;
+    },
+    get(_, key) {
+      if (typeof key === "symbol") return Reflect.get(target, key);
+      if (key === "toJSON") return () => inner.value;
+      return inner.value[key];
+    },
+    has(_, key) {
+      if (typeof key === "symbol") return Reflect.has(target, key);
+      return Reflect.has(inner.value, key);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(inner.value);
+    },
+    getOwnPropertyDescriptor(_, key) {
+      const desc = Reflect.getOwnPropertyDescriptor(inner.value, key);
+      if (desc !== void 0) desc.configurable = true;
+      return desc;
+    },
+    // Match Vue's `readonly()` semantics: writes warn (in dev) and
+    // silently noop (return true). Returning false would throw
+    // TypeError in strict-mode consumers, surprising users who
+    // assigned through the proxy and expected it to be ignored.
+    set(_, key) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] form.values is read-only \u2014 write to "${String(key)}" was ignored. Use form.setValue / the directive / field-array helpers instead.`
+        );
+      }
+      return true;
+    },
+    deleteProperty(_, key) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] form.values is read-only \u2014 delete of "${String(key)}" was ignored.`
+        );
+      }
+      return true;
+    },
+    defineProperty: () => true
+  });
+}
+
+function readonlySetSnapshot(source) {
+  const snapshot = new Set(source);
+  return new Proxy(snapshot, {
+    get(target, prop) {
+      if (prop === "add" || prop === "delete" || prop === "clear") {
+        return () => {
+          throw new TypeError(`Cannot mutate readonly Set: '${String(prop)}' is not allowed.`);
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function buildFormApi(state, formInstanceId, options = {}) {
+  const register = buildRegister(state, formInstanceId);
+  const processOptions = options.onInvalidSubmit !== void 0 ? { onInvalidSubmit: options.onInvalidSubmit } : {};
+  const {
+    validate: validateBuilt,
+    validateAsync: validateAsyncBuilt,
+    handleSubmit
+  } = buildProcessForm(state, formInstanceId, processOptions);
+  const validate = (pathInput) => validateBuilt(pathInput);
+  const validateAsync = (pathInput) => validateAsyncBuilt(pathInput);
+  function pathToRef(pathInput) {
+    const segments = canonicalizePath(pathInput).segments;
+    return computed(() => getAtPath(state.form.value, segments));
+  }
+  function setValueImpl(pathOrValue, maybeValue) {
+    if (arguments.length === 1) {
+      const next = typeof pathOrValue === "function" ? pathOrValue(state.form.value) : pathOrValue;
+      const walked = walkUnsetSentinels(
+        next,
+        state.schema
+      );
+      const ok = state.setValueAtPath([], walked.cleanedValues);
+      if (!ok) return false;
+      for (const pathKey of walked.paths) {
+        const segments2 = segmentsForPathKey(pathKey);
+        if (segments2 === null) continue;
+        state.setValueAtPath(segments2, state.schema.getDefaultAtPath(segments2), {
+          blank: true
+        });
+      }
+      return true;
+    }
+    const segments = canonicalizePath(pathOrValue).segments;
+    if (isUnset(maybeValue)) {
+      return state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
+        blank: true
+      });
+    }
+    let resolvedValue;
+    if (typeof maybeValue === "function") {
+      const current = state.getValueAtPath(segments);
+      const prev = current === void 0 ? state.schema.getDefaultAtPath(segments) : current;
+      resolvedValue = maybeValue(prev);
+      if (isUnset(resolvedValue)) {
+        return state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
+          blank: true
+        });
+      }
+    } else {
+      resolvedValue = maybeValue;
+    }
+    return state.setValueAtPath(segments, resolvedValue);
+  }
+  const errorsProxy = buildErrorsProxy(state);
+  function setFieldErrors(errors) {
+    state.setAllUserErrors(errors);
+  }
+  function addFieldErrors(errors) {
+    state.addUserErrors(errors);
+  }
+  function clearFieldErrors(path) {
+    if (path === void 0) {
+      state.clearSchemaErrors();
+      state.clearUserErrors();
+      return;
+    }
+    const segments = canonicalizePath(path).segments;
+    state.clearSchemaErrors(segments);
+    state.clearUserErrors(segments);
+  }
+  const isDirty = computed(() => {
+    for (const [, { segments, value: original }] of state.originals) {
+      if (!Object.is(getAtPath(state.form.value, segments), original)) return true;
+    }
+    if (state.blankPaths.size !== state.originalBlankPaths.size) return true;
+    for (const key of state.blankPaths) {
+      if (!state.originalBlankPaths.has(key)) return true;
+    }
+    return false;
+  });
+  const isValid = computed(
+    () => state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0
+  );
+  const isSubmitting = computed(() => state.isSubmitting.value);
+  const submitCount = computed(() => state.submitCount.value);
+  const submitError = computed(() => state.submitError.value);
+  const isValidating = computed(() => state.activeValidations.value > 0);
+  const history = options.history;
+  const undo = history?.undo ?? (() => false);
+  const redo = history?.redo ?? (() => false);
+  const canUndo = history?.canUndo ?? computed(() => false);
+  const canRedo = history?.canRedo ?? computed(() => false);
+  const historySize = history?.historySize ?? computed(() => 0);
+  const metaErrors = computed(() => {
+    const buckets = /* @__PURE__ */ new Map();
+    const collect = (errs) => {
+      for (const [pathKey, list] of errs) {
+        if (list.length === 0) continue;
+        const ordinal = state.ensurePathOrdinal(pathKey);
+        const existing = buckets.get(ordinal);
+        if (existing === void 0) buckets.set(ordinal, [...list]);
+        else existing.push(...list);
+      }
+    };
+    collect(state.schemaErrors);
+    collect(state.derivedBlankErrors.value);
+    collect(state.userErrors);
+    if (buckets.size === 0) return [];
+    return [...buckets.entries()].sort(([a], [b]) => a - b).flatMap(([, errs]) => errs);
+  });
+  const formMeta = readonly(
+    reactive({
+      isDirty,
+      isValid,
+      isSubmitting,
+      isValidating,
+      submitCount,
+      submitError,
+      canUndo,
+      canRedo,
+      historySize,
+      errors: metaErrors,
+      // Per-`useForm()`-call identity. Stable for one mount; new on
+      // re-mount; orthogonal to `form.key` (which is the user-supplied
+      // shared identifier). Useful for devtools panels disambiguating
+      // shared-key instances, telemetry hooks tagging events with
+      // "which mount", and E2E tests stamping `data-form-id`.
+      instanceId: formInstanceId
+    })
+  );
+  const persistence = state.modules.get(PERSISTENCE_MODULE_KEY);
+  const reset = (nextDefaultValues) => {
+    if (nextDefaultValues === void 0) {
+      state.reset();
+    } else {
+      const walked = walkUnsetSentinels(
+        nextDefaultValues,
+        state.schema
+      );
+      state.reset(walked.cleanedValues);
+      for (const pathKey of walked.paths) {
+        const segments = segmentsForPathKey(pathKey);
+        if (segments === null) continue;
+        state.setValueAtPath(segments, state.schema.getDefaultAtPath(segments), {
+          blank: true
+        });
+        state.originalBlankPaths.add(pathKey);
+      }
+    }
+    if (persistence !== void 0) {
+      void persistence.clearPersistedDraft().catch(() => void 0);
+    }
+  };
+  const resetField = (pathInput) => {
+    const segments = canonicalizePath(pathInput).segments;
+    state.resetField(segments);
+    if (persistence !== void 0) {
+      void persistence.clearPersistedDraft(segments).catch(() => void 0);
+    }
+  };
+  const persist = async (pathInput, options2) => {
+    const segments = canonicalizePath(pathInput).segments;
+    enforceSensitiveCheck(segments, options2?.acknowledgeSensitive === true);
+    if (persistence === void 0) return;
+    await persistence.writePathImmediately(segments);
+  };
+  const clearPersistedDraft = async (pathInput) => {
+    if (persistence === void 0) return;
+    if (pathInput === void 0) {
+      await persistence.clearPersistedDraft();
+      return;
+    }
+    const segments = canonicalizePath(pathInput).segments;
+    await persistence.clearPersistedDraft(segments);
+  };
+  const focusFirstError = (options2) => {
+    const target = state.getFirstErrorElement(formInstanceId);
+    if (target === null) return false;
+    target.element.focus(options2);
+    return true;
+  };
+  const scrollToFirstError = (options2) => {
+    const target = state.getFirstErrorElement(formInstanceId);
+    if (target === null) return false;
+    target.element.scrollIntoView(options2);
+    return true;
+  };
+  const fieldArrays = buildFieldArrayApi(state);
+  const blankPathsView = computed(() => {
+    return readonlySetSnapshot(state.blankPaths);
+  });
+  const valuesProxy = buildValuesProxy(state.form);
+  const fieldStateProxy = buildFieldStateProxy(state);
+  return {
+    handleSubmit,
+    // `values` is the callable readonly Proxy. Each `get` trap reads
+    // through `inner.value` (a `computed(() => readonly(form.value))`)
+    // so reactivity tracking propagates at the call site. Identity-
+    // stable across whole-form swaps (the inner readonly proxy
+    // re-keys; the outer callable proxy stays the same instance).
+    values: valuesProxy,
+    fields: fieldStateProxy,
+    setValue: setValueImpl,
+    validate,
+    validateAsync,
+    register,
+    key: state.formKey,
+    errors: errorsProxy,
+    toRef: pathToRef,
+    setFieldErrors,
+    addFieldErrors,
+    clearFieldErrors,
+    meta: formMeta,
+    reset,
+    resetField,
+    persist,
+    clearPersistedDraft,
+    focusFirstError,
+    scrollToFirstError,
+    undo,
+    redo,
+    append: fieldArrays.append,
+    prepend: fieldArrays.prepend,
+    insert: fieldArrays.insert,
+    remove: fieldArrays.remove,
+    swap: fieldArrays.swap,
+    move: fieldArrays.move,
+    replace: fieldArrays.replace,
+    blankPaths: blankPathsView
+  };
+}
+
+function isDescendable(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+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) {
+    if (Array.isArray(newValue)) {
+      for (let i = 0; i < newValue.length; i++) {
+        diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+      }
+    } else {
+      const rec = newValue;
+      for (const k of Object.keys(rec)) {
+        diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+      }
+    }
+    return;
+  }
+  if (oldIsDescendable && newValue === void 0) {
+    if (Array.isArray(oldValue)) {
+      for (let i = 0; i < oldValue.length; i++) {
+        diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+      }
+    } else {
+      const rec = oldValue;
+      for (const k of Object.keys(rec)) {
+        diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+      }
+    }
+    return;
+  }
+  if (oldIsDescendable && newIsDescendable) {
+    const oldIsArray = Array.isArray(oldValue);
+    const newIsArray = Array.isArray(newValue);
+    if (oldIsArray && newIsArray) {
+      const oldArr = oldValue;
+      const newArr = newValue;
+      const max = Math.max(oldArr.length, newArr.length);
+      for (let i = 0; i < max; i++) {
+        diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+      }
+      return;
+    }
+    if (!oldIsArray && !newIsArray) {
+      const oldRec = oldValue;
+      const newRec = newValue;
+      const seen = /* @__PURE__ */ new Set();
+      for (const k of Object.keys(oldRec)) {
+        seen.add(k);
+        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+      }
+      for (const k of Object.keys(newRec)) {
+        if (seen.has(k)) continue;
+        diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+      }
+      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 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.isConnected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && (typeof r.touched === "boolean" || r.touched === null);
+}
+function isHydratedValidationErrorArray(value) {
+  if (!Array.isArray(value)) return false;
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) return false;
+    const e = entry;
+    if (typeof e.message !== "string") return false;
+    if (!Array.isArray(e.path)) return false;
+    if (typeof e.formKey !== "string") return false;
+    if (typeof e.code !== "string") return false;
+  }
+  return true;
+}
+function warnMalformedHydration(formKey, kind, rawKey) {
+  if (!__DEV__) return;
+  console.warn(
+    `[attaform] hydration: skipping malformed ${kind} entry at key '${rawKey}' on form '${formKey}'. This usually means the SSR bundle is on a different version than the client (rolling deploy / stale cache).`
+  );
+}
+function isPathKeyUnder(existingKey, parentPath) {
+  const parsed = segmentsForPathKey(existingKey);
+  if (parsed === null) return false;
+  if (parsed.length <= parentPath.length) return false;
+  for (let i = 0; i < parentPath.length; i++) {
+    if (parsed[i] !== parentPath[i]) return false;
+  }
+  return true;
+}
+function createFormStore(options) {
+  const { formKey, schema, defaultValues, strict = true, hydration } = options;
+  const isSSR = options.isSSR === true;
+  const rememberVariants = options.rememberVariants !== false;
+  const fieldValidationMode = options.validateOn ?? "change";
+  const fieldValidationDebounceMs = options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS;
+  const fieldValidationState = /* @__PURE__ */ new Map();
+  const formChangeListeners = /* @__PURE__ */ new Set();
+  const submitSuccessListeners = /* @__PURE__ */ new Set();
+  const resetListeners = /* @__PURE__ */ new Set();
+  const persistOptIns = createPersistOptInRegistry();
+  const coerceIndex = resolveCoercionIndex(options.coerce);
+  const cleanupHooks = [];
+  const modules = /* @__PURE__ */ new Map();
+  const completedConstraints = defaultValues === void 0 ? void 0 : mergeStructural(schema, [], defaultValues);
+  const schemaResponse = schema.getDefaultValues({
+    useDefaultSchemaValues: true,
+    constraints: completedConstraints,
+    strict
+  });
+  const schemaInitialData = schemaResponse.data;
+  const initialData = hydration !== void 0 ? hydration.form : schemaInitialData;
+  const form = ref(initialData);
+  const fields = reactive(/* @__PURE__ */ new Map());
+  const elements = reactive(/* @__PURE__ */ new Map());
+  const elementToFormInstance = /* @__PURE__ */ new WeakMap();
+  let sortedRegistrationsCache = null;
+  const schemaErrors = reactive(/* @__PURE__ */ new Map());
+  const userErrors = reactive(/* @__PURE__ */ new Map());
+  const originals = /* @__PURE__ */ new Map();
+  const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
+  const blankPaths = reactive(/* @__PURE__ */ new Set());
+  const originalBlankPaths = /* @__PURE__ */ new Set();
+  for (const raw of initialTransientList) {
+    blankPaths.add(raw);
+    originalBlankPaths.add(raw);
+  }
+  const variantMemory = /* @__PURE__ */ new Map();
+  const pathOrdinals = /* @__PURE__ */ new Map();
+  let nextOrdinal = 0;
+  function ensurePathOrdinal(key) {
+    let ordinal = pathOrdinals.get(key);
+    if (ordinal === void 0) {
+      ordinal = nextOrdinal;
+      pathOrdinals.set(key, ordinal);
+      nextOrdinal += 1;
+    }
+    return ordinal;
+  }
+  const derivedBlankErrors = computed(() => {
+    const result = /* @__PURE__ */ new Map();
+    if (blankPaths.size === 0) return result;
+    for (const pathKey of blankPaths) {
+      const segments = segmentsForPathKey(pathKey);
+      if (segments === null) continue;
+      if (!schema.isRequiredAtPath(segments)) continue;
+      result.set(pathKey, [
+        {
+          message: "No value supplied",
+          path: [...segments],
+          formKey,
+          code: AttaformErrorCode.NoValueSupplied
+        }
+      ]);
+    }
+    return result;
+  });
+  const isSubmitting = ref(false);
+  const activeSubmissions = ref(0);
+  const submitCount = ref(0);
+  const submitError = ref(null);
+  const submissionGeneration = ref(0);
+  const activeValidations = ref(0);
+  const initStamp = (/* @__PURE__ */ new Date()).toISOString();
+  diffAndApply({}, schemaInitialData, [], (patch) => {
+    if (patch.kind !== "added") return;
+    const { key } = canonicalizePath(patch.path);
+    originals.set(key, { segments: patch.path, value: patch.newValue });
+    ensurePathOrdinal(key);
+  });
+  if (hydration !== void 0) {
+    for (const [rawKey, record] of hydration.fields) {
+      if (typeof rawKey !== "string" || !isHydratedFieldRecord(record)) {
+        warnMalformedHydration(formKey, "FieldRecord", String(rawKey));
+        continue;
+      }
+      fields.set(rawKey, record);
+    }
+    for (const [rawKey, errs] of hydration.schemaErrors) {
+      if (typeof rawKey !== "string" || !isHydratedValidationErrorArray(errs)) {
+        warnMalformedHydration(formKey, "schemaErrors", String(rawKey));
+        continue;
+      }
+      schemaErrors.set(rawKey, errs);
+    }
+    for (const [rawKey, errs] of hydration.userErrors) {
+      if (typeof rawKey !== "string" || !isHydratedValidationErrorArray(errs)) {
+        warnMalformedHydration(formKey, "userErrors", String(rawKey));
+        continue;
+      }
+      userErrors.set(rawKey, errs);
+    }
+  } else {
+    diffAndApply({}, initialData, [], (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = canonicalizePath(patch.path);
+      fields.set(key, {
+        path: patch.path,
+        updatedAt: initStamp,
+        isConnected: false,
+        focused: null,
+        blurred: null,
+        touched: null
+      });
+    });
+    if (strict && !schemaResponse.success) {
+      setAllSchemaErrors(schemaResponse.errors);
+    }
+  }
+  if (!isSSR && strict && schema.needsAsyncValidation?.() === true) {
+    queueMicrotask(() => scheduleFieldValidation(
+      [],
+      true
+      /* immediate */
+    ));
+  }
+  function touchFieldRecord(pathKey, path, patch) {
+    const current = fields.get(pathKey);
+    fields.set(pathKey, {
+      path,
+      updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
+      isConnected: patch.isConnected ?? current?.isConnected ?? false,
+      focused: patch.focused ?? current?.focused ?? null,
+      blurred: patch.blurred ?? current?.blurred ?? null,
+      touched: patch.touched ?? current?.touched ?? null
+    });
+  }
+  function applyFormReplacement(next, meta) {
+    const prev = form.value;
+    if (Object.is(prev, next)) return;
+    form.value = next;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    diffAndApply(prev, next, [], (patch) => {
+      const { key } = canonicalizePath(patch.path);
+      if (patch.kind === "added" && !originals.has(key)) {
+        originals.set(key, { segments: patch.path, value: void 0 });
+      }
+      touchFieldRecord(key, patch.path, { updatedAt: now });
+    });
+    for (const listener of formChangeListeners) {
+      try {
+        listener(next, meta);
+      } catch (err) {
+        console.error("[attaform] onFormChange threw:", err);
+      }
+    }
+  }
+  function setValueAtPath(path, value, meta) {
+    if (!isSlimPrimitiveValid(schema, form, path, value)) {
+      return false;
+    }
+    if (meta?.skipDiscriminatorReshape !== true) {
+      if (path.length > 0) {
+        const last = path[path.length - 1];
+        if (typeof last === "string") {
+          const parentPath = path.slice(0, -1);
+          const parentDU = schema.getUnionDiscriminatorAtPath(parentPath);
+          if (parentDU?.discriminatorKey === last) {
+            const oldValue = getAtPath(form.value, path);
+            if (!Object.is(oldValue, value)) {
+              const variantDefault = parentDU.getVariantDefault(value);
+              if (variantDefault !== void 0) {
+                return reshapeUnionVariant(
+                  parentPath,
+                  oldValue,
+                  value,
+                  variantDefault,
+                  void 0,
+                  meta
+                );
+              }
+            }
+          }
+        }
+      }
+      if (isPlainRecord(value)) {
+        const selfDU = schema.getUnionDiscriminatorAtPath(path);
+        if (selfDU !== void 0) {
+          const valueRecord = value;
+          const discValue = valueRecord[selfDU.discriminatorKey];
+          if (discValue !== void 0) {
+            const variantDefault = selfDU.getVariantDefault(discValue);
+            if (variantDefault !== void 0 && isPlainRecord(variantDefault)) {
+              const currentUnionValue = getAtPath(form.value, path);
+              const oldDiscValue = isPlainRecord(currentUnionValue) ? currentUnionValue[selfDU.discriminatorKey] : void 0;
+              return reshapeUnionVariant(
+                path,
+                oldDiscValue,
+                discValue,
+                variantDefault,
+                valueRecord,
+                meta
+              );
+            }
+          }
+        }
+      }
+    }
+    const pathKey = canonicalizePath(path).key;
+    if (meta?.blank === true) {
+      blankPaths.add(pathKey);
+    } else if (blankPaths.has(pathKey)) {
+      blankPaths.delete(pathKey);
+    }
+    const completedValue = mergeStructural(schema, path, value);
+    const currentValue = getAtPath(form.value, path);
+    if (Object.is(currentValue, completedValue)) {
+      return true;
+    }
+    const nextForm = setAtPathWithSchemaFill(form.value, schema, path, completedValue);
+    applyFormReplacement(nextForm, meta);
+    if (fieldValidationMode === "change") {
+      scheduleFieldValidation(
+        path,
+        false
+        /* debounced */
+      );
+    }
+    return true;
+  }
+  function reshapeUnionVariant(parentPath, oldDiscValue, newDiscValue, variantDefault, consumerOverrides, meta) {
+    const sameDisc = Object.is(oldDiscValue, newDiscValue);
+    const parentKey = canonicalizePath(parentPath).key;
+    let baseline = variantDefault;
+    let restoredBlanks;
+    if (rememberVariants && !sameDisc) {
+      if (oldDiscValue !== void 0) {
+        const currentValue2 = JSON.parse(JSON.stringify(getAtPath(form.value, parentPath)));
+        const outgoingBlanks = [];
+        for (const k of blankPaths) {
+          if (isPathKeyUnder(k, parentPath)) outgoingBlanks.push(k);
+        }
+        let memoryForUnion2 = variantMemory.get(parentKey);
+        if (memoryForUnion2 === void 0) {
+          memoryForUnion2 = /* @__PURE__ */ new Map();
+          variantMemory.set(parentKey, memoryForUnion2);
+        }
+        memoryForUnion2.set(oldDiscValue, {
+          value: currentValue2,
+          blankPaths: outgoingBlanks
+        });
+      }
+      const memoryForUnion = variantMemory.get(parentKey);
+      const restored = memoryForUnion?.get(newDiscValue);
+      if (restored !== void 0) {
+        baseline = restored.value;
+        restoredBlanks = [...restored.blankPaths];
+      }
+    }
+    const finalValue = consumerOverrides !== void 0 ? { ...baseline, ...consumerOverrides } : baseline;
+    let newBlankPaths;
+    if (restoredBlanks !== void 0) {
+      newBlankPaths = restoredBlanks;
+    } else {
+      newBlankPaths = [];
+      walkUnspecified(finalValue, [...parentPath], newBlankPaths);
+    }
+    const survivingBlankKeys = new Set(newBlankPaths);
+    for (const existingKey of [...blankPaths]) {
+      if (isPathKeyUnder(existingKey, parentPath) && !survivingBlankKeys.has(existingKey)) {
+        blankPaths.delete(existingKey);
+      }
+    }
+    const currentValue = getAtPath(form.value, parentPath);
+    if (Object.is(currentValue, finalValue)) {
+      for (const k of newBlankPaths) blankPaths.add(k);
+      return true;
+    }
+    const nextForm = parentPath.length === 0 ? finalValue : setAtPath(form.value, parentPath, finalValue);
+    let appliedSync = false;
+    if (fieldValidationMode === "change") {
+      const syncOrPromise = schema.validateAtPath(finalValue, parentPath, { sync: true });
+      if (!(syncOrPromise instanceof Promise)) {
+        const reStamped = syncOrPromise.success ? [] : syncOrPromise.errors.map((err) => ({
+          ...err,
+          path: [...parentPath, ...err.path]
+        }));
+        applySchemaErrorsForSubtree(parentPath, reStamped);
+        const { key: parentKey2 } = canonicalizePath(parentPath);
+        const prevValidation = fieldValidationState.get(parentKey2);
+        if (prevValidation !== void 0) {
+          if (prevValidation.timer !== null) clearTimeout(prevValidation.timer);
+          prevValidation.controller.abort();
+          fieldValidationState.delete(parentKey2);
+        }
+        appliedSync = true;
+      }
+    }
+    applyFormReplacement(nextForm, meta);
+    for (const k of newBlankPaths) blankPaths.add(k);
+    if (fieldValidationMode === "change" && !appliedSync) {
+      scheduleFieldValidation(
+        parentPath,
+        false
+        /* debounced */
+      );
+    }
+    return true;
+  }
+  function scheduleFieldValidation(path, immediate) {
+    if (fieldValidationMode === "submit") return;
+    const { key } = canonicalizePath(path);
+    const prev = fieldValidationState.get(key);
+    if (prev !== void 0) {
+      if (prev.timer !== null) clearTimeout(prev.timer);
+      prev.controller.abort();
+    }
+    const controller = new AbortController();
+    const fresh = { controller, timer: null };
+    fieldValidationState.set(key, fresh);
+    const run = () => {
+      fresh.timer = null;
+      if (controller.signal.aborted) return;
+      const data = getAtPath(form.value, path);
+      activeValidations.value += 1;
+      void Promise.resolve().then(() => schema.validateAtPath(data, path)).then((response) => {
+        if (controller.signal.aborted) return;
+        const reStamped = response.success ? [] : response.errors.map((err) => ({
+          ...err,
+          path: [...path, ...err.path]
+        }));
+        applySchemaErrorsForSubtree(path, reStamped);
+      }).catch(() => {
+      }).finally(() => {
+        activeValidations.value = Math.max(0, activeValidations.value - 1);
+      });
+    };
+    if (immediate || fieldValidationDebounceMs === 0) {
+      run();
+    } else {
+      fresh.timer = setTimeout(run, fieldValidationDebounceMs);
+    }
+  }
+  function cancelFieldValidation() {
+    for (const entry of fieldValidationState.values()) {
+      if (entry.timer !== null) clearTimeout(entry.timer);
+      entry.controller.abort();
+    }
+    fieldValidationState.clear();
+  }
+  function onFormChange(listener) {
+    formChangeListeners.add(listener);
+    return () => {
+      formChangeListeners.delete(listener);
+    };
+  }
+  function onSubmitSuccess(listener) {
+    submitSuccessListeners.add(listener);
+    return () => {
+      submitSuccessListeners.delete(listener);
+    };
+  }
+  function onReset(listener) {
+    resetListeners.add(listener);
+    return () => {
+      resetListeners.delete(listener);
+    };
+  }
+  function emitSubmitSuccess() {
+    for (const listener of submitSuccessListeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("[attaform] onSubmitSuccess threw:", err);
+      }
+    }
+  }
+  function registerCleanup(fn) {
+    cleanupHooks.push(fn);
+  }
+  const drainHooks = [];
+  function registerDrain(fn) {
+    drainHooks.push(fn);
+  }
+  async function awaitPendingWrites() {
+    if (drainHooks.length === 0) return;
+    await Promise.allSettled(drainHooks.map((fn) => fn()));
+  }
+  function dispose() {
+    for (const hook of cleanupHooks) {
+      try {
+        hook();
+      } catch (err) {
+        console.error("[attaform] cleanup threw:", err);
+      }
+    }
+    cleanupHooks.length = 0;
+    drainHooks.length = 0;
+    modules.clear();
+    cancelFieldValidation();
+    formChangeListeners.clear();
+    submitSuccessListeners.clear();
+    resetListeners.clear();
+    persistOptIns.clear();
+  }
+  function getValueAtPath(path) {
+    return getAtPath(form.value, path);
+  }
+  function appendErrorsTo(map, entries) {
+    for (const err of entries) {
+      const { key } = canonicalizePath(err.path);
+      const current = map.get(key);
+      if (current === void 0) {
+        map.set(key, [err]);
+      } else {
+        map.set(key, [...current, err]);
+      }
+    }
+  }
+  function replaceErrorsIn(map, entries) {
+    map.clear();
+    appendErrorsTo(map, entries);
+  }
+  function clearErrorsIn(map, path) {
+    if (path === void 0) {
+      map.clear();
+      return;
+    }
+    const { key } = canonicalizePath(path);
+    map.delete(key);
+  }
+  function setSchemaErrorsForPath(path, entries) {
+    const { key } = canonicalizePath(path);
+    if (entries.length === 0) {
+      schemaErrors.delete(key);
+      return;
+    }
+    schemaErrors.set(key, [...entries]);
+  }
+  function applySchemaErrorsForSubtree(path, entries) {
+    const { key: parentKey } = canonicalizePath(path);
+    const grouped = /* @__PURE__ */ new Map();
+    for (const err of entries) {
+      const { key } = canonicalizePath(err.path);
+      const list = grouped.get(key);
+      if (list === void 0) grouped.set(key, [err]);
+      else list.push(err);
+    }
+    if (!grouped.has(parentKey)) schemaErrors.delete(parentKey);
+    for (const existingKey of [...schemaErrors.keys()]) {
+      if (isPathKeyUnder(existingKey, path) && !grouped.has(existingKey)) {
+        schemaErrors.delete(existingKey);
+      }
+    }
+    for (const [leafKey, group] of grouped) {
+      schemaErrors.set(leafKey, group);
+    }
+  }
+  function setAllSchemaErrors(entries) {
+    replaceErrorsIn(schemaErrors, entries);
+  }
+  function clearSchemaErrors(path) {
+    clearErrorsIn(schemaErrors, path);
+  }
+  function setAllUserErrors(entries) {
+    replaceErrorsIn(userErrors, entries);
+  }
+  function addUserErrors(entries) {
+    appendErrorsTo(userErrors, entries);
+  }
+  function clearUserErrors(path) {
+    clearErrorsIn(userErrors, path);
+  }
+  function getErrorsForPath(path) {
+    const { key } = canonicalizePath(path);
+    const schemaForKey = schemaErrors.get(key);
+    const userForKey = userErrors.get(key);
+    const blankForKey = derivedBlankErrors.value.get(key);
+    if (schemaForKey === void 0 && userForKey === void 0 && blankForKey === void 0) {
+      return [];
+    }
+    const result = [];
+    if (schemaForKey !== void 0) result.push(...schemaForKey);
+    if (blankForKey !== void 0) result.push(...blankForKey);
+    if (userForKey !== void 0) result.push(...userForKey);
+    return result;
+  }
+  function registerElement(path, element, formInstanceId) {
+    const { key } = canonicalizePath(path);
+    const record = elements.get(key);
+    if (record === void 0) {
+      elements.set(key, { path, elements: /* @__PURE__ */ new Set([element]) });
+    } else {
+      if (record.elements.has(element)) return false;
+      record.elements.add(element);
+    }
+    elementToFormInstance.set(element, formInstanceId);
+    sortedRegistrationsCache = null;
+    touchFieldRecord(key, path, { isConnected: true });
+    return true;
+  }
+  function deregisterElement(path, element) {
+    const { key } = canonicalizePath(path);
+    const record = elements.get(key);
+    if (record === void 0) return 0;
+    const removed = record.elements.delete(element);
+    if (removed) {
+      elementToFormInstance.delete(element);
+      sortedRegistrationsCache = null;
+    }
+    const remaining = record.elements.size;
+    if (remaining === 0) {
+      elements.delete(key);
+      touchFieldRecord(key, path, { isConnected: false });
+    }
+    return remaining;
+  }
+  function markConnectedOptimistically(path) {
+    if (!isSSR) return;
+    const { key } = canonicalizePath(path);
+    const current = fields.get(key);
+    if (current?.isConnected === true) return;
+    touchFieldRecord(key, path, { isConnected: true });
+  }
+  function markFocused(path, focused) {
+    const { key } = canonicalizePath(path);
+    touchFieldRecord(key, path, {
+      focused,
+      blurred: !focused,
+      // `touched` flips to true on blur and stays true thereafter; while
+      // a field is currently focused we keep whatever value it held.
+      touched: focused ? fields.get(key)?.touched ?? null : true
+    });
+    if (!focused && fieldValidationMode === "blur") {
+      scheduleFieldValidation(
+        path,
+        true
+        /* immediate */
+      );
+    }
+  }
+  function markTouched(path) {
+    const { key } = canonicalizePath(path);
+    touchFieldRecord(key, path, { touched: true });
+  }
+  function reset(nextDefaultValues) {
+    const next = schema.getDefaultValues({
+      useDefaultSchemaValues: true,
+      constraints: nextDefaultValues ?? defaultValues,
+      strict
+    }).data;
+    applyFormReplacement(next);
+    originals.clear();
+    diffAndApply({}, next, [], (patch) => {
+      if (patch.kind !== "added") return;
+      const { key } = canonicalizePath(patch.path);
+      originals.set(key, { segments: patch.path, value: patch.newValue });
+    });
+    if (nextDefaultValues !== void 0) {
+      blankPaths.clear();
+      originalBlankPaths.clear();
+    } else {
+      blankPaths.clear();
+      for (const key of originalBlankPaths) {
+        blankPaths.add(key);
+      }
+    }
+    schemaErrors.clear();
+    userErrors.clear();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const [pathKey, record] of fields) {
+      fields.set(pathKey, {
+        path: record.path,
+        updatedAt: now,
+        isConnected: record.isConnected,
+        focused: null,
+        blurred: null,
+        touched: null
+      });
+    }
+    submissionGeneration.value += 1;
+    isSubmitting.value = false;
+    activeSubmissions.value = 0;
+    submitCount.value = 0;
+    submitError.value = null;
+    cancelFieldValidation();
+    variantMemory.clear();
+    for (const listener of resetListeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("[attaform] onReset threw:", err);
+      }
+    }
+  }
+  function resetField(path) {
+    const { key: targetKey, segments: targetSegments } = canonicalizePath(path);
+    for (const memKey of [...variantMemory.keys()]) {
+      const memSegments = segmentsForPathKey(memKey);
+      if (memSegments === null) continue;
+      if (isPathPrefix(targetSegments, memSegments)) {
+        variantMemory.delete(memKey);
+      }
+    }
+    const leafEntry = originals.get(targetKey);
+    if (leafEntry !== void 0) {
+      const wrote = setValueAtPath(targetSegments, leafEntry.value);
+      if (!wrote) {
+        console.error(
+          `[attaform] resetField: leaf write rejected for path '${targetKey}' \u2014 originals contain a value that doesn't satisfy the slim primitive shape. This is a bug in the construction pipeline.`
+        );
+      }
+      schemaErrors.delete(targetKey);
+      userErrors.delete(targetKey);
+      clearFieldRecordFlags(targetKey);
+      return;
+    }
+    let subtree = void 0;
+    let anyMatch = false;
+    for (const [, entry] of originals) {
+      const leafSegments = entry.segments;
+      if (!isPathPrefix(targetSegments, leafSegments)) continue;
+      if (leafSegments.length === targetSegments.length) continue;
+      anyMatch = true;
+      const relative = leafSegments.slice(targetSegments.length);
+      if (subtree === void 0) {
+        subtree = typeof relative[0] === "number" ? [] : {};
+      }
+      subtree = setAtPath(subtree, relative, entry.value);
+    }
+    if (!anyMatch) return;
+    const wroteSubtree = setValueAtPath(targetSegments, subtree);
+    if (!wroteSubtree) {
+      console.error(
+        `[attaform] resetField: subtree write rejected at path '${targetKey}' \u2014 originals contain values that don't satisfy the slim primitive shape. This is a bug in the construction pipeline.`
+      );
+    }
+    deleteErrorsUnderPrefix(schemaErrors, targetSegments);
+    deleteErrorsUnderPrefix(userErrors, targetSegments);
+    for (const [fieldKey, record] of Array.from(fields.entries())) {
+      if (isPathPrefix(targetSegments, record.path)) clearFieldRecordFlags(fieldKey);
+    }
+  }
+  function deleteErrorsUnderPrefix(map, prefix) {
+    for (const [errorKey, errs] of Array.from(map.entries())) {
+      const first = errs[0];
+      if (first === void 0) continue;
+      if (isPathPrefix(prefix, first.path)) {
+        map.delete(errorKey);
+      }
+    }
+  }
+  function clearFieldRecordFlags(pathKey) {
+    const record = fields.get(pathKey);
+    if (record === void 0) return;
+    fields.set(pathKey, {
+      path: record.path,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isConnected: record.isConnected,
+      focused: null,
+      blurred: null,
+      touched: null
+    });
+  }
+  function isPathPrefix(prefix, candidate) {
+    if (prefix.length > candidate.length) return false;
+    for (let i = 0; i < prefix.length; i++) {
+      if (prefix[i] !== candidate[i]) return false;
+    }
+    return true;
+  }
+  function isPristineAtPath(path) {
+    const { key, segments } = canonicalizePath(path);
+    if (blankPaths.has(key) !== originalBlankPaths.has(key)) return false;
+    const entry = originals.get(key);
+    if (entry === void 0) return true;
+    return Object.is(getAtPath(form.value, segments), entry.value);
+  }
+  function getFieldRecord(path) {
+    const { key } = canonicalizePath(path);
+    return fields.get(key);
+  }
+  function getOriginalAtPath(path) {
+    const { key } = canonicalizePath(path);
+    return originals.get(key)?.value;
+  }
+  function getFirstErrorElement(formInstanceId) {
+    sortedRegistrationsCache ?? (sortedRegistrationsCache = rebuildSortedRegistrations());
+    for (const entry of sortedRegistrationsCache) {
+      if (elementToFormInstance.get(entry.element) !== formInstanceId) continue;
+      if (!entry.element.isConnected) continue;
+      if (entry.element.offsetParent === null) continue;
+      const { key } = canonicalizePath(entry.path);
+      const hasSchemaErr = (schemaErrors.get(key)?.length ?? 0) > 0;
+      const hasUserErr = (userErrors.get(key)?.length ?? 0) > 0;
+      if (!hasSchemaErr && !hasUserErr) continue;
+      return { path: entry.path, element: entry.element };
+    }
+    return null;
+  }
+  function rebuildSortedRegistrations() {
+    const flat = [];
+    for (const [, record] of elements) {
+      for (const el of record.elements) flat.push({ path: record.path, element: el });
+    }
+    flat.sort(
+      (a, b) => a.element.compareDocumentPosition(b.element) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1
+    );
+    return flat;
+  }
+  return {
+    formKey,
+    form,
+    fields,
+    elements,
+    schemaErrors,
+    userErrors,
+    derivedBlankErrors,
+    originals,
+    schema,
+    isSSR,
+    isSubmitting,
+    activeSubmissions,
+    submitCount,
+    submitError,
+    submissionGeneration,
+    activeValidations,
+    applyFormReplacement,
+    setValueAtPath,
+    getValueAtPath,
+    reset,
+    resetField,
+    setSchemaErrorsForPath,
+    setAllSchemaErrors,
+    clearSchemaErrors,
+    setAllUserErrors,
+    addUserErrors,
+    clearUserErrors,
+    getErrorsForPath,
+    ensurePathOrdinal,
+    registerElement,
+    deregisterElement,
+    markFocused,
+    markTouched,
+    markConnectedOptimistically,
+    isPristineAtPath,
+    getFieldRecord,
+    getOriginalAtPath,
+    getFirstErrorElement,
+    cancelFieldValidation,
+    scheduleFieldValidation,
+    onFormChange,
+    onSubmitSuccess,
+    onReset,
+    emitSubmitSuccess,
+    registerCleanup,
+    registerDrain,
+    awaitPendingWrites,
+    modules,
+    persistOptIns,
+    coerceIndex,
+    blankPaths,
+    originalBlankPaths,
+    dispose
+  };
+}
+
+function getComputedSchema(formKey, schemaOrCallback) {
+  if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey);
+  return schemaOrCallback;
+}
+
+function createHistoryModule(state, config) {
+  const max = typeof config === "object" ? config.max ?? DEFAULT_HISTORY_MAX_SNAPSHOTS : DEFAULT_HISTORY_MAX_SNAPSHOTS;
+  const undoStack = shallowRef([]);
+  const redoStack = shallowRef([]);
+  let suppressNext = false;
+  function captureSnapshot() {
+    return {
+      form: state.form.value,
+      blankPaths: [...state.blankPaths],
+      schemaErrors: [...state.schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
+      userErrors: [...state.userErrors.entries()].map(([k, v]) => [k, [...v]])
+    };
+  }
+  function pushSnapshot(snap) {
+    const next = [...undoStack.value, snap];
+    undoStack.value = next.length > max ? next.slice(-max) : next;
+    redoStack.value = [];
+  }
+  pushSnapshot(captureSnapshot());
+  const unsubscribeChange = state.onFormChange(() => {
+    if (suppressNext) {
+      suppressNext = false;
+      return;
+    }
+    pushSnapshot(captureSnapshot());
+  });
+  const unsubscribeReset = state.onReset(() => {
+    undoStack.value = [];
+    redoStack.value = [];
+    pushSnapshot(captureSnapshot());
+  });
+  function restore(snap) {
+    suppressNext = true;
+    state.blankPaths.clear();
+    for (const key of snap.blankPaths) state.blankPaths.add(key);
+    state.applyFormReplacement(snap.form, {
+      persist: !state.persistOptIns.isEmpty()
+    });
+    const schemaFlat = snap.schemaErrors.flatMap(([, errs]) => errs);
+    const userFlat = snap.userErrors.flatMap(([, errs]) => errs);
+    state.setAllSchemaErrors(schemaFlat);
+    state.setAllUserErrors(userFlat);
+  }
+  function undo() {
+    if (undoStack.value.length <= 1) return false;
+    const current = undoStack.value[undoStack.value.length - 1];
+    const prev = undoStack.value[undoStack.value.length - 2];
+    if (current === void 0 || prev === void 0) return false;
+    redoStack.value = [...redoStack.value, current];
+    undoStack.value = undoStack.value.slice(0, -1);
+    restore(prev);
+    return true;
+  }
+  function redo() {
+    if (redoStack.value.length === 0) return false;
+    const next = redoStack.value[redoStack.value.length - 1];
+    if (next === void 0) return false;
+    redoStack.value = redoStack.value.slice(0, -1);
+    undoStack.value = [...undoStack.value, next];
+    restore(next);
+    return true;
+  }
+  const canUndo = computed(() => undoStack.value.length > 1);
+  const canRedo = computed(() => redoStack.value.length > 0);
+  const historySize = computed(() => undoStack.value.length + redoStack.value.length);
+  return {
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    historySize,
+    dispose() {
+      unsubscribeChange();
+      unsubscribeReset();
+      undoStack.value = [];
+      redoStack.value = [];
+    }
+  };
+}
+
+function hashStableString(input, seed = 0) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, "0");
+}
+
+function useAbstractForm(configuration) {
+  const key = resolveFormKey(configuration.key);
+  const resolvedSchema = getComputedSchema(key, configuration.schema);
+  if (configuration.persist !== void 0 && configuration.key === void 0) {
+    throw new AnonPersistError({
+      cause: "no-key",
+      schemaFields: extractSchemaFields(resolvedSchema),
+      callSite: captureUserCallSite()
+    });
+  }
+  const registry = useRegistry();
+  const merged = mergeWithDefaults(registry.defaults, configuration);
+  const existing = registry.forms.get(key);
+  if (__DEV__ && existing !== void 0) {
+    warnOnSchemaFingerprintMismatch(key, existing.schema, resolvedSchema);
+  }
+  const state = existing ?? buildFreshState(key, resolvedSchema, merged, registry);
+  if (getCurrentScope() !== void 0) {
+    const releaseConsumer = registry.trackConsumer(key);
+    onScopeDispose(releaseConsumer);
+  }
+  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.isSSR);
+  if (existing === void 0 && !registry.isSSR) {
+    if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
+      const resolvedPersist = normalizePersistConfig(merged.persist);
+      const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
+      void sweepNonConfiguredStandardStoresForOrphans(resolvedPersist.storage, persistenceBase);
+      const persistenceModule = wirePersistence(state, resolvedPersist);
+      state.modules.set(PERSISTENCE_MODULE_KEY, persistenceModule);
+      state.registerDrain(() => persistenceModule.awaitPendingWrites());
+      state.registerCleanup(() => persistenceModule.dispose());
+    } else {
+      void sweepAllOrphansAcrossStandardStores(`${PERSISTENCE_KEY_PREFIX}${state.formKey}`);
+    }
+  }
+  if (existing === void 0 && merged.history !== void 0) {
+    const historyModule = createHistoryModule(state, merged.history);
+    state.modules.set(HISTORY_MODULE_KEY, historyModule);
+    state.registerCleanup(() => historyModule.dispose());
+  }
+  if (configuration.key === void 0) {
+    recordAmbientProvide(registry.isSSR);
+    provide(kFormContext, state);
+  }
+  const formInstanceId = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
+  if (getCurrentInstance() !== null) {
+    provide(kFormInstanceId, formInstanceId);
+  }
+  const apiOptions = {};
+  if (merged.onInvalidSubmit !== void 0) {
+    apiOptions.onInvalidSubmit = merged.onInvalidSubmit;
+  }
+  const history = state.modules.get(HISTORY_MODULE_KEY);
+  if (history !== void 0) {
+    apiOptions.history = history;
+  }
+  return buildFormApi(state, formInstanceId, apiOptions);
+}
+function mergeWithDefaults(defaults, configuration) {
+  const strict = configuration.strict ?? defaults.strict;
+  const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
+  const history = configuration.history ?? defaults.history;
+  const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
+  const coerce = configuration.coerce ?? defaults.coerce;
+  const validateOn = configuration.validateOn ?? defaults.validateOn;
+  const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
+  return {
+    ...configuration,
+    ...strict === void 0 ? {} : { strict },
+    ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
+    ...history === void 0 ? {} : { history },
+    ...rememberVariants === void 0 ? {} : { rememberVariants },
+    ...coerce === void 0 ? {} : { coerce },
+    ...validateOn === void 0 ? {} : { validateOn },
+    ...debounceMs === void 0 ? {} : { debounceMs }
+  };
+}
+const HISTORY_MODULE_KEY = "history";
+function buildFreshState(key, schema, configuration, registry) {
+  const pending = registry.pendingHydration.get(key);
+  if (pending !== void 0) registry.pendingHydration.delete(key);
+  const walked = walkUnsetSentinels(
+    configuration.defaultValues,
+    schema
+  );
+  const initialBlankPaths = pending === void 0 ? walked.paths : void 0;
+  const createOptions = {
+    formKey: key,
+    schema,
+    defaultValues: walked.cleanedValues,
+    ...configuration.strict !== void 0 ? { strict: configuration.strict } : {},
+    hydration: pending,
+    ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
+    ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
+    isSSR: registry.isSSR,
+    ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
+    ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
+    ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {}
+  };
+  const state = createFormStore(createOptions);
+  registry.forms.set(
+    key,
+    state
+  );
+  return state;
+}
+let anonCounter = 0;
+let formInstanceCounter = 0;
+const ambientProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function recordAmbientProvide(isSSR) {
+  if (!__DEV__ || isSSR || ambientProvideHistory === null) return;
+  const instance = getCurrentInstance();
+  if (instance === null) return;
+  const instanceKey = instance;
+  const entry = {
+    source: captureUserCallSite()
+  };
+  const existing = ambientProvideHistory.get(instanceKey);
+  if (existing === void 0) {
+    ambientProvideHistory.set(instanceKey, [entry]);
+    return;
+  }
+  existing.push(entry);
+}
+function resolveFormKey(key) {
+  if (key !== void 0 && key !== null && key !== "") {
+    if (key.startsWith(RESERVED_KEY_PREFIX)) {
+      throw new ReservedFormKeyError(key);
+    }
+    return key;
+  }
+  if (getCurrentInstance() !== null) {
+    return `${ANONYMOUS_FORM_KEY_PREFIX}${useId()}`;
+  }
+  return `${ANONYMOUS_FORM_KEY_PREFIX}${anonCounter++}`;
+}
+function warnOnSchemaFingerprintMismatch(key, existing, incoming) {
+  let existingFp;
+  let incomingFp;
+  try {
+    existingFp = existing.fingerprint();
+    incomingFp = incoming.fingerprint();
+  } catch (error) {
+    console.error(
+      `[attaform] fingerprint() threw for key "${key}"; skipping mismatch check.`,
+      error
+    );
+    return;
+  }
+  if (existingFp === incomingFp) return;
+  console.warn(
+    `[attaform] useForm() calls with key "${key}" use different schemas; first wins, second is ignored. Use identical schemas or unique keys.
+  existing: ${existingFp}
+  incoming: ${incomingFp}`
+  );
+}
+function wirePersistence(state, config) {
+  const fingerprint = hashStableString(state.schema.fingerprint());
+  const base = resolveStorageKeyBase(config, state.formKey);
+  const key = `${base}:${fingerprint}`;
+  const debounceMs = config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS;
+  const include = config.include ?? "form";
+  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
+  const adapterPromise = getStorageAdapter(config.storage);
+  let disposed = false;
+  let inFlightFinalFlush = null;
+  let pendingOptedInPaths = null;
+  const writer = createDebouncedWriter(async () => {
+    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
+    pendingOptedInPaths = null;
+    const adapter = await adapterPromise;
+    if (disposed) return;
+    if (optedInPaths.size === 0) {
+      await adapter.removeItem(key);
+      return;
+    }
+    const rawForm = toRaw(state.form.value);
+    const filteredForm = pluckPaths(rawForm, optedInPaths);
+    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
+    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
+    const filteredTransientEmpty = /* @__PURE__ */ new Set();
+    for (const tk of state.blankPaths) {
+      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
+    }
+    const payload = buildPersistedPayload(
+      filteredForm,
+      include,
+      filteredSchemaErrors,
+      filteredUserErrors,
+      filteredTransientEmpty
+    );
+    await adapter.setItem(key, payload);
+  }, debounceMs);
+  const unsubscribeChange = state.onFormChange((_next, meta) => {
+    if (disposed || inFlightFinalFlush !== null) return;
+    if (meta?.persist !== true) return;
+    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
+    writer.schedule();
+  });
+  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
+    if (disposed) return;
+    void (async () => {
+      await writer.flush();
+      if (disposed) return;
+      const adapter = await adapterPromise;
+      if (disposed) return;
+      await adapter.removeItem(key);
+    })();
+  }) : () => void 0;
+  void (async () => {
+    const adapter = await adapterPromise;
+    if (disposed) return;
+    void cleanupOrphanKeys(adapter, base, key);
+    try {
+      const raw = await adapter.getItem(key);
+      const payload = readPersistedPayload(raw);
+      if (payload === null) {
+        if (raw !== null && raw !== void 0) {
+          await adapter.removeItem(key);
+        }
+        return;
+      }
+      if (disposed) return;
+      const merged = mergeSparseHydration(
+        toRaw(state.form.value),
+        payload.data.form,
+        state.schema
+      );
+      state.applyFormReplacement(merged);
+      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
+      for (const k of persistedLeafPaths) {
+        state.blankPaths.delete(k);
+        state.originalBlankPaths.delete(k);
+      }
+      for (const k of payload.data.blankPaths ?? []) {
+        state.blankPaths.add(k);
+        state.originalBlankPaths.add(k);
+      }
+      if (include === "form+errors") {
+        if (payload.data.schemaErrors !== void 0) {
+          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
+          state.setAllSchemaErrors(flat);
+        }
+        if (payload.data.userErrors !== void 0) {
+          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
+          state.setAllUserErrors(flat);
+        }
+      }
+      state.scheduleFieldValidation(
+        [],
+        true
+        /* immediate */
+      );
+    } catch {
+    }
+  })();
+  async function writePathImmediately(path) {
+    if (disposed) return;
+    await writer.flush();
+    if (disposed) return;
+    const adapter = await adapterPromise;
+    if (disposed) return;
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    const baseForm = existing?.data.form ?? {};
+    const value = getAtPath(toRaw(state.form.value), path);
+    const nextForm = setAtPath(baseForm, path, value);
+    const { key: pathKey } = canonicalizePath(path);
+    const transientSet = new Set(
+      (existing?.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    for (const liveKey of state.blankPaths) {
+      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
+        transientSet.add(liveKey);
+      }
+    }
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
+      return;
+    }
+    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
+    const userMap = new Map(existing?.data.userErrors ?? []);
+    const currentSchema = state.schemaErrors.get(pathKey);
+    const currentUser = state.userErrors.get(pathKey);
+    if (currentSchema !== void 0 && currentSchema.length > 0) {
+      schemaMap.set(pathKey, [...currentSchema]);
+    } else {
+      schemaMap.delete(pathKey);
+    }
+    if (currentUser !== void 0 && currentUser.length > 0) {
+      userMap.set(pathKey, [...currentUser]);
+    } else {
+      userMap.delete(pathKey);
+    }
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
+  }
+  async function clearPersistedDraft(path) {
+    if (disposed) return;
+    await writer.flush();
+    if (disposed) return;
+    const adapter = await adapterPromise;
+    if (disposed) return;
+    if (path === void 0) {
+      await adapter.removeItem(key);
+      return;
+    }
+    const raw = await adapter.getItem(key);
+    const existing = readPersistedPayload(raw);
+    if (existing === null) return;
+    const nextForm = deleteAtPath(existing.data.form, path);
+    if (isEmptyContainer(nextForm)) {
+      await adapter.removeItem(key);
+      return;
+    }
+    const { key: pathKey } = canonicalizePath(path);
+    const transientSet = new Set(
+      (existing.data.blankPaths ?? []).filter(
+        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
+      )
+    );
+    if (include === "form") {
+      await adapter.setItem(
+        key,
+        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
+      );
+      return;
+    }
+    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
+    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
+    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
+    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
+    await adapter.setItem(
+      key,
+      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
+    );
+  }
+  function awaitPendingWrites() {
+    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
+    if (disposed) return Promise.resolve();
+    return writer.flush().catch(() => void 0);
+  }
+  function dispose() {
+    if (disposed || inFlightFinalFlush !== null) return;
+    unsubscribeChange();
+    unsubscribeSuccess();
+    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
+      disposed = true;
+      inFlightFinalFlush = null;
+    });
+  }
+  return {
+    writePathImmediately,
+    clearPersistedDraft,
+    awaitPendingWrites,
+    dispose
+  };
+}
+function isEmptyContainer(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainRecord(value)) return Object.keys(value).length === 0;
+  return false;
+}
+const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
+function enforceAnonPersistRule(formKey, isSSR) {
+  if (!formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return false;
+  if (__DEV__)
+    throw new AnonPersistError({
+      cause: "no-key",
+      callSite: captureUserCallSite()
+    });
+  if (!isSSR && !warnedAnonPersistKeys.has(formKey)) {
+    warnedAnonPersistKeys.add(formKey);
+    console.warn(
+      "[attaform] persist: ignored \u2014 anonymous useForm() can't safely persist (key drift + cross-form collision risk).\n  Persistence is disabled for this form; the app keeps working.\n  Fix: useForm({ schema, key: 'login', persist: '...' })"
+    );
+  }
+  return true;
+}
+function collectPersistedLeafPaths(form) {
+  const out = [];
+  walk(form, []);
+  return out;
+  function walk(node, prefix) {
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        walk(node[i], [...prefix, i]);
+      }
+      return;
+    }
+    if (isPlainRecord(node)) {
+      for (const key of Object.keys(node)) {
+        walk(node[key], [...prefix, key]);
+      }
+      return;
+    }
+    if (prefix.length === 0) return;
+    out.push(canonicalizePath(prefix).key);
+  }
+}
+function isDescendantPathKey(candidate, ancestor) {
+  if (candidate.length <= ancestor.length) return false;
+  if (!ancestor.endsWith("]")) return false;
+  const childPrefix = `${ancestor.slice(0, -1)},`;
+  return candidate.startsWith(childPrefix);
+}
+
+let injectedInstanceCounter = 0;
+function injectForm(key) {
+  const registry = useRegistry();
+  const state = resolveState(key, registry);
+  if (state === null) return null;
+  if (getCurrentScope() !== void 0) {
+    const releaseConsumer = registry.trackConsumer(state.formKey);
+    onScopeDispose(releaseConsumer);
+  }
+  const apiOptions = {};
+  const history = state.modules.get("history");
+  if (history !== void 0) {
+    apiOptions.history = history;
+  }
+  const ambientInstanceId = getCurrentInstance() !== null ? inject(kFormInstanceId, null) : null;
+  const formInstanceId = ambientInstanceId ?? (getCurrentInstance() !== null ? useId() : `atta:form-instance-injected:${injectedInstanceCounter++}`);
+  return buildFormApi(state, formInstanceId, apiOptions);
+}
+function resolveState(key, registry) {
+  if (key !== void 0) {
+    const stored = registry.forms.get(key);
+    if (stored === void 0) {
+      warnMiss(`no form registered for key '${key}'`, registry.isSSR);
+      return null;
+    }
+    return stored;
+  }
+  const ambient = inject(kFormContext, null);
+  if (ambient === null) {
+    warnMiss("no ambient form context", registry.isSSR);
+    return null;
+  }
+  warnIfAmbientProviderHadDuplicates();
+  return ambient;
+}
+function warnMiss(detail, isSSR) {
+  if (!__DEV__ || isSSR) return;
+  const frame = captureUserCallSite();
+  console.warn(
+    `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
+  );
+}
+function warnIfAmbientProviderHadDuplicates() {
+  if (!__DEV__ || ambientProvideHistory === null) return;
+  let ancestor = getCurrentInstance()?.parent ?? null;
+  while (ancestor !== null) {
+    const history = ambientProvideHistory.get(ancestor);
+    if (history !== void 0) {
+      if (history.length > 1) {
+        const lines = history.map((entry) => `  - ${entry.source ?? "<unknown location>"}`);
+        console.warn(
+          "[attaform] injectForm<F>() (no key) resolved against an ancestor with multiple anonymous useForm() calls; descendants only see the last-provided form. Anonymous useForm() calls were:\n" + lines.join("\n") + '\nFix: pass a key to each call (e.g. useForm({ schema, key: "x" })) and reach them via injectForm<F>("x"), or split the forms across separate components.'
+        );
+      }
+      return;
+    }
+    ancestor = ancestor.parent;
+  }
+}
+
+export { AttaformErrorCode as A, defineCoercion as a, isUnset as b, useAbstractForm as c, defaultCoercionRules as d, setAtPath as e, isPlainRecord as f, getAtPath as g, injectForm as i, slimKindOf as s, unset as u };
+//# sourceMappingURL=attaform.BRTxpA3q.mjs.map