attaform 0.14.0 → 0.15.1

package/dist/shared/{attaform.BRTxpA3q.mjs → attaform.qxyip_aN.mjs}

@@ -1,6 +1,173 @@
-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';
+import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, watch, markRaw, shallowRef, provide, getCurrentInstance, useId, toRaw, inject } from 'vue';
+import { s as segmentsForPathKey, i as isPathPrefix, c as canonicalizePath, a as ROOT_PATH_KEY } from './attaform.DXye3JKf.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.a99dQV7Q.mjs';
+
+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) {
@@ -246,6 +413,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 } = canonicalizePath(pathInput);
+    const cached = cache.get(key);
+    if (cached !== void 0) return cached;
+    const c = 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(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 (!isPathPrefix(segments, entry.segments)) continue;
+    if (segments.length === entry.segments.length) continue;
+    if (!hasAtPath(formValue, entry.segments)) continue;
+    const leafKey = 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 = segmentsForPathKey(pathKey);
+      if (segs === null) continue;
+      if (!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;
@@ -270,11 +584,6 @@ function buildSurfaceProxy(opts) {
     }
     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);
@@ -291,8 +600,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 } = canonicalizePath(arg);
+        return opts.resolveCallTarget(argSegs);
       },
       get(_, key) {
         if (typeof key === "symbol") {
@@ -354,8 +664,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 } = canonicalizePath(arg);
+        return opts.resolveCallTarget(argSegs);
       },
       get(_, key) {
         if (typeof key === "symbol") {
@@ -378,9 +689,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;
@@ -421,7 +731,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) {
@@ -528,39 +851,6 @@ function buildFieldArrayApi(state) {
   };
 }
 
-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",
@@ -569,11 +859,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);
@@ -583,12 +881,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) {
@@ -920,7 +1267,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;
@@ -967,7 +1314,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;
         }
       }
@@ -1363,14 +1710,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 AnonPersistError({
         cause: "register-without-config",
         schemaFields: extractSchemaFields(state.schema),
         callSite: captureUserCallSite()
       });
     }
-    return {
+    const internalRv = {
       innerRef,
       displayValue,
       lastTypedForm,
@@ -1394,18 +1741,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,
@@ -1413,6 +1767,7 @@ function buildRegister(state, formInstanceId) {
       coerce,
       ...coerceElement !== void 0 ? { coerceElement } : {}
     };
+    return shallowReadonly(internalRv);
   };
 }
 
@@ -1451,22 +1806,30 @@ function walk(input, segments, schema, paths) {
   }
   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);
+      const walked = walk(input[i], [...segments, i], schema, paths);
+      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);
+      const orig = input[key];
+      const walked = walk(orig, [...segments, key], schema, paths);
+      out[key] = walked;
+      if (walked !== orig) mutated = true;
     }
-    return out;
+    return mutated ? out : input;
   }
   return input;
 }
