attaform 0.27.6 → 0.29.0

package/dist/{shared/attaform.B1ZYt2Li.mjs → dev/shared/attaform-dev.q6UutkCx.mjs}

@@ -1,57 +1,7 @@
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as getFieldMetaPathMap, m as mergeDeep, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.CoR4mWfv.mjs';
-import { q as humanize, r as getAtPath, p as slimKindOf, t as setAtPath, h as useAbstractForm } from './attaform.CKH2lGdL.mjs';
-import { A as AttaformError, _ as __DEV__, f as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.nMaz2C5P.mjs';
-
-const fieldMeta = fieldMetaStore;
-function withMeta(schema, payload) {
-  const existing = getFieldMetaForSchema(schema) ?? {};
-  const Ctor = schema.constructor;
-  const cloned = new Ctor(schema._def);
-  fieldMetaStore.add(cloned, { ...existing, ...payload });
-  return cloned;
-}
-function getFieldMeta(schema) {
-  return getFieldMetaForSchema(schema);
-}
-function getFieldMetaList(schema) {
-  return getFieldMetaListForSchema(schema);
-}
-
-function cloneSchemaDeep(value) {
-  return clone(value, /* @__PURE__ */ new WeakMap());
-}
-function clone(value, seen) {
-  if (value === null || typeof value !== "object") return value;
-  if (seen.has(value)) return seen.get(value);
-  if (value instanceof RegExp) {
-    const copy2 = new RegExp(value.source, value.flags);
-    copy2.lastIndex = value.lastIndex;
-    seen.set(value, copy2);
-    return copy2;
-  }
-  if (value instanceof Date) {
-    const copy2 = new Date(value.getTime());
-    seen.set(value, copy2);
-    return copy2;
-  }
-  if (Array.isArray(value)) {
-    const copy2 = [];
-    seen.set(value, copy2);
-    for (let i = 0; i < value.length; i++) {
-      copy2[i] = clone(value[i], seen);
-    }
-    return copy2;
-  }
-  const copy = Object.create(Object.getPrototypeOf(value));
-  seen.set(value, copy);
-  const source = value;
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor?.enumerable !== true) continue;
-    copy[key] = clone(source[key], seen);
-  }
-  return copy;
-}
+import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, m as mergeDeep, f as fixStructuralDefaults, d as deriveDefaultWalk, a as getFieldMetaListForSchema } from './attaform-dev.BgM6FdtA.mjs';
+import { p as getAtPath, q as humanize, h as useAbstractForm } from './attaform-dev.DHuydLAC.mjs';
+import { c as callConsumerSchemaFn } from './attaform-dev.ButTkwHd.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.A-TpJW0B.mjs';
 
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
@@ -171,6 +121,8 @@ function getRecordValueType(schema) {
   const def = readDef(schema);
   return def?.valueType;
 }
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
 function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
@@ -211,6 +163,10 @@ function unwrapEffectsSource(schema) {
   const def = readDef(schema);
   return def?.schema;
 }
