attaform 0.14.0 → 0.15.1

package/dist/shared/{attaform.CNJO3mME.cjs → attaform.CDJVeoJU.cjs}

@@ -1,8 +1,175 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.xKWYHMdq.cjs');
-const sensitiveNames = require('./attaform.B5GWYl76.cjs');
+const paths = require('./attaform.BOi138GE.cjs');
+const sensitiveNames = require('./attaform.RypIkgVy.cjs');
+
+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 applyChangedKeys(target, source) {
+  if (!isDescendable(target) || !isDescendable(source)) return false;
+  const targetIsArray = Array.isArray(target);
+  const sourceIsArray = Array.isArray(source);
+  if (targetIsArray !== sourceIsArray) return false;
+  const ROOT_SENTINEL = Symbol.for("attaform.applyChangedKeys.rootMismatch");
+  const changedFirstSegments = /* @__PURE__ */ new Set();
+  diffAndApply(target, source, [], (patch) => {
+    if (patch.path.length === 0) {
+      changedFirstSegments.add(ROOT_SENTINEL);
+      return;
+    }
+    changedFirstSegments.add(patch.path[0]);
+  });
+  if (changedFirstSegments.has(ROOT_SENTINEL)) return false;
+  if (targetIsArray) {
+    const t = target;
+    const s = source;
+    if (t.length > s.length) t.length = s.length;
+    for (const idx of changedFirstSegments) {
+      if (typeof idx === "symbol") continue;
+      const i = typeof idx === "number" ? idx : Number(idx);
+      t[i] = s[i];
+    }
+  } else {
+    const t = target;
+    const s = source;
+    const sourceKeys = new Set(Object.keys(s));
+    for (const k of Object.keys(t)) {
+      if (!sourceKeys.has(k)) delete t[k];
+    }
+    for (const k of changedFirstSegments) {
+      if (typeof k === "symbol") continue;
+      t[String(k)] = s[String(k)];
+    }
+  }
+  return true;
+}
+function structuralSnapshot(value) {
+  if (!isDescendable(value)) return value;
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      out2[i] = structuralSnapshot(value[i]);
+    }
+    return out2;
+  }
+  const src = value;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    out[k] = structuralSnapshot(src[k]);
+  }
+  return out;
+}
+
+const EMPTY_RESOLVED_FIELD_META = Object.freeze({
+  label: "",
+  description: void 0,
+  placeholder: void 0,
+  meta: Object.freeze({})
+});
+
+function humanize(segment) {
+  if (typeof segment === "number") return "";
+  const str = String(segment);
+  if (str.length === 0) return "";
+  if (/^\d+$/.test(str)) return "";
+  const tokens = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((part) => part.length > 0);
+  if (tokens.length === 0) return "";
+  return tokens.map((part) => {
+    const head = part[0];
+    return head === void 0 ? part : head.toUpperCase() + part.slice(1).toLowerCase();
+  }).join(" ");
+}
 
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
@@ -248,6 +415,153 @@ function setAtPathWithSchemaFillImpl(root, schema, fullPath, value, startIdx) {
   return rec;
 }
 