@@ -1490,6 +1853,48 @@ function walkUnspecified(slim, segments, paths) {
   }
   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) {
+  if (isUnset(input)) {
+    const slim = schema.getDefaultAtPath(segments);
+    if (!isPrimitiveOrEmpty(slim)) {
+      warnNonPrimitiveLeaf(segments, slim);
+      return slim;
+    }
+    paths.push(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);
+      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);
+      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;
@@ -1598,14 +2003,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 = segmentsForPathKey(pathKey);
         if (segments2 === null) continue;
         state.setValueAtPath(segments2, state.schema.getDefaultAtPath(segments2), {
@@ -1633,7 +2038,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 = segmentsForPathKey(pathKey);
+      if (blankSegments === null) continue;
+      state.setValueAtPath(blankSegments, state.schema.getDefaultAtPath(blankSegments), {
+        blank: true
+      });
+    }
+    return true;
   }
   const errorsProxy = buildErrorsProxy(state);
   function setFieldErrors(errors) {
@@ -1652,58 +2071,89 @@ function buildFormApi(state, formInstanceId, options = {}) {
     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;
+  function setFormErrors(errors) {
+    if (errors.length === 0) {
+      state.userErrors.delete(ROOT_PATH_KEY);
+      return;
     }
-    return false;
-  });
-  const isValid = computed(
-    () => state.schemaErrors.size === 0 && state.userErrors.size === 0 && state.derivedBlankErrors.value.size === 0
-  );
-  const isSubmitting = computed(() => state.isSubmitting.value);
+    state.userErrors.set(
+      ROOT_PATH_KEY,
+      errors.map((e) => ({
+        path: [],
+        message: e.message,
+        formKey: state.formKey,
+        code: e.code ?? "atta:form-error"
+      }))
+    );
+  }
+  function clearFormErrors() {
+    state.userErrors.delete(ROOT_PATH_KEY);
+  }
+  const submitting = computed(() => state.submitting.value);
   const submitCount = computed(() => state.submitCount.value);
   const submitError = computed(() => state.submitError.value);
-  const isValidating = computed(() => state.activeValidations.value > 0);
+  const validating = computed(() => state.activeValidations.value > 0);
+  const valid = 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 ?? 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 metaErrors = computed(
+    () => aggregateErrorsAt(state, [])
+  );
+  const getRootFieldStateAt = buildFieldStateAccessor(state);
+  const rootFieldState = getRootFieldStateAt([]);
   const formMeta = readonly(
     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: computed(() => rootFieldState.value.value),
+      original: computed(() => rootFieldState.value.original),
+      pristine: computed(() => rootFieldState.value.pristine),
+      dirty: computed(() => rootFieldState.value.dirty),
+      focused: computed(() => rootFieldState.value.focused),
+      blurred: computed(() => rootFieldState.value.blurred),
+      touched: computed(() => rootFieldState.value.touched),
+      connected: computed(() => rootFieldState.value.connected),
+      element: computed(() => rootFieldState.value.element),
+      elements: computed(() => rootFieldState.value.elements),
+      updatedAt: 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: 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: computed(() => rootFieldState.value.path),
+      blank: computed(() => rootFieldState.value.blank),
+      label: computed(() => rootFieldState.value.label),
+      description: computed(() => rootFieldState.value.description),
+      placeholder: computed(() => rootFieldState.value.placeholder),
+      meta: 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
@@ -1794,6 +2244,8 @@ function buildFormApi(state, formInstanceId, options = {}) {
     setFieldErrors,
     addFieldErrors,
     clearFieldErrors,
+    setFormErrors,
+    clearFormErrors,
     meta: formMeta,
     reset,
     resetField,
@@ -1814,103 +2266,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;
@@ -1941,7 +2300,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;
@@ -1960,7 +2319,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 = ref(initialData);
   const fields = reactive(/* @__PURE__ */ new Map());
   const elements = reactive(/* @__PURE__ */ new Map());
@@ -1968,7 +2327,7 @@ function createFormStore(options) {
   let sortedRegistrationsCache = null;
   const schemaErrors = reactive(/* @__PURE__ */ new Map());
   const userErrors = reactive(/* @__PURE__ */ new Map());
-  const originals = /* @__PURE__ */ new Map();
+  const originals = reactive(/* @__PURE__ */ new Map());
   const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
   const blankPaths = reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
@@ -2006,12 +2365,37 @@ function createFormStore(options) {
     }
     return result;
   });
-  const isSubmitting = ref(false);
+  const submitting = ref(false);
   const activeSubmissions = ref(0);
   const submitCount = ref(0);
   const submitError = ref(null);
   const submissionGeneration = ref(0);
   const activeValidations = ref(0);
+  const firstValidationDone = ref(!strict || schema.needsAsyncValidation?.() !== true);
+  watch(activeValidations, (now, prev) => {
+    if (prev > 0 && now === 0) {
+      firstValidationDone.value = true;
+    }
+  });
+  const pathAsyncCache = /* @__PURE__ */ new Map();
+  function pathHasAsyncValidation(path) {
+    const { key } = 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 = 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;
@@ -2048,7 +2432,7 @@ function createFormStore(options) {
       fields.set(key, {
         path: patch.path,
         updatedAt: initStamp,
-        isConnected: false,
+        connected: false,
         focused: null,
         blurred: null,
         touched: null
@@ -2058,7 +2442,7 @@ function createFormStore(options) {
       setAllSchemaErrors(schemaResponse.errors);
     }
   }
-  if (!isSSR && strict && schema.needsAsyncValidation?.() === true) {
+  if (!ssr && strict && schema.needsAsyncValidation?.() === true) {
     queueMicrotask(() => scheduleFieldValidation(
       [],
       true
@@ -2070,7 +2454,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
@@ -2079,18 +2463,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 } = 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);
       }
@@ -2264,6 +2654,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) => ({
@@ -2274,6 +2665,7 @@ function createFormStore(options) {
       }).catch(() => {
       }).finally(() => {
         activeValidations.value = Math.max(0, activeValidations.value - 1);
+        decFieldValidation(key);
       });
     };
     if (immediate || fieldValidationDebounceMs === 0) {
@@ -2429,15 +2821,16 @@ function createFormStore(options) {
   function registerElement(path, element, formInstanceId) {
     const { key } = canonicalizePath(path);
     const record = elements.get(key);
+    const raw = markRaw(element);
     if (record === void 0) {
-      elements.set(key, { path, elements: /* @__PURE__ */ new Set([element]) });
+      elements.set(key, { path, elements: 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) {
@@ -2452,16 +2845,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 } = 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 } = canonicalizePath(path);
@@ -2513,14 +2906,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;
@@ -2597,7 +2990,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
@@ -2659,13 +3052,16 @@ function createFormStore(options) {
     derivedBlankErrors,
     originals,
     schema,
-    isSSR,
-    isSubmitting,
+    ssr,
+    submitting,
     activeSubmissions,
     submitCount,
     submitError,
     submissionGeneration,
     activeValidations,
+    firstValidationDone,
+    pathHasAsyncValidation,
+    fieldValidationCounts,
     applyFormReplacement,
     setValueAtPath,
     getValueAtPath,
@@ -2718,7 +3114,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]])
@@ -2825,8 +3221,8 @@ function useAbstractForm(configuration) {
     const releaseConsumer = registry.trackConsumer(key);
     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);
@@ -2845,7 +3241,7 @@ function useAbstractForm(configuration) {
     state.registerCleanup(() => historyModule.dispose());
   }
   if (configuration.key === void 0) {
-    recordAmbientProvide(registry.isSSR);
+    recordAmbientProvide(registry.ssr);
     provide(kFormContext, state);
   }
   const formInstanceId = getCurrentInstance() !== null ? useId() : `atta:form-instance:${formInstanceCounter++}`;
@@ -2898,7 +3294,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 } : {}
@@ -2913,8 +3309,8 @@ function buildFreshState(key, schema, configuration, registry) {
 let anonCounter = 0;
 let formInstanceCounter = 0;
 const ambientProvideHistory = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
-function recordAmbientProvide(isSSR) {
-  if (!__DEV__ || isSSR || ambientProvideHistory === null) return;
+function recordAmbientProvide(ssr) {
+  if (!__DEV__ || ssr || ambientProvideHistory === null) return;
   const instance = getCurrentInstance();
   if (instance === null) return;
   const instanceKey = instance;
@@ -3176,14 +3572,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 (__DEV__)
     throw new AnonPersistError({
       cause: "no-key",
       callSite: 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: '...' })"
@@ -3241,21 +3637,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 = inject(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 (!__DEV__ || isSSR) return;
+function warnMiss(detail, ssr) {
+  if (!__DEV__ || ssr) return;
   const frame = captureUserCallSite();
   console.warn(
     `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
@@ -3279,5 +3675,5 @@ function warnIfAmbientProviderHadDuplicates() {
   }
 }
 
-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
+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, humanize as h, injectForm as i, slimKindOf as s, unset as u };
+//# sourceMappingURL=attaform.qxyip_aN.mjs.map