+function getEffect(schema) {
+  const def = readDef(schema);
+  return def?.effect;
+}
 function getEffectsKind(schema) {
   const def = readDef(schema);
   const type = def?.effect?.type;
@@ -234,12 +190,18 @@ function isAsyncEffect(schema) {
   return fn.constructor.name === "AsyncFunction";
 }
 function containsAsyncRefine(schema, seen) {
-  return walkForAsync(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
+  return walkForTarget(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
+}
+function containsMapOrSet(schema, seen) {
+  return walkForTarget(schema, "map-or-set", /* @__PURE__ */ new WeakSet());
+}
+function containsDiscriminatedUnion(schema, seen) {
+  return walkForTarget(schema, "discriminated-union", seen ?? /* @__PURE__ */ new WeakSet());
 }
 function containsAsyncTransform(schema, seen) {
-  return walkForAsync(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
+  return walkForTarget(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
 }
-function walkForAsync(schema, target, visited) {
+function walkForTarget(schema, target, visited) {
   const candidate = schema;
   if (typeof candidate !== "object" || candidate === null) return false;
   if (visited.has(candidate)) return false;
@@ -251,66 +213,77 @@ function walkForAsync(schema, target, visited) {
       return true;
     }
     const inner = unwrapEffectsSource(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodReadonly")) {
     const inner = unwrapInner(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodBranded")) {
     const inner = unwrapBranded(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodLazy")) {
     const inner = unwrapLazy(schema);
-    return inner !== void 0 && walkForAsync(inner, target, visited);
+    return inner !== void 0 && walkForTarget(inner, target, visited);
   }
   if (isZodSchemaType(schema, "ZodPipeline")) {
     const inSide = unwrapPipeIn(schema);
-    if (inSide !== void 0 && walkForAsync(inSide, target, visited)) return true;
+    if (inSide !== void 0 && walkForTarget(inSide, target, visited)) return true;
     const outSide = unwrapPipeOut(schema);
-    if (outSide !== void 0 && walkForAsync(outSide, target, visited)) return true;
+    if (outSide !== void 0 && walkForTarget(outSide, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodObject")) {
     for (const sub of Object.values(getObjectShape(schema))) {
-      if (walkForAsync(sub, target, visited)) return true;
+      if (walkForTarget(sub, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodArray")) {
     const elem = getArrayElement(schema);
-    return elem !== void 0 && walkForAsync(elem, target, visited);
+    return elem !== void 0 && walkForTarget(elem, target, visited);
   }
   if (isZodSchemaType(schema, "ZodTuple")) {
     for (const it of getTupleItems(schema)) {
-      if (walkForAsync(it, target, visited)) return true;
+      if (walkForTarget(it, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    if (target === "discriminated-union" && isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+      return true;
+    }
     for (const opt of getUnionOptions(schema)) {
-      if (walkForAsync(opt, target, visited)) return true;
+      if (walkForTarget(opt, target, visited)) return true;
     }
     return false;
   }
   if (isZodSchemaType(schema, "ZodIntersection")) {
     const left = getIntersectionLeft(schema);
-    if (left !== void 0 && walkForAsync(left, target, visited)) return true;
+    if (left !== void 0 && walkForTarget(left, target, visited)) return true;
     const right = getIntersectionRight(schema);
-    if (right !== void 0 && walkForAsync(right, target, visited)) return true;
+    if (right !== void 0 && walkForTarget(right, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodRecord")) {
     const keyType = getRecordKeyType(schema);
-    if (keyType !== void 0 && walkForAsync(keyType, target, visited)) return true;
+    if (keyType !== void 0 && walkForTarget(keyType, target, visited)) return true;
     const valueType = getRecordValueType(schema);
-    if (valueType !== void 0 && walkForAsync(valueType, target, visited)) return true;
+    if (valueType !== void 0 && walkForTarget(valueType, target, visited)) return true;
     return false;
   }
   if (isZodSchemaType(schema, "ZodSet")) {
+    if (target === "map-or-set") return true;
     const elem = getSetValueType(schema);
-    return elem !== void 0 && walkForAsync(elem, target, visited);
+    return elem !== void 0 && walkForTarget(elem, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodMap")) {
+    if (target === "map-or-set") return true;
+    const keyType = getMapKeyType(schema);
+    if (keyType !== void 0 && walkForTarget(keyType, target, visited)) return true;
+    const valueType = getMapValueType(schema);
+    return valueType !== void 0 && walkForTarget(valueType, target, visited);
   }
   return false;
 }
@@ -326,11 +299,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  try {
-    return getter();
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(() => getter(), void 0, "lazy-getter");
 }
 function getLazyGetter(schema) {
   const def = readDef(schema);
@@ -347,35 +316,26 @@ function getNativeEnumValues(schema) {
   const def = readDef(schema);
   return def?.values;
 }
-function getDefaultValue$1(schema) {
+function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  try {
-    return thunk();
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(() => thunk(), void 0, "default-factory");
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  try {
-    return cv({ error: null, input: void 0 });
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(
+    () => cv({ error: null, input: void 0 }),
+    void 0,
+    "catch-factory"
+  );
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
   return typeof def?.catchValue === "function";
 }
-function hasChecks(schema) {
-  const def = readDef(schema);
-  const checks = def?.checks;
-  return Array.isArray(checks) && checks.length > 0;
-}
 function hasContainerOrRootRefine(schema, seen) {
   const visited = seen ?? /* @__PURE__ */ new WeakSet();
   const candidate = schema;
@@ -471,10 +431,124 @@ function isContainerAfterWrapperPeel(schema) {
   return isZodSchemaType(cur, "ZodObject") || isZodSchemaType(cur, "ZodArray") || isZodSchemaType(cur, "ZodTuple") || isZodSchemaType(cur, "ZodIntersection") || isZodSchemaType(cur, "ZodUnion") || isZodSchemaType(cur, "ZodDiscriminatedUnion") || isZodSchemaType(cur, "ZodRecord") || isZodSchemaType(cur, "ZodSet");
 }
 
+const V3_INTROSPECTOR = {
+  kindOf: (schema) => kindOf(schema),
+  getObjectShape,
+  getTupleItems,
+  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
+  getDiscriminator,
+  getLiteralValues,
+  isPreprocessNode,
+  isCoercePrimitive,
+  containsAsyncRefine,
+  containsAsyncTransform,
+  containsDiscriminatedUnion,
+  hasContainerOrRootRefine,
+  // Walker accessors (D2 / D3 / D5).
+  getArrayElement,
+  getSetValueType,
+  getRecordKeyType,
+  getRecordValueType,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
+  getUnionOptions,
+  getIntersectionLeft,
+  getIntersectionRight,
+  getEnumValues: (schema) => {
+    if (!isZodSchemaType(schema, "ZodEnum")) return [];
+    return schema.options;
+  },
+  getNativeEnumValues,
+  unwrapInner,
+  unwrapBranded,
+  unwrapEffectsSource,
+  unwrapPipeIn,
+  unwrapPipeOut,
+  unwrapLazy,
+  getLazyGetter,
+  getDefaultValue,
+  getCatchDefault,
+  hasCatchValue
+};
+
+function mapKeyAt(value, index) {
+  if (!(value instanceof Map)) return void 0;
+  if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return void 0;
+  let i = 0;
+  for (const key of value.keys()) {
+    if (i === index) return key;
+    i += 1;
+  }
+  return void 0;
+}
+function stepSchema(schema, segment, maxRecursionDepth) {
+  if (schema === void 0) return void 0;
+  return walkPathSegments(schema, [String(segment)], V3_INTROSPECTOR, maxRecursionDepth, 0)[0];
+}
+function normalizeIssuePaths(issues, rootSchema, data, maxRecursionDepth, peel) {
+  let out = null;
+  for (let i = 0; i < issues.length; i++) {
+    const issue = issues[i];
+    const next = normalizeOne(issue.path, rootSchema, data, maxRecursionDepth, peel);
+    if (next === null) continue;
+    out ?? (out = [...issues]);
+    out[i] = { ...issue, path: next };
+  }
+  return out ?? issues;
+}
+function normalizeOne(path, rootSchema, data, maxRecursionDepth, peel) {
+  const out = [];
+  let schema = rootSchema;
+  let value = data;
+  let changed = false;
+  let i = 0;
+  while (i < path.length) {
+    const peeled = schema === void 0 ? void 0 : peel(schema);
+    const kind = peeled === void 0 ? void 0 : V3_INTROSPECTOR.kindOf(peeled);
+    if (kind === "set") {
+      changed = true;
+      break;
+    }
+    if (kind === "map") {
+      const key = mapKeyAt(value, path[i]);
+      if (key === void 0) {
+        changed = true;
+        break;
+      }
+      if (typeof key !== "string" && typeof key !== "number") {
+        changed = true;
+        break;
+      }
+      out.push(key);
+      value = value.get(key);
+      schema = V3_INTROSPECTOR.getMapValueType(peeled);
+      changed = true;
+      const half = path[i + 1];
+      i += half === "key" || half === "value" ? 2 : 1;
+      continue;
+    }
+    const segment = path[i];
+    out.push(segment);
+    value = getAtPath(value, [segment]);
+    schema = stepSchema(schema, segment, maxRecursionDepth);
+    i += 1;
+  }
+  return changed ? out : null;
+}
+
+function slimPrimitivesV3(schema) {
+  return new Set(slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+}
+
 function rebuildWithDef(original, defPatch) {
-  const node = Object.create(Object.getPrototypeOf(original));
-  node._def = { ...original._def, ...defPatch };
-  return node;
+  return Object.create(Object.getPrototypeOf(original), {
+    _def: {
+      value: { ...original._def, ...defPatch },
+      writable: true,
+      enumerable: true,
+      configurable: true
+    }
+  });
 }
 function rebuildObject(original, shape) {
   const node = rebuildWithDef(original, { shape: () => shape, unknownKeys: "strip" });
@@ -516,9 +590,6 @@ function rebuildWrapperInner(original, inner) {
 function rebuildLazy(original, target) {
   return rebuildWithDef(original, { getter: () => target });
 }
-function stripLeafChecks(original) {
-  return rebuildWithDef(original, { checks: [] });
-}
 function rebuildDiscriminatedUnion(original, options) {
   const originalOptions = getDiscriminatedOptions(original);
   const originalMap = getDiscriminatedOptionsMap(original);
@@ -532,141 +603,20 @@ function rebuildDiscriminatedUnion(original, options) {
   }
   return rebuildWithDef(original, { options, optionsMap });
 }
-
-class UnsupportedSchemaError extends AttaformError {
+function rebuildEffects(original, source, effect) {
+  return rebuildWithDef(original, { schema: source, effect });
 }
 
-const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
-function labelPath(path) {
-  return path.length === 0 ? "<root>" : path.join(".");
-}
-function assertSupportedKinds(schema, path = [], lazyGetters = []) {
-  const typeName = getTypeName(schema);
-  if (typeName !== void 0 && UNSUPPORTED_TYPE_NAMES.has(typeName)) {
-    throw new UnsupportedSchemaError(
-      `[attaform/zod-v3] unsupported kind '${typeName}' at '${labelPath(path)}'`
-    );
-  }
-  if (isZodSchemaType(schema, "ZodObject")) {
-    for (const [key, sub] of Object.entries(getObjectShape(schema))) {
-      assertSupportedKinds(sub, [...path, key], lazyGetters);
-    }
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodArray")) {
-    const inner = getArrayElement(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodSet")) {
-    const inner = getSetValueType(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodRecord")) {
-    const inner = getRecordValueType(schema);
-    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodTuple")) {
-    const items = getTupleItems(schema);
-    items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodUnion")) {
-    const options = getUnionOptions(schema);
-    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
-    const options = getDiscriminatedOptions(schema);
-    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodIntersection")) {
-    const left = getIntersectionLeft(schema);
-    if (left) assertSupportedKinds(left, [...path, "left"], lazyGetters);
-    const right = getIntersectionRight(schema);
-    if (right) assertSupportedKinds(right, [...path, "right"], lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch")) {
-    const inner = unwrapInner(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodBranded")) {
-    const inner = unwrapBranded(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodEffects")) {
-    const inner = unwrapEffectsSource(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodPipeline")) {
-    const inner = unwrapPipeIn(schema);
-    if (inner) assertSupportedKinds(inner, path, lazyGetters);
-    return;
-  }
-  if (isZodSchemaType(schema, "ZodLazy")) {
-    const getter = getLazyGetter(schema);
-    if (getter !== void 0 && lazyGetters.includes(getter)) return;
-    const inner = getter?.();
-    if (inner !== void 0) {
-      assertSupportedKinds(
-        inner,
-        path,
-        getter === void 0 ? lazyGetters : [...lazyGetters, getter]
-      );
-    }
-    return;
-  }
+function stripAsyncChecks(schema) {
+  return walkEffects(schema, "strip");
 }
-
-const V3_INTROSPECTOR = {
-  kindOf: (schema) => kindOf(schema),
-  getObjectShape,
-  getTupleItems,
-  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
-  getDiscriminator,
-  getLiteralValues,
-  isPreprocessNode,
-  isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  hasContainerOrRootRefine,
-  // Walker accessors (D2 / D3 / D5).
-  getArrayElement,
-  getSetValueType,
-  getRecordKeyType,
-  getRecordValueType,
-  getUnionOptions,
-  getIntersectionLeft,
-  getIntersectionRight,
-  getEnumValues: (schema) => {
-    if (!isZodSchemaType(schema, "ZodEnum")) return [];
-    return schema.options;
-  },
-  getNativeEnumValues,
-  unwrapInner,
-  unwrapBranded,
-  unwrapEffectsSource,
-  unwrapPipeIn,
-  unwrapPipeOut,
-  unwrapLazy,
-  getLazyGetter,
-  getDefaultValue: getDefaultValue$1,
-  getCatchDefault,
-  hasCatchValue
-};
-
-function slimPrimitivesV3(schema) {
-  return new Set(slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+function wrapAsyncSafeRefinements(schema) {
+  return walkEffects(schema, "wrap");
 }
-
-function stripAsyncChecks(schema) {
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function walkEffects(schema, policy) {
   const seen = /* @__PURE__ */ new WeakSet();
   function recurse(s) {
     const candidate = s;
@@ -675,7 +625,26 @@ function stripAsyncChecks(schema) {
     seen.add(candidate);
     if (isZodSchemaType(s, "ZodEffects")) {
       const inner = unwrapEffectsSource(s);
-      return inner === void 0 ? s : recurse(inner);
+      if (inner === void 0) return s;
+      if (policy === "strip") return recurse(inner);
+      const effect = getEffect(s);
+      const rebuiltInner = recurse(inner);
+      const original = effect?.["refinement"];
+      if (effect === void 0 || typeof original !== "function") {
+        return rebuildEffects(s, rebuiltInner, effect);
+      }
+      const refine = original;
+      const safeEffect = {
+        ...effect,
+        refinement: (value, ctx) => {
+          const result = refine(value, ctx);
+          if (isThenable(result)) {
+            void result.catch(() => void 0);
+          }
+          return result;
+        }
+      };
+      return rebuildEffects(s, rebuiltInner, safeEffect);
     }
     if (isZodSchemaType(s, "ZodOptional")) {
       const inner = unwrapInner(s);
@@ -688,7 +657,7 @@ function stripAsyncChecks(schema) {
     if (isZodSchemaType(s, "ZodDefault")) {
       const inner = unwrapInner(s);
       if (inner === void 0) return s;
-      const def = getDefaultValue$1(s);
+      const def = getDefaultValue(s);
       return recurse(inner).default(def);
     }
     if (isZodSchemaType(s, "ZodCatch")) {
@@ -821,41 +790,20 @@ function carryObjectChecks(rebuilt, original) {
   return next;
 }
 
-const PATH_SEPARATOR = ".";
 const MAX_UNWRAP_STEPS = 64;
-function isPrimitive(input) {
-  const type = typeof input;
-  if (type === "string" || type === "number" || type === "boolean" || type === "bigint" || type === "undefined")
-    return true;
-  return input === null;
-}
-function constraintsAreSlimValid(slimSchema, constraints) {
-  try {
-    return slimSchema.safeParse(constraints).success;
-  } catch {
-    return false;
-  }
-}
 let warnedZodCodeMissing = false;
 function zodAdapter(zodSchema) {
-  assertSupportedKinds(zodSchema);
-  const [_strippedRoot] = stripRootSchema(zodSchema, {
-    stripDefaultValues: true,
-    stripNullable: true,
-    stripOptional: true,
-    stripZodEffects: true,
-    stripZodRefinements: true
-  });
-  if (!isZodSchemaType(_strippedRoot, "ZodObject") && !isZodSchemaType(_strippedRoot, "ZodRecord") && !isZodSchemaType(_strippedRoot, "ZodDiscriminatedUnion")) {
-    const name = getTypeName(_strippedRoot);
-    throw new Error(
-      `Attaform: useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got ${name}). Wrap other shapes under a key.`
+  const peeledRoot = peelAllV3Wrappers(zodSchema);
+  if (!isZodSchemaType(peeledRoot, "ZodObject") && !isZodSchemaType(peeledRoot, "ZodRecord") && !isZodSchemaType(peeledRoot, "ZodDiscriminatedUnion")) {
+    const name = getTypeName(peeledRoot) ?? "unknown";
+    throw new AttaformError(
+      `[attaform/zod-v3] useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got '${name}'). Wrap other shapes under a key.` 
     );
   }
   return (formKey, options) => createAbstractSchema(
     zodSchema,
     V3_INTROSPECTOR,
-    buildV3Services(),
+    buildV3Services(options.maxRecursionDepth),
     formKey,
     options
   );
@@ -864,46 +812,67 @@ async function lazyFingerprint(schema) {
   const { fingerprintZodSchema } = await import('../chunks/fingerprint.mjs');
   return fingerprintZodSchema(schema);
 }
-function buildV3Services() {
+const syncSafeCache = /* @__PURE__ */ new WeakMap();
+function syncSafe(schema) {
+  const cached = syncSafeCache.get(schema);
+  if (cached !== void 0) return cached;
+  const wrapped = wrapAsyncSafeRefinements(schema);
+  syncSafeCache.set(schema, wrapped);
+  return wrapped;
+}
+function buildV3Services(maxRecursionDepth) {
+  const mapOrSetBySchema = /* @__PURE__ */ new WeakMap();
+  const refileIssues = (schema, data, issues) => {
+    let hasMapOrSet = mapOrSetBySchema.get(schema);
+    if (hasMapOrSet === void 0) {
+      hasMapOrSet = containsMapOrSet(schema);
+      mapOrSetBySchema.set(schema, hasMapOrSet);
+    }
+    if (!hasMapOrSet) return issues;
+    return normalizeIssuePaths(issues, schema, data, maxRecursionDepth, peelAllV3Wrappers);
+  };
   return {
     fingerprint: (schema) => lazyFingerprint(schema),
-    getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    getNestedSchemasAtPath: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     // v3 pre-strips refinements / defaults / wrappers off the root for
     // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
     // `getSchemasAtPath` both consume this variant so the yielded
     // candidates reflect the slim shape.
-    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedSchemasInSlimModeV3(schema, path, maxRecursionDepth),
+    // The slim-root projection is gone (size-teardown P7): the shared
+    // path walker peels wrappers / effects inline, so the slim and
+    // unstripped walks coincide — same aliasing v4 always had.
+    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
     deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
-    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth),
+    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth2) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth2),
     unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
     isLeafRequired: (schema) => isLeafRequiredV3(schema),
-    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth),
-    issuesToValidationErrors: (issues, formKey) => zodIssuesToValidationErrors(issues, formKey),
+    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth2) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth2),
+    issuesToValidationErrors: (issues) => zodIssuesToValidationErrors(issues),
     safeParseSync: (schema, data) => {
-      const result = schema.safeParse(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+      const result = syncSafe(schema).safeParse(data);
+      return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
     safeParseAsync: async (schema, data) => {
       const result = await schema.safeParseAsync(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+      return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
     // v3 returns the full recursive AbstractSchema for sub-schemas (the
     // historical shape) — `getSchemasAtPath` consumers may probe any
     // method on the result. The factory call rebuilds the full surface
     // against the sub-schema with its own per-form caches.
-    makeSubSchema: (sub, formKey, maxRecursionDepth) => createAbstractSchema(
+    makeSubSchema: (sub, formKey, maxRecursionDepth2) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
-      buildV3Services(),
+      buildV3Services(maxRecursionDepth2),
       formKey,
-      { maxRecursionDepth }
+      { maxRecursionDepth: maxRecursionDepth2 }
     )
   };
 }
-function zodIssuesToValidationErrors(issues, formKey) {
+function zodIssuesToValidationErrors(issues) {
   const validationErrors = [];
   for (const issue of issues) {
     let code;
@@ -911,7 +880,7 @@ function zodIssuesToValidationErrors(issues, formKey) {
       code = `zod:${issue.code}`;
     } else {
       code = "zod:unknown";
-      if (__DEV__ && !warnedZodCodeMissing) {
+      if (!warnedZodCodeMissing) {
         warnedZodCodeMissing = true;
         console.warn(
           "[attaform] zod-v3 adapter received an issue with no string `code`; stamping `'zod:unknown'`. This usually means a custom Zod plugin emitted an issue without the standard code field."
@@ -932,7 +901,6 @@ function zodIssuesToValidationErrors(issues, formKey) {
       // to absolutise, then routes form-level (absolute path length 0)
       // entries to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
-      formKey,
       code
     });
   }
@@ -1092,271 +1060,6 @@ function unwrapToDiscriminatedUnion(schema, depth = 0) {
   }
   return void 0;
 }
-function getDefaultValue(expected, context) {
-  const discriminatorContext = context.discriminator;
-  if (discriminatorContext.isDiscriminatorKey) {
-    if (!discriminatorContext.schema) {
-      throw new Error("discriminatorContext.schema unspecified");
-    }
-    if (!isZodSchemaType(discriminatorContext.schema, "ZodDiscriminatedUnion")) {
-      throw new TypeError(
-        "Programming error: discriminatorContext.schema is not a ZodDiscriminatedUnion schema."
-      );
-    }
-    const optionDiscriminator = getSchemaByDiscriminatorKey(
-      discriminatorContext.schema);
-    if (!optionDiscriminator) {
-      throw new Error("ZodDiscriminatedUnion: default option not found");
-    }
-    return getDefaultValuesFromZodSchema(
-      optionDiscriminator,
-      discriminatorContext.useDefaultSchemaValues,
-      context.formKey
-    );
-  }
-  if (expected === "string") return "";
-  if (expected === "number") return 0;
-  if (expected === "array") return [];
-  if (expected === "boolean") return false;
-  if (expected === "bigint") return 0n;
-  if (expected === "float") return 0;
-  if (expected === "integer") return 0;
-  if (expected === "null") return null;
-  if (expected === "object") return {};
-  if (expected === "set") return /* @__PURE__ */ new Set();
-  if (expected === "date") return /* @__PURE__ */ new Date();
-  if (expected === "undefined") return void 0;
-  if (expected === "unknown") return void 0;
-  if (expected === "nan") return Number("nan");
-  return void 0;
-}
-function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
-    unsupportedKindFallback: (schema) => {
-      console.warn(
-        `[attaform] zod-v3 adapter: unsupported schema kind '${schema.constructor?.name ?? "unknown"}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.`
-      );
-      return null;
-    },
-    // v3 historically surfaces the `.catch(v)` fallback even when
-    // `useDefaultSchemaValues=false`. Pinned by
-    // `test/adapters/zod-v3/wrappers.test.ts` ('surfaces the catch
-    // fallback even when useDefaultSchemaValues is false').
-    catchOnUseDefaultFalse: "preserveCatch"
-  });
-}
-function getSchemaByDiscriminatorKey(unionSchema, key) {
-  if (!isZodSchemaType(unionSchema, "ZodDiscriminatedUnion")) {
-    throw new TypeError("Provided schema is not a discriminated union.");
-  }
-  {
-    const options = getDiscriminatedOptions(unionSchema);
-    if (!options.length) {
-      throw new TypeError("Provided ZodDiscriminatedUnion does not have any options");
-    }
-    return options[0];
-  }
-}
-function stripRefinements(schema) {
-  function _stripRefinements(_schema, depth) {
-    if (depth >= MAX_UNWRAP_STEPS) return _schema;
-    if (isZodSchemaType(_schema, "ZodString") && hasChecks(_schema)) {
-      return stripLeafChecks(_schema);
-    }
-    if (isZodSchemaType(_schema, "ZodNumber") && hasChecks(_schema)) {
-      return stripLeafChecks(_schema);
-    }
-    if (isZodSchemaType(_schema, "ZodArray")) {
-      const inner = getArrayElement(_schema);
-      if (!inner) return _schema;
-      return rebuildArray(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodObject")) {
-      const strippedShape = Object.fromEntries(
-        Object.entries(getObjectShape(_schema)).map(([key, value]) => [
-          key,
-          _stripRefinements(value, depth + 1)
-        ])
-      );
-      return rebuildObject(_schema, strippedShape);
-    }
-    if (isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodOptional")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodNullable")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return rebuildWrapperInner(_schema, _stripRefinements(inner, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodReadonly")) {
-      const inner = unwrapInner(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodBranded")) {
-      const inner = unwrapBranded(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodPipeline")) {
-      const inner = unwrapPipeIn(_schema);
-      if (!inner) return _schema;
-      return _stripRefinements(inner, depth + 1);
-    }
-    if (isZodSchemaType(_schema, "ZodSet")) {
-      const valueType = getSetValueType(_schema);
-      if (!valueType) return _schema;
-      return rebuildSet(_schema, _stripRefinements(valueType, depth + 1));
-    }
-    if (isZodSchemaType(_schema, "ZodTuple")) {
-      const items = getTupleItems(_schema);
-      if (items.length === 0) return _schema;
-      const stripped = items.map((it) => _stripRefinements(it, depth + 1));
-      return rebuildTuple(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodRecord")) {
-      const valueType = getRecordValueType(_schema);
-      if (!valueType) return _schema;
-      const value = _stripRefinements(valueType, depth + 1);
-      const keyType = getRecordKeyType(_schema);
-      if (keyType) {
-        return rebuildRecord(_schema, value, keyType);
-      }
-      return rebuildRecord(_schema, value);
-    }
-    if (isZodSchemaType(_schema, "ZodUnion")) {
-      const options = getUnionOptions(_schema);
-      if (options.length === 0) return _schema;
-      const stripped = options.map((o) => _stripRefinements(o, depth + 1));
-      return rebuildUnion(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
-      const discKey = getDiscriminator(_schema);
-      const options = getDiscriminatedOptions(_schema);
-      if (discKey === void 0 || options.length === 0) return _schema;
-      const stripped = options.map(
-        (o) => _stripRefinements(o, depth + 1)
-      );
-      return rebuildDiscriminatedUnion(_schema, stripped);
-    }
-    if (isZodSchemaType(_schema, "ZodIntersection")) {
-      const left = getIntersectionLeft(_schema);
-      const right = getIntersectionRight(_schema);
-      if (!left || !right) return _schema;
-      return rebuildIntersection(
-        _schema,
-        _stripRefinements(left, depth + 1),
-        _stripRefinements(right, depth + 1)
-      );
-    }
-    if (isZodSchemaType(_schema, "ZodLazy")) {
-      const inner = unwrapLazy(_schema);
-      if (!inner) return _schema;
-      const stripped = _stripRefinements(inner, depth + 1);
-      return rebuildLazy(_schema, stripped);
-    }
-    return _schema;
-  }
-  return _stripRefinements(schema, 0);
-}
-function stripRootSchema(schema, stripConfig) {
-  function recursion(_schema, _stripped = false) {
-    if (getStripInstruction(stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
-      return recursion(_schema.unwrap(), true);
-    }
-    if (getStripInstruction(stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
-      return recursion(_schema.unwrap(), true);
-    }
-    if (getStripInstruction(stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (inner) return recursion(inner, true);
-    }
-    if (getStripInstruction(stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return recursion(inner, true);
-    }
-    if (getStripInstruction(stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
-      return recursion(stripRefinements(_schema));
-    }
-    return [_schema, _stripped];
-  }
-  return recursion(schema, false);
-}
-const getStripInstruction = (stripValueOrCallback, schema) => {
-  if (stripValueOrCallback === void 0 || stripValueOrCallback === false) return false;
-  return typeof stripValueOrCallback === "function" ? stripValueOrCallback(schema) : stripValueOrCallback;
-};
-function getSlimSchema(config) {
-  function _getSlimSchema(_schema) {
-    if (isZodSchemaType(_schema, "ZodObject")) {
-      const newShape = {};
-      for (const [key, value] of Object.entries(getObjectShape(_schema))) {
-        newShape[key] = _getSlimSchema(value);
-      }
-      return rebuildObject(_schema, newShape);
-    }
-    if (isZodSchemaType(_schema, "ZodArray")) {
-      const inner = getArrayElement(_schema);
-      if (!inner) return _schema;
-      return rebuildArray(_schema, _getSlimSchema(inner));
-    }
-    if (isZodSchemaType(_schema, "ZodRecord")) {
-      const keyType = getRecordKeyType(_schema);
-      const valueType = getRecordValueType(_schema);
-      if (!keyType || !valueType) return _schema;
-      const key = _getSlimSchema(keyType);
-      const value = _getSlimSchema(valueType);
-      return rebuildRecord(_schema, value, key);
-    }
-    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
-      const slimmedSchemas = [];
-      const discKey = getDiscriminator(_schema);
-      if (discKey === void 0) return _schema;
-      for (const option of getDiscriminatedOptions(_schema)) {
-        const slimmedSchema = _getSlimSchema(option);
-        const deepCloneSlimmedSchema = cloneSchemaDeep(slimmedSchema);
-        slimmedSchemas.push(deepCloneSlimmedSchema);
-      }
-      return rebuildDiscriminatedUnion(
-        _schema,
-        slimmedSchemas
-      );
-    }
-    if (getStripInstruction(config.stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    if (getStripInstruction(config.stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
-      return stripRefinements(_schema);
-    }
-    if (getStripInstruction(config.stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
-      const inner = unwrapInner(_schema);
-      if (inner) return _getSlimSchema(inner);
-    }
-    const unionSchema = unwrapToDiscriminatedUnion(_schema);
-    if (unionSchema && getStripInstruction(config.stripConfig.stripDefaultValues, unionSchema)) {
-      return _getSlimSchema(unionSchema);
-    }
-    return _schema;
-  }
-  const processedRootSchema = stripRootSchema(config.schema, config.stripConfig)[0];
-  return _getSlimSchema(processedRootSchema);
-}
 function peelAllV3Wrappers(schema) {
   let current = schema;
   for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
@@ -1383,6 +1086,17 @@ function peelAllV3Wrappers(schema) {
   }
   return current;
 }
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
+  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
+    unsupportedKindFallback: (schema) => {
+      const kindName = schema.constructor?.name ?? "unknown";
+      console.warn(
+        `[attaform] zod-v3 adapter: unsupported schema kind '${kindName}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.` 
+      );
+      return null;
+    }
+  });
+}
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
   const target = path.length === 0 ? rootSchema : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth)[0];
@@ -1394,14 +1108,14 @@ function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
       meta: Object.freeze({})
     };
   }
-  const pathMap = getFieldMetaPathMap(rootSchema, {
+  const pathMap = buildFieldMetaPathMap(rootSchema, {
     intro: V3_INTROSPECTOR,
     peelAllWrappers: peelAllV3Wrappers,
-    getFieldMetaList
+    getFieldMetaList: getFieldMetaListForSchema
   });
   const pathKey = canonicalizePath(path).key;
   const peeled = peelV3Wrappers(target);
-  const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
+  const payload = pathMap?.get(pathKey) ?? getFieldMetaForSchema(target) ?? (peeled !== target ? getFieldMetaForSchema(peeled) : void 0);
   const targetDescription = typeof target.description === "string" ? target.description : void 0;
   const peeledDescription = peeled !== target && typeof peeled.description === "string" ? peeled.description : void 0;
   const schemaDescription = targetDescription ?? peeledDescription;
@@ -1418,24 +1132,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
     config.useDefaultSchemaValues,
     formKey
   );
-  const slimSchema = getSlimSchema({
-    schema: rootSchema,
-    stripConfig: {
-      stripZodEffects: true,
-      stripDefaultValues: true,
-      // `strict: false` strips refinements (so empty defaults pass);
-      // strict keeps them so the slim parse below surfaces refinement
-      // errors. Async refines are guarded by the try/catch — they
-      // can't be surfaced synchronously regardless.
-      stripZodRefinements: (config.strict ?? true) === false
-    }
-  });
-  let rawDefaultValues = defaultValuesWithoutConstraints;
-  if (!isPrimitive(rawDefaultValues)) {
-    rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
-  } else if (constraintsAreSlimValid(slimSchema, config.constraints)) {
-    rawDefaultValues = config.constraints;
-  }
+  const rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
   if ((config.strict ?? true) !== false) {
     if (containsAsyncTransform(rootSchema)) {
       return {
@@ -1446,7 +1143,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       };
     }
     try {
-      const strictResult = rootSchema.safeParse(rawDefaultValues);
+      const strictResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
       if (strictResult.success) {
         return {
           data: rawDefaultValues,
@@ -1457,7 +1154,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       }
       return {
         data: rawDefaultValues,
-        errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+        errors: zodIssuesToValidationErrors(strictResult.error.issues),
         success: false,
         formKey
       };
@@ -1465,7 +1162,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       const isAsyncDetect = err instanceof Error && err.message.includes("Async refinement encountered");
       if (isAsyncDetect) {
         try {
-          const strippedResult = stripAsyncChecks(rootSchema).safeParse(rawDefaultValues);
+          const strippedResult = syncSafe(stripAsyncChecks(rootSchema)).safeParse(rawDefaultValues);
           if (strippedResult.success) {
             return {
               data: rawDefaultValues,
@@ -1476,7 +1173,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
           }
           return {
             data: rawDefaultValues,
-            errors: zodIssuesToValidationErrors(strippedResult.error.issues, formKey),
+            errors: zodIssuesToValidationErrors(strippedResult.error.issues),
             success: false,
             formKey
           };
@@ -1497,119 +1194,25 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       };
     }
   }
-  let parseResult;
-  try {
-    parseResult = slimSchema.safeParse(rawDefaultValues);
-  } catch {
-    return {
-      data: rawDefaultValues,
-      errors: void 0,
-      success: true,
-      formKey
-    };
-  }
-  const { data, success, error } = parseResult;
-  if (success) {
-    return {
-      data,
-      errors: void 0,
-      success,
-      formKey
-    };
-  }
-  let fixedData = {};
-  for (const issue of error.issues) {
-    const schemasAtPath = getNestedZodSchemasAtPath(slimSchema, issue.path, maxRecursionDepth);
-    const path = coercePathSegments(issue.path);
-    if (!schemasAtPath.length) {
-      console.error(
-        `[attaform] zod-v3 adapter: no schema at path '${path.join(PATH_SEPARATOR)}' for key '${formKey}'. Skipping the issue. (This is a library-internal invariant \u2014 please file a bug.)`
-      );
-      continue;
-    }
-    const candidate = schemasAtPath[0];
-    if (candidate !== void 0) {
-      const valueAtPath = getAtPath(rawDefaultValues, path);
-      const slimKinds = slimPrimitivesV3(candidate);
-      if (slimKinds.size > 0 && slimKinds.has(slimKindOf(valueAtPath))) {
-        continue;
-      }
-    }
-    for (const schemaAtPath of schemasAtPath) {
-      if (issue.code === "invalid_type") {
-        const isDiscriminatedUnion = isZodSchemaType(schemaAtPath, "ZodDiscriminatedUnion");
-        const defaultValueContext = isDiscriminatedUnion ? {
-          formKey,
-          discriminator: {
-            isDiscriminatorKey: true,
-            schema: schemaAtPath,
-            useDefaultSchemaValues: false
-          }
-        } : {
-          formKey,
-          discriminator: {
-            isDiscriminatorKey: false,
-            schema: void 0,
-            useDefaultSchemaValues: false
-          }
-        };
-        const defaultValue = getDefaultValue(issue.expected, defaultValueContext);
-        fixedData = setAtPath(fixedData, path, defaultValue);
-        continue;
-      }
-      const peeled = peelEmbeddedDefault(schemaAtPath, V3_INTROSPECTOR);
-      if (peeled !== NO_EMBEDDED_DEFAULT) {
-        fixedData = setAtPath(fixedData, path, peeled);
-        continue;
-      }
-      const ctx = {
-        formKey,
-        discriminator: {
-          isDiscriminatorKey: false,
-          schema: void 0,
-          useDefaultSchemaValues: false
-        }
-      };
-      const slimKinds = slimPrimitivesV3(schemaAtPath);
-      const firstKind = [...slimKinds][0];
-      if (firstKind !== void 0) {
-        const expected = firstKind === "string" ? "string" : firstKind === "number" ? "number" : firstKind === "boolean" ? "boolean" : firstKind === "bigint" ? "bigint" : firstKind === "date" ? "date" : firstKind === "array" ? "array" : firstKind === "object" ? "object" : null;
-        if (expected !== null) {
-          fixedData = setAtPath(fixedData, path, getDefaultValue(expected, ctx));
-        }
-      }
+  const fixed = fixStructuralDefaults(
+    rootSchema,
+    rawDefaultValues,
+    config.useDefaultSchemaValues,
+    maxRecursionDepth,
+    {
+      intro: V3_INTROSPECTOR,
+      slimPrimitivesOf: (s) => slimPrimitivesV3(s),
+      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault, formKey),
+      unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
-  }
-  fixedData = mergeDeep(rawDefaultValues, fixedData);
-  const secondParse = slimSchema.safeParse(fixedData);
-  const finalData = secondParse.success ? secondParse.data : fixedData;
+  );
   return {
-    data: finalData,
+    data: fixed.data,
     errors: void 0,
     success: true,
     formKey
   };
 }
-const slimRootCacheV3 = /* @__PURE__ */ new WeakMap();
-function getSlimRootV3(rootSchema) {
-  const cached = slimRootCacheV3.get(rootSchema);
-  if (cached !== void 0) return cached;
-  const [strippedSchema] = stripRootSchema(rootSchema, {
-    stripDefaultValues: true,
-    stripNullable: true,
-    stripOptional: true,
-    stripZodEffects: true
-  });
-  const slimSchema = getSlimSchema({
-    schema: strippedSchema,
-    stripConfig: { stripDefaultValues: true, stripZodEffects: true }
-  });
-  slimRootCacheV3.set(rootSchema, slimSchema);
-  return slimSchema;
-}
-function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
-  return getNestedZodSchemasAtPath(getSlimRootV3(rootSchema), path, maxRecursionDepth);
-}
 
 function useForm(configuration) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
@@ -1627,5 +1230,4 @@ function useForm(configuration) {
   });
 }
 
-export { fieldMeta as f, isZodSchemaType as i, useForm as u, withMeta as w, zodAdapter as z };
-//# sourceMappingURL=attaform.B1ZYt2Li.mjs.map
+export { isZodSchemaType as i, useForm as u, zodAdapter as z };