+function buildFieldStateAccessor(state) {
+  const cache = /* @__PURE__ */ new Map();
+  return function getFieldState(pathInput) {
+    const { segments, key } = paths.canonicalizePath(pathInput);
+    const cached = cache.get(key);
+    if (cached !== void 0) return cached;
+    const c = vue.computed(
+      () => state.schema.isLeafAtPath(segments) ? buildLeafFieldState(state, segments, key) : buildContainerFieldState(state, segments)
+    );
+    cache.set(key, c);
+    return c;
+  };
+}
+function buildLeafFieldState(state, segments, key) {
+  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);
+  const validating = (state.fieldValidationCounts.get(key) ?? 0) > 0;
+  const gated = state.pathHasAsyncValidation(segments) && !state.firstValidationDone.value;
+  const valid = !gated && errors.length === 0 && !validating;
+  const elementRecord = state.elements.get(key);
+  const elementsArr = elementRecord ? Object.freeze([...elementRecord.elements]) : EMPTY_ELEMENTS;
+  const firstElement = elementsArr[0] ?? null;
+  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
+  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
+  const label = resolved.label || humanize(lastSegment);
+  return {
+    value,
+    original,
+    pristine,
+    dirty: !pristine,
+    focused: record?.focused ?? null,
+    blurred: record?.blurred ?? null,
+    touched: record?.touched ?? null,
+    connected: record?.connected ?? false,
+    element: firstElement,
+    elements: elementsArr,
+    updatedAt: record?.updatedAt ?? null,
+    errors,
+    validating,
+    valid,
+    path: segments,
+    blank: state.blankPaths.has(key),
+    label,
+    description: resolved.description,
+    placeholder: resolved.placeholder,
+    meta: resolved.meta
+  };
+}
+function buildContainerFieldState(state, segments, _key) {
+  const formValue = state.form.value;
+  const value = state.getValueAtPath(segments);
+  const original = state.originals.get(paths.canonicalizePath(segments).key)?.value;
+  let pristine = true;
+  let blank = true;
+  let dirty = false;
+  let focused = false;
+  let blurred = false;
+  let touched = false;
+  let connected = false;
+  let validating = false;
+  let updatedAt = null;
+  let asyncPending = false;
+  for (const [, entry] of state.originals) {
+    if (!paths.isPathPrefix(segments, entry.segments)) continue;
+    if (segments.length === entry.segments.length) continue;
+    if (!hasAtPath(formValue, entry.segments)) continue;
+    const leafKey = paths.canonicalizePath(entry.segments).key;
+    const leafRecord = state.fields.get(leafKey);
+    if (!state.isPristineAtPath(entry.segments)) {
+      pristine = false;
+      dirty = true;
+    }
+    if (!state.blankPaths.has(leafKey)) blank = false;
+    if (leafRecord?.focused === true) focused = true;
+    if (leafRecord?.blurred === true) blurred = true;
+    if (leafRecord?.touched === true) touched = true;
+    if (leafRecord?.connected === true) connected = true;
+    if ((state.fieldValidationCounts.get(leafKey) ?? 0) > 0) validating = true;
+    if (state.pathHasAsyncValidation(entry.segments)) asyncPending = true;
+    const ts = leafRecord?.updatedAt;
+    if (ts !== void 0 && ts !== null) {
+      if (updatedAt === null || ts > updatedAt) updatedAt = ts;
+    }
+  }
+  const errors = aggregateErrorsAt(state, segments);
+  if (!asyncPending && state.pathHasAsyncValidation(segments)) asyncPending = true;
+  const gated = asyncPending && !state.firstValidationDone.value;
+  const valid = !gated && errors.length === 0 && !validating;
+  const resolved = state.schema.getFieldMetaAtPath ? state.schema.getFieldMetaAtPath(segments) : EMPTY_RESOLVED_FIELD_META;
+  const lastSegment = segments.length === 0 ? "" : segments[segments.length - 1] ?? "";
+  const label = resolved.label || humanize(lastSegment);
+  return {
+    value,
+    original,
+    pristine,
+    dirty,
+    focused,
+    blurred,
+    touched,
+    connected,
+    element: null,
+    elements: EMPTY_ELEMENTS,
+    updatedAt,
+    errors,
+    validating,
+    valid,
+    path: segments,
+    blank,
+    label,
+    description: resolved.description,
+    placeholder: resolved.placeholder,
+    meta: resolved.meta
+  };
+}
+function aggregateErrorsAt(state, prefix) {
+  const formValue = state.form.value;
+  const buckets = /* @__PURE__ */ new Map();
+  const collect = (errs) => {
+    for (const [pathKey, list] of errs) {
+      if (list.length === 0) continue;
+      const segs = paths.segmentsForPathKey(pathKey);
+      if (segs === null) continue;
+      if (!paths.isPathPrefix(prefix, segs)) continue;
+      if (segs.length > 0 && !hasAtPath(formValue, segs)) 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 EMPTY_ELEMENTS = Object.freeze([]);
+
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
 function keyToSegment(key) {
   return INTEGER_SEGMENT.test(key) ? Number(key) : key;
@@ -272,11 +586,6 @@ function buildSurfaceProxy(opts) {
     }
     return containerProxyAt(segs);
   }
-  function navigateTo(input) {
-    if (input === void 0) return rootProxy;
-    const { segments } = paths.canonicalizePath(input);
-    return descendOrTerminate(segments);
-  }
   function containerProxyAt(segments) {
     const cacheKey = JSON.stringify(segments);
     const existing = containerCache.get(cacheKey);
@@ -293,8 +602,9 @@ function buildSurfaceProxy(opts) {
     const proxy = new Proxy(target, {
       apply(_, __, args) {
         const arg = args[0];
-        if (arg === void 0) return proxy;
-        return navigateTo(arg);
+        if (arg === void 0) return opts.resolveCallTarget(segments);
+        const { segments: argSegs } = paths.canonicalizePath(arg);
+        return opts.resolveCallTarget(argSegs);
       },
       get(_, key) {
         if (typeof key === "symbol") {
@@ -356,8 +666,9 @@ function buildSurfaceProxy(opts) {
     const proxy = new Proxy(target, {
       apply(_, __, args) {
         const arg = args[0];
-        if (arg === void 0) return opts.resolveLeaf(segments);
-        return navigateTo(arg);
+        if (arg === void 0) return opts.resolveCallTarget(segments);
+        const { segments: argSegs } = paths.canonicalizePath(arg);
+        return opts.resolveCallTarget(argSegs);
       },
       get(_, key) {
         if (typeof key === "symbol") {
@@ -380,9 +691,8 @@ function buildSurfaceProxy(opts) {
         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).
+      // `JSON.stringify(form.fields.email)` produces a FieldState
+      // snapshot rather than the function-target placeholder.
       ownKeys: () => Array.from(leafKeys),
       getOwnPropertyDescriptor(_, key) {
         if (typeof key !== "string") return void 0;
@@ -423,7 +733,20 @@ function buildErrorsProxy(state) {
     },
     // No leafKeys — at a leaf, the resolved value (the merged array or
     // undefined) IS the terminal.
-    materializeContainer: (segments) => materializeErrors(state, segments)
+    materializeContainer: (segments) => materializeErrors(state, segments),
+    // Call-form aggregates: `form.errors(path)` returns a single
+    // `ValidationError[]` for any depth (leaf or container) — same
+    // shared `aggregateErrorsAt` helper that `form.meta.errors` and
+    // `form.fields(path).errors` use, so the three surfaces never
+    // drift. Empty results return `undefined`, matching the leaf
+    // proxy's pre-existing semantic (`form.errors.email === undefined`
+    // when valid) so consumer code that branches on truthiness keeps
+    // working — the call-form just extends that semantic to
+    // containers and dynamic paths.
+    resolveCallTarget: (path) => {
+      const errs = aggregateErrorsAt(state, path);
+      return errs.length === 0 ? void 0 : errs;
+    }
   });
 }
 function materializeErrors(state, containerSegments) {
@@ -530,39 +853,6 @@ function buildFieldArrayApi(state) {
   };
 }
 
-function buildFieldStateAccessor(state) {
-  return function getFieldState(pathInput) {
-    const { segments, key } = paths.canonicalizePath(pathInput);
-    return vue.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",
@@ -571,11 +861,19 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "focused",
   "blurred",
   "touched",
-  "isConnected",
+  "connected",
+  "element",
+  "elements",
   "updatedAt",
   "errors",
+  "validating",
+  "valid",
   "path",
-  "blank"
+  "blank",
+  "label",
+  "description",
+  "placeholder",
+  "meta"
 ]);
 function buildFieldStateProxy(state) {
   const getFieldStateAt = buildFieldStateAccessor(state);
@@ -585,12 +883,61 @@ function buildFieldStateProxy(state) {
     for (const k of FIELD_STATE_KEYS) snapshot[k] = view[k];
     return snapshot;
   };
+  const terminalCache = /* @__PURE__ */ new Map();
+  function fieldStateTerminalAt(segments) {
+    const cacheKey = JSON.stringify(segments);
+    const existing = terminalCache.get(cacheKey);
+    if (existing !== void 0) return existing;
+    const target = (() => {
+    });
+    const proxy = new Proxy(target, {
+      get(_, key) {
+        if (typeof key === "symbol") {
+          if (key === Symbol.toPrimitive) {
+            return (hint) => hint === "number" ? NaN : JSON.stringify(snapshotFieldStateAt(segments));
+          }
+          return Reflect.get(target, key);
+        }
+        if (typeof key !== "string") return void 0;
+        if (key === "toJSON") return () => snapshotFieldStateAt(segments);
+        if (key === "toString") return () => JSON.stringify(snapshotFieldStateAt(segments));
+        if (key === "valueOf")
+          return function() {
+            return this;
+          };
+        if (FIELD_STATE_KEYS.has(key)) {
+          const computed = getFieldStateAt(segments);
+          return computed.value[key];
+        }
+        return void 0;
+      },
+      has: (_, key) => typeof key === "string" && FIELD_STATE_KEYS.has(key),
+      ownKeys: () => Array.from(FIELD_STATE_KEYS),
+      getOwnPropertyDescriptor(_, key) {
+        if (typeof key !== "string") return void 0;
+        if (!FIELD_STATE_KEYS.has(key)) return void 0;
+        const computed = getFieldStateAt(segments);
+        return {
+          configurable: true,
+          enumerable: true,
+          value: computed.value[key],
+          writable: false
+        };
+      },
+      set: () => false,
+      deleteProperty: () => false,
+      defineProperty: () => false
+    });
+    terminalCache.set(cacheKey, proxy);
+    return proxy;
+  }
   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)
+    materializeContainer: (segments) => materializeFields(state, segments, snapshotFieldStateAt),
+    resolveCallTarget: (path) => fieldStateTerminalAt(path)
   });
 }
 function materializeFields(state, containerSegments, snapshotFieldStateAt) {
@@ -922,7 +1269,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
       }
       const genAtEntry = state.submissionGeneration.value;
       state.activeSubmissions.value += 1;
-      state.isSubmitting.value = true;
+      state.submitting.value = true;
       state.submitError.value = null;
       state.cancelFieldValidation();
       state.activeValidations.value += 1;
@@ -969,7 +1316,7 @@ function buildProcessForm(state, formInstanceId, options = {}) {
         }
         state.activeSubmissions.value = Math.max(0, state.activeSubmissions.value - 1);
         if (state.submissionGeneration.value === genAtEntry) {
-          state.isSubmitting.value = state.activeSubmissions.value > 0;
+          state.submitting.value = state.activeSubmissions.value > 0;
           state.submitCount.value += 1;
         }
       }
@@ -1365,14 +1712,14 @@ function buildRegister(state, formInstanceId) {
       segments,
       state.coerceIndex
     );
-    if (persist && !state.isSSR && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
+    if (persist && !state.ssr && !state.modules.has(PERSISTENCE_MODULE_KEY)) {
       throw new sensitiveNames.AnonPersistError({
         cause: "register-without-config",
         schemaFields: extractSchemaFields(state.schema),
         callSite: sensitiveNames.captureUserCallSite()
       });
     }
-    return {
+    const internalRv = {
       innerRef,
       displayValue,
       lastTypedForm,
@@ -1396,18 +1743,25 @@ function buildRegister(state, formInstanceId) {
       },
       // 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`
+      // Without it, every SSR'd FieldState serialises `connected: 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
+      // `created` hook. The mark only takes effect when `state.ssr` is
       // true; on the client this is a no-op so the directive lifecycle
       // remains the source of truth.
       markConnectedOptimistically: () => {
         state.markConnectedOptimistically(segments);
       },
+      path: pathKey,
+      // Frozen so a wrapper component can pass `rv.segments` directly
+      // to `form.fields(...)` without defensive copying — and so test
+      // fixtures or downstream code can't mutate the canonical
+      // segment list out from under the directive.
+      segments: Object.freeze(segments.slice()),
+      formKey: state.formKey,
+      formInstanceId,
       // --- Persistence opt-in (internal; the directive is the only
       // legitimate consumer) ---
-      path: pathKey,
       persist,
       acknowledgeSensitive,
       persistOptIns: state.persistOptIns,
@@ -1415,6 +1769,7 @@ function buildRegister(state, formInstanceId) {
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {}
     };
+    return vue.shallowReadonly(internalRv);
   };
 }
 
@@ -1453,22 +1808,30 @@ function walk(input, segments, schema, paths$1) {
   }
   if (Array.isArray(input)) {
     const out = new Array(input.length);
+    let mutated = false;
     for (let i = 0; i < input.length; i++) {
-      out[i] = walk(input[i], [...segments, i], schema, paths$1);
+      const walked = walk(input[i], [...segments, i], schema, paths$1);
+      out[i] = walked;
+      if (walked !== input[i]) mutated = true;
     }
-    return out;
+    return mutated ? out : input;
   }
   if (typeof input === "object") {
     const slim = schema.getDefaultAtPath(segments);
-    const allKeys = new Set(Object.keys(input));
+    const inputKeys = Object.keys(input);
+    const allKeys = new Set(inputKeys);
     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 = {};
+    let mutated = allKeys.size !== inputKeys.length;
     for (const key of allKeys) {
-      out[key] = walk(input[key], [...segments, key], schema, paths$1);
+      const orig = input[key];
+      const walked = walk(orig, [...segments, key], schema, paths$1);
+      out[key] = walked;
+      if (walked !== orig) mutated = true;
     }
-    return out;
+    return mutated ? out : input;
   }
   return input;
 }
@@ -1492,6 +1855,48 @@ function walkUnspecified(slim, segments, paths$1) {
   }
   return slim;
 }
+function substituteUnsetSentinels(value, prefix, schema) {
+  const paths = [];
+  const cleaned = substitute(value, [...prefix], schema, paths);
+  return { cleanedValues: cleaned, paths };
+}
+function substitute(input, segments, schema, paths$1) {
+  if (isUnset(input)) {
+    const slim = schema.getDefaultAtPath(segments);
+    if (!isPrimitiveOrEmpty(slim)) {
+      warnNonPrimitiveLeaf(segments, slim);
+      return slim;
+    }
+    paths$1.push(paths.canonicalizePath(segments).key);
+    return slim;
+  }
+  if (input === void 0 || input === null) return input;
+  if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set || typeof input === "function") {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    let mutated = false;
+    const out = new Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const walked = substitute(input[i], [...segments, i], schema, paths$1);
+      out[i] = walked;
+      if (walked !== input[i]) mutated = true;
+    }
+    return mutated ? out : input;
+  }
+  if (typeof input === "object") {
+    let mutated = false;
+    const out = {};
+    for (const key of Object.keys(input)) {
+      const orig = input[key];
+      const walked = substitute(orig, [...segments, key], schema, paths$1);
+      out[key] = walked;
+      if (walked !== orig) mutated = true;
+    }
+    return mutated ? out : input;
+  }
+  return input;
+}
 function isPrimitiveOrEmpty(value) {
   if (value === null || value === void 0) return true;
   const t = typeof value;
@@ -1600,14 +2005,14 @@ function buildFormApi(state, formInstanceId, options = {}) {
   }
   function setValueImpl(pathOrValue, maybeValue) {
     if (arguments.length === 1) {
-      const next = typeof pathOrValue === "function" ? pathOrValue(state.form.value) : pathOrValue;
-      const walked = walkUnsetSentinels(
+      const next = typeof pathOrValue === "function" ? pathOrValue(structuralSnapshot(state.form.value)) : pathOrValue;
+      const walked2 = walkUnsetSentinels(
         next,
         state.schema
       );
-      const ok = state.setValueAtPath([], walked.cleanedValues);
-      if (!ok) return false;
-      for (const pathKey of walked.paths) {
+      const ok2 = state.setValueAtPath([], walked2.cleanedValues);
+      if (!ok2) return false;
+      for (const pathKey of walked2.paths) {
         const segments2 = paths.segmentsForPathKey(pathKey);
         if (segments2 === null) continue;
         state.setValueAtPath(segments2, state.schema.getDefaultAtPath(segments2), {
@@ -1635,7 +2040,21 @@ function buildFormApi(state, formInstanceId, options = {}) {
     } else {
       resolvedValue = maybeValue;
     }
-    return state.setValueAtPath(segments, resolvedValue);
+    const walked = substituteUnsetSentinels(
+      resolvedValue,
+      segments,
+      state.schema
+    );
+    const ok = state.setValueAtPath(segments, walked.cleanedValues);
+    if (!ok) return false;
+    for (const pathKey of walked.paths) {
+      const blankSegments = paths.segmentsForPathKey(pathKey);
+      if (blankSegments === null) continue;
+      state.setValueAtPath(blankSegments, state.schema.getDefaultAtPath(blankSegments), {
+        blank: true
+      });
+    }
+    return true;
   }
   const errorsProxy = buildErrorsProxy(state);
   function setFieldErrors(errors) {
@@ -1654,58 +2073,89 @@ function buildFormApi(state, formInstanceId, options = {}) {
     state.clearSchemaErrors(segments);
     state.clearUserErrors(segments);
   }
-  const isDirty = vue.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;
+  function setFormErrors(errors) {
+    if (errors.length === 0) {
+      state.userErrors.delete(paths.ROOT_PATH_KEY);
+      return;
     }
-    return false;
-  });
-  const isValid = vue.computed(
-    () => state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0
-  );
-  const isSubmitting = vue.computed(() => state.isSubmitting.value);
+    state.userErrors.set(
+      paths.ROOT_PATH_KEY,
+      errors.map((e) => ({
+        path: [],
+        message: e.message,
+        formKey: state.formKey,
+        code: e.code ?? "atta:form-error"
+      }))
+    );
+  }
+  function clearFormErrors() {
+    state.userErrors.delete(paths.ROOT_PATH_KEY);
+  }
+  const submitting = vue.computed(() => state.submitting.value);
   const submitCount = vue.computed(() => state.submitCount.value);
   const submitError = vue.computed(() => state.submitError.value);
-  const isValidating = vue.computed(() => state.activeValidations.value > 0);
+  const validating = vue.computed(() => state.activeValidations.value > 0);
+  const valid = vue.computed(
+    () => state.firstValidationDone.value && state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0 && !validating.value
+  );
   const history = options.history;
   const undo = history?.undo ?? (() => false);
   const redo = history?.redo ?? (() => false);
   const canUndo = history?.canUndo ?? vue.computed(() => false);
   const canRedo = history?.canRedo ?? vue.computed(() => false);
   const historySize = history?.historySize ?? vue.computed(() => 0);
-  const metaErrors = vue.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 metaErrors = vue.computed(
+    () => aggregateErrorsAt(state, [])
+  );
+  const getRootFieldStateAt = buildFieldStateAccessor(state);
+  const rootFieldState = getRootFieldStateAt([]);
   const formMeta = vue.readonly(
     vue.reactive({
-      isDirty,
-      isValid,
-      isSubmitting,
-      isValidating,
+      // FieldState fields — read through one shared root computed. Each
+      // property accesses `rootFieldState.value[X]`, so any descendant
+      // change re-evaluates the root computed once (Vue's reactive
+      // graph dedupes the dependent re-renders).
+      value: vue.computed(() => rootFieldState.value.value),
+      original: vue.computed(() => rootFieldState.value.original),
+      pristine: vue.computed(() => rootFieldState.value.pristine),
+      dirty: vue.computed(() => rootFieldState.value.dirty),
+      focused: vue.computed(() => rootFieldState.value.focused),
+      blurred: vue.computed(() => rootFieldState.value.blurred),
+      touched: vue.computed(() => rootFieldState.value.touched),
+      connected: vue.computed(() => rootFieldState.value.connected),
+      element: vue.computed(() => rootFieldState.value.element),
+      elements: vue.computed(() => rootFieldState.value.elements),
+      updatedAt: vue.computed(() => rootFieldState.value.updatedAt),
+      // Whole-form validating mirrors the LIFECYCLE counter
+      // (`state.activeValidations`) ORed with any per-leaf validation
+      // in flight (via `rootFieldState.validating`). A submit-time
+      // validate run shows up as activeValidations; per-field
+      // debounced validators show up as fieldValidationCounts. Either
+      // flips the flag.
+      validating: vue.computed(
+        () => state.activeValidations.value > 0 || rootFieldState.value.validating
+      ),
+      // Whole-form valid keeps the original `firstValidationDone`
+      // mount gate so the surface doesn't lie about a yet-to-arrive
+      // verdict at construction time. The shared `aggregateErrorsAt`
+      // ensures `form.meta.errors` and `rootFieldState.errors` match,
+      // so `errors.length === 0` here would agree with `valid` —
+      // keep the explicit form-level computation for the gate.
+      valid,
+      errors: metaErrors,
+      path: vue.computed(() => rootFieldState.value.path),
+      blank: vue.computed(() => rootFieldState.value.blank),
+      label: vue.computed(() => rootFieldState.value.label),
+      description: vue.computed(() => rootFieldState.value.description),
+      placeholder: vue.computed(() => rootFieldState.value.placeholder),
+      meta: vue.computed(() => rootFieldState.value.meta),
+      // Lifecycle (form-level only — not on FieldState).
+      submitting,
       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
@@ -1796,6 +2246,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     setFieldErrors,
     addFieldErrors,
     clearFieldErrors,
+    setFormErrors,
+    clearFormErrors,
     meta: formMeta,
     reset,
     resetField,
@@ -1816,103 +2268,10 @@ function buildFormApi(state, formInstanceId, options = {}) {
   };
 }
 
-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);
+  return Array.isArray(r.path) && (typeof r.updatedAt === "string" || r.updatedAt === null) && typeof r.connected === "boolean" && (typeof r.focused === "boolean" || r.focused === null) && (typeof r.blurred === "boolean" || r.blurred === null) && (typeof r.touched === "boolean" || r.touched === null);
 }
 function isHydratedValidationErrorArray(value) {
   if (!Array.isArray(value)) return false;
@@ -1943,7 +2302,7 @@ function isPathKeyUnder(existingKey, parentPath) {
 }
 function createFormStore(options) {
   const { formKey, schema, defaultValues, strict = true, hydration } = options;
-  const isSSR = options.isSSR === true;
+  const ssr = options.ssr === true;
   const rememberVariants = options.rememberVariants !== false;
   const fieldValidationMode = options.validateOn ?? "change";
   const fieldValidationDebounceMs = options.debounceMs ?? DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS;
@@ -1962,7 +2321,7 @@ function createFormStore(options) {
     strict
   });
   const schemaInitialData = schemaResponse.data;
-  const initialData = hydration !== void 0 ? hydration.form : schemaInitialData;
+  const initialData = hydration !== void 0 ? hydration.form : structuralSnapshot(schemaInitialData);
   const form = vue.ref(initialData);
   const fields = vue.reactive(/* @__PURE__ */ new Map());
   const elements = vue.reactive(/* @__PURE__ */ new Map());
@@ -1970,7 +2329,7 @@ function createFormStore(options) {
   let sortedRegistrationsCache = null;
   const schemaErrors = vue.reactive(/* @__PURE__ */ new Map());
   const userErrors = vue.reactive(/* @__PURE__ */ new Map());
-  const originals = /* @__PURE__ */ new Map();
+  const originals = vue.reactive(/* @__PURE__ */ new Map());
   const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
   const blankPaths = vue.reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
@@ -2008,12 +2367,37 @@ function createFormStore(options) {
     }
     return result;
   });
-  const isSubmitting = vue.ref(false);
+  const submitting = vue.ref(false);
   const activeSubmissions = vue.ref(0);
   const submitCount = vue.ref(0);
   const submitError = vue.ref(null);
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
+  const firstValidationDone = vue.ref(!strict || schema.needsAsyncValidation?.() !== true);
+  vue.watch(activeValidations, (now, prev) => {
+    if (prev > 0 && now === 0) {
+      firstValidationDone.value = true;
+    }
+  });
+  const pathAsyncCache = /* @__PURE__ */ new Map();
+  function pathHasAsyncValidation(path) {
+    const { key } = paths.canonicalizePath(path);
+    const cached = pathAsyncCache.get(key);
+    if (cached !== void 0) return cached;
+    const candidates = schema.getSchemasAtPath(path);
+    const hasAsync = candidates.some((sub) => sub.needsAsyncValidation?.() === true);
+    pathAsyncCache.set(key, hasAsync);
+    return hasAsync;
+  }
+  const fieldValidationCounts = vue.reactive(/* @__PURE__ */ new Map());
+  function incFieldValidation(key) {
+    fieldValidationCounts.set(key, (fieldValidationCounts.get(key) ?? 0) + 1);
+  }
+  function decFieldValidation(key) {
+    const next = (fieldValidationCounts.get(key) ?? 0) - 1;
+    if (next <= 0) fieldValidationCounts.delete(key);
+    else fieldValidationCounts.set(key, next);
+  }
   const initStamp = (/* @__PURE__ */ new Date()).toISOString();
   diffAndApply({}, schemaInitialData, [], (patch) => {
     if (patch.kind !== "added") return;
@@ -2050,7 +2434,7 @@ function createFormStore(options) {
       fields.set(key, {
         path: patch.path,
         updatedAt: initStamp,
-        isConnected: false,
+        connected: false,
         focused: null,
         blurred: null,
         touched: null
@@ -2060,7 +2444,7 @@ function createFormStore(options) {
       setAllSchemaErrors(schemaResponse.errors);
     }
   }
-  if (!isSSR && strict && schema.needsAsyncValidation?.() === true) {
+  if (!ssr && strict && schema.needsAsyncValidation?.() === true) {
     queueMicrotask(() => scheduleFieldValidation(
       [],
       true
@@ -2072,7 +2456,7 @@ function createFormStore(options) {
     fields.set(pathKey, {
       path,
       updatedAt: patch.updatedAt ?? current?.updatedAt ?? null,
-      isConnected: patch.isConnected ?? current?.isConnected ?? false,
+      connected: patch.connected ?? current?.connected ?? false,
       focused: patch.focused ?? current?.focused ?? null,
       blurred: patch.blurred ?? current?.blurred ?? null,
       touched: patch.touched ?? current?.touched ?? null
@@ -2081,18 +2465,24 @@ function createFormStore(options) {
   function applyFormReplacement(next, meta) {
     const prev = form.value;
     if (Object.is(prev, next)) return;
-    form.value = next;
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const patches = [];
     diffAndApply(prev, next, [], (patch) => {
+      patches.push(patch);
+    });
+    if (!applyChangedKeys(prev, next)) {
+      form.value = next;
+    }
+    for (const patch of patches) {
       const { key } = paths.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);
+        listener(form.value, meta);
       } catch (err) {
         console.error("[attaform] onFormChange threw:", err);
       }
@@ -2266,6 +2656,7 @@ function createFormStore(options) {
       if (controller.signal.aborted) return;
       const data = getAtPath(form.value, path);
       activeValidations.value += 1;
+      incFieldValidation(key);
       void Promise.resolve().then(() => schema.validateAtPath(data, path)).then((response) => {
         if (controller.signal.aborted) return;
         const reStamped = response.success ? [] : response.errors.map((err) => ({
@@ -2276,6 +2667,7 @@ function createFormStore(options) {
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
       });
     };
     if (immediate || fieldValidationDebounceMs === 0) {
@@ -2431,15 +2823,16 @@ function createFormStore(options) {
   function registerElement(path, element, formInstanceId) {
     const { key } = paths.canonicalizePath(path);
     const record = elements.get(key);
+    const raw = vue.markRaw(element);
     if (record === void 0) {
-      elements.set(key, { path, elements: /* @__PURE__ */ new Set([element]) });
+      elements.set(key, { path, elements: vue.reactive(/* @__PURE__ */ new Set([raw])) });
     } else {
-      if (record.elements.has(element)) return false;
-      record.elements.add(element);
+      if (record.elements.has(raw)) return false;
+      record.elements.add(raw);
     }
     elementToFormInstance.set(element, formInstanceId);
     sortedRegistrationsCache = null;
-    touchFieldRecord(key, path, { isConnected: true });
+    touchFieldRecord(key, path, { connected: true });
     return true;
   }
   function deregisterElement(path, element) {
@@ -2454,16 +2847,16 @@ function createFormStore(options) {
     const remaining = record.elements.size;
     if (remaining === 0) {
       elements.delete(key);
-      touchFieldRecord(key, path, { isConnected: false });
+      touchFieldRecord(key, path, { connected: false });
     }
     return remaining;
   }
   function markConnectedOptimistically(path) {
-    if (!isSSR) return;
+    if (!ssr) return;
     const { key } = paths.canonicalizePath(path);
     const current = fields.get(key);
-    if (current?.isConnected === true) return;
-    touchFieldRecord(key, path, { isConnected: true });
+    if (current?.connected === true) return;
+    touchFieldRecord(key, path, { connected: true });
   }
   function markFocused(path, focused) {
     const { key } = paths.canonicalizePath(path);
@@ -2515,14 +2908,14 @@ function createFormStore(options) {
       fields.set(pathKey, {
         path: record.path,
         updatedAt: now,
-        isConnected: record.isConnected,
+        connected: record.connected,
         focused: null,
         blurred: null,
         touched: null
       });
     }
     submissionGeneration.value += 1;
-    isSubmitting.value = false;
+    submitting.value = false;
     activeSubmissions.value = 0;
     submitCount.value = 0;
     submitError.value = null;
@@ -2599,7 +2992,7 @@ function createFormStore(options) {
     fields.set(pathKey, {
       path: record.path,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      isConnected: record.isConnected,
+      connected: record.connected,
       focused: null,
       blurred: null,
       touched: null
@@ -2661,13 +3054,16 @@ function createFormStore(options) {
     derivedBlankErrors,
     originals,
     schema,
-    isSSR,
-    isSubmitting,
+    ssr,
+    submitting,
     activeSubmissions,
     submitCount,
     submitError,
     submissionGeneration,
     activeValidations,
+    firstValidationDone,
+    pathHasAsyncValidation,
+    fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
@@ -2720,7 +3116,7 @@ function createHistoryModule(state, config) {
   let suppressNext = false;
   function captureSnapshot() {
     return {
-      form: state.form.value,
+      form: structuralSnapshot(state.form.value),
       blankPaths: [...state.blankPaths],
       schemaErrors: [...state.schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
       userErrors: [...state.userErrors.entries()].map(([k, v]) => [k, [...v]])
@@ -2827,8 +3223,8 @@ function useAbstractForm(configuration) {
     const releaseConsumer = registry.trackConsumer(key);
     vue.onScopeDispose(releaseConsumer);
   }
-  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.isSSR);
-  if (existing === void 0 && !registry.isSSR) {
+  const persistDisabledByAnonRule = merged.persist !== void 0 && enforceAnonPersistRule(state.formKey, registry.ssr);
+  if (existing === void 0 && !registry.ssr) {
     if (merged.persist !== void 0 && !persistDisabledByAnonRule) {
       const resolvedPersist = normalizePersistConfig(merged.persist);
       const persistenceBase = resolveStorageKeyBase(resolvedPersist, state.formKey);
@@ -2847,7 +3243,7 @@ function useAbstractForm(configuration) {
     state.registerCleanup(() => historyModule.dispose());
   }
   if (configuration.key === void 0) {
-    recordAmbientProvide(registry.isSSR);
+    recordAmbientProvide(registry.ssr);
     vue.provide(sensitiveNames.kFormContext, state);
   }
   const formInstanceId = vue.getCurrentInstance() !== null ? vue.useId() : `atta:form-instance:${formInstanceCounter++}`;
@@ -2900,7 +3296,7 @@ function buildFreshState(key, schema, configuration, registry) {
     hydration: pending,
     ...configuration.validateOn !== void 0 ? { validateOn: configuration.validateOn } : {},
     ...configuration.debounceMs !== void 0 ? { debounceMs: configuration.debounceMs } : {},
-    isSSR: registry.isSSR,
+    ssr: registry.ssr,
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
     ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {}
@@ -2915,8 +3311,8 @@ function buildFreshState(key, schema, configuration, registry) {
 let anonCounter = 0;
 let formInstanceCounter = 0;
 const ambientProvideHistory = sensitiveNames.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(isSSR) {
-  if (!sensitiveNames.__DEV__ || isSSR || ambientProvideHistory === null) return;
+function recordAmbientProvide(ssr) {
+  if (!sensitiveNames.__DEV__ || ssr || ambientProvideHistory === null) return;
   const instance = vue.getCurrentInstance();
   if (instance === null) return;
   const instanceKey = instance;
@@ -3178,14 +3574,14 @@ function isEmptyContainer(value) {
   return false;
 }
 const warnedAnonPersistKeys = /* @__PURE__ */ new Set();
-function enforceAnonPersistRule(formKey, isSSR) {
+function enforceAnonPersistRule(formKey, ssr) {
   if (!formKey.startsWith(ANONYMOUS_FORM_KEY_PREFIX)) return false;
   if (sensitiveNames.__DEV__)
     throw new sensitiveNames.AnonPersistError({
       cause: "no-key",
       callSite: sensitiveNames.captureUserCallSite()
     });
-  if (!isSSR && !warnedAnonPersistKeys.has(formKey)) {
+  if (!ssr && !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: '...' })"
@@ -3243,21 +3639,21 @@ 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);
+      warnMiss(`no form registered for key '${key}'`, registry.ssr);
       return null;
     }
     return stored;
   }
   const ambient = vue.inject(sensitiveNames.kFormContext, null);
   if (ambient === null) {
-    warnMiss("no ambient form context", registry.isSSR);
+    warnMiss("no ambient form context", registry.ssr);
     return null;
   }
   warnIfAmbientProviderHadDuplicates();
   return ambient;
 }
-function warnMiss(detail, isSSR) {
-  if (!sensitiveNames.__DEV__ || isSSR) return;
+function warnMiss(detail, ssr) {
+  if (!sensitiveNames.__DEV__ || ssr) return;
   const frame = sensitiveNames.captureUserCallSite();
   console.warn(
     `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
@@ -3285,6 +3681,7 @@ exports.AttaformErrorCode = AttaformErrorCode;
 exports.defaultCoercionRules = defaultCoercionRules;
 exports.defineCoercion = defineCoercion;
 exports.getAtPath = getAtPath;
+exports.humanize = humanize;
 exports.injectForm = injectForm;
 exports.isPlainRecord = isPlainRecord;
 exports.isUnset = isUnset;
@@ -3292,4 +3689,4 @@ exports.setAtPath = setAtPath;
 exports.slimKindOf = slimKindOf;
 exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
-//# sourceMappingURL=attaform.CNJO3mME.cjs.map
+//# sourceMappingURL=attaform.CDJVeoJU.cjs.map