attaform 0.27.6 → 0.28.0

package/dist/{shared/attaform.DMxM2kol.mjs → dev/shared/attaform-dev.oYrkP9dj.mjs}

@@ -1,31 +1,17 @@
-import { r as getAtPath, p as slimKindOf, t as setAtPath, q as humanize, h as useAbstractForm } from './attaform.CKH2lGdL.mjs';
-import { A as AttaformError, _ as __DEV__, f as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.nMaz2C5P.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema, b as getFieldMetaPathMap } from './attaform.CoR4mWfv.mjs';
+import { o as humanize, h as useAbstractForm } from './attaform-dev.WmuhD_CZ.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.Dr2YzS5B.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform-dev.6qxD-Yqo.mjs';
 import { z } from 'zod';
 
-const fieldMeta = fieldMetaStore;
-function getFieldMetaList(schema) {
-  return getFieldMetaListForSchema(schema);
-}
-function withMeta(schema, payload) {
-  const existing = getFieldMetaForSchema(schema) ?? {};
-  const cloned = schema.clone();
-  fieldMetaStore.add(cloned, { ...existing, ...payload });
-  return cloned;
-}
-function getFieldMeta(schema) {
-  return getFieldMetaForSchema(schema);
-}
-
 let warnedZodCodeMissing = false;
-function zodIssuesToValidationErrors(issues, formKey) {
+function zodIssuesToValidationErrors(issues) {
   return issues.map((issue) => {
     let code;
     if (typeof issue.code === "string" && issue.code.length > 0) {
       code = `zod:${issue.code}`;
     } else {
       code = "zod:unknown";
-      if (__DEV__ && !warnedZodCodeMissing) {
+      if (!warnedZodCodeMissing) {
         warnedZodCodeMissing = true;
         console.warn(
           "[attaform] zod-v4 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."
@@ -39,7 +25,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: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
-      formKey,
       code
     };
   });
@@ -51,89 +36,59 @@ function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
   return schema.def;
 }
+const KIND_ALIAS = /* @__PURE__ */ new Map([
+  ["discriminated_union", "discriminated-union"],
+  ["discriminatedUnion", "discriminated-union"],
+  ["prefault", "default"],
+  ["template_literal", "template-literal"],
+  ["templateLiteral", "template-literal"]
+]);
+const IDENTITY_KINDS = /* @__PURE__ */ new Set([
+  "object",
+  "array",
+  "set",
+  "record",
+  "tuple",
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "date",
+  "enum",
+  "literal",
+  "null",
+  "undefined",
+  "any",
+  "unknown",
+  "optional",
+  "nullable",
+  "default",
+  "pipe",
+  "readonly",
+  "nan",
+  "void",
+  "never",
+  "lazy",
+  "intersection",
+  "catch",
+  "promise",
+  "custom",
+  "transform",
+  "file",
+  "map",
+  "symbol",
+  "function"
+]);
 function kindOf(schema) {
   const def = readDef(schema);
   const rawType = def?.type;
   if (rawType === void 0) return "unknown";
-  switch (rawType) {
-    case "object":
-      return "object";
-    case "array":
-      return "array";
-    case "set":
-      return "set";
-    case "record":
-      return "record";
-    case "tuple":
-      return "tuple";
-    case "union":
-      return def?.discriminator !== void 0 ? "discriminated-union" : "union";
-    case "discriminated_union":
-    case "discriminatedUnion":
-      return "discriminated-union";
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "bigint":
-      return "bigint";
-    case "date":
-      return "date";
-    case "enum":
-      return "enum";
-    case "literal":
-      return "literal";
-    case "null":
-      return "null";
-    case "undefined":
-      return "undefined";
-    case "optional":
-      return "optional";
-    case "nullable":
-      return "nullable";
-    case "default":
-    case "prefault":
-      return "default";
-    case "pipe":
-      return "pipe";
-    case "readonly":
-      return "readonly";
-    case "any":
-      return "any";
-    case "nan":
-      return "nan";
-    case "void":
-      return "void";
-    case "never":
-      return "never";
-    case "lazy":
-      return "lazy";
-    case "intersection":
-      return "intersection";
-    case "catch":
-      return "catch";
-    case "transform":
-      return "transform";
-    case "promise":
-      return "promise";
-    case "custom":
-      return "custom";
-    case "template_literal":
-    case "templateLiteral":
-      return "template-literal";
-    case "file":
-      return "file";
-    case "map":
-      return "map";
-    case "symbol":
-      return "symbol";
-    case "function":
-      return "function";
-    default:
-      return "unknown";
+  if (rawType === "union") {
+    return def?.discriminator !== void 0 ? "discriminated-union" : "union";
   }
+  const alias = KIND_ALIAS.get(rawType);
+  if (alias !== void 0) return alias;
+  return IDENTITY_KINDS.has(rawType) ? rawType : "unknown";
 }
 function getObjectShape(schema) {
   const s = schema;
@@ -265,10 +220,22 @@ function assertZodVersion(schema) {
   const def = readDef(schema);
   if (def?.type === void 0) {
     throw new Error(
-      "[attaform/zod-v4] Schema is not a Zod v4 schema. The `attaform/zod-v4` adapter requires zod@^4. Either: (a) install zod@^4 in your project; (b) import from `attaform/zod`, which auto-detects the Zod version (and tree-shakes to a single adapter when the `attaform/vite` plugin is active); or (c) import from `attaform/zod-v3` if you are staying on Zod v3."
+      "[attaform/zod-v4] Schema is not a Zod v4 schema. The `attaform/zod-v4` adapter requires zod@^4. Either: (a) install zod@^4 in your project; (b) import from `attaform/zod`, which auto-detects the Zod version (and tree-shakes to a single adapter when the `attaform/vite` plugin is active); or (c) import from `attaform/zod-v3` if you are staying on Zod v3." 
     );
   }
 }
+const DESCEND_SINGLE = [
+  "innerType",
+  "element",
+  "in",
+  "out",
+  "left",
+  "right",
+  "keyType",
+  "valueType"
+];
+const DESCEND_RECORD = ["shape", "entries"];
+const DESCEND_LIST = ["options", "items"];
 function walkSchemaTree(schema, visit, seen) {
   const visited = seen ?? /* @__PURE__ */ new WeakSet();
   const candidate = schema;
@@ -278,40 +245,25 @@ function walkSchemaTree(schema, visit, seen) {
   if (visit(schema)) return true;
   const def = readDef(schema);
   if (def === void 0) return false;
-  if (def.innerType !== void 0 && walkSchemaTree(def.innerType, visit, visited)) {
-    return true;
-  }
-  if (def.element !== void 0 && walkSchemaTree(def.element, visit, visited)) {
-    return true;
-  }
-  if (def.in !== void 0 && walkSchemaTree(def.in, visit, visited)) return true;
-  if (def.out !== void 0 && walkSchemaTree(def.out, visit, visited)) return true;
-  if (def.left !== void 0 && walkSchemaTree(def.left, visit, visited)) return true;
-  if (def.right !== void 0 && walkSchemaTree(def.right, visit, visited)) return true;
-  if (def.keyType !== void 0 && walkSchemaTree(def.keyType, visit, visited)) {
-    return true;
-  }
-  if (def.valueType !== void 0 && walkSchemaTree(def.valueType, visit, visited)) {
-    return true;
-  }
-  if (def.shape !== void 0) {
-    for (const sub of Object.values(def.shape)) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (def.entries !== void 0) {
-    for (const sub of Object.values(def.entries)) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (def.options !== void 0) {
-    for (const sub of def.options) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
+  const slots = def;
+  for (const key of DESCEND_SINGLE) {
+    const child = slots[key];
+    if (child !== void 0 && walkSchemaTree(child, visit, visited)) return true;
+  }
+  for (const key of DESCEND_RECORD) {
+    const record = slots[key];
+    if (record !== void 0) {
+      for (const sub of Object.values(record)) {
+        if (walkSchemaTree(sub, visit, visited)) return true;
+      }
     }
   }
-  if (def.items !== void 0) {
-    for (const sub of def.items) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
+  for (const key of DESCEND_LIST) {
+    const list = slots[key];
+    if (list !== void 0) {
+      for (const sub of list) {
+        if (walkSchemaTree(sub, visit, visited)) return true;
+      }
     }
   }
   if (typeof def.getter === "function") {
@@ -323,6 +275,9 @@ function walkSchemaTree(schema, visit, seen) {
   }
   return false;
 }
+function containsDiscriminatedUnion(schema, seen) {
+  return walkSchemaTree(schema, (node) => kindOf(node) === "discriminated-union", seen);
+}
 function containsAsyncRefine(schema, seen) {
   return walkSchemaTree(
     schema,
@@ -335,14 +290,25 @@ function containsAsyncRefine(schema, seen) {
     seen
   );
 }
+const CONTAINER_SLOTS = [
+  "shape",
+  "entries",
+  "element",
+  "options",
+  "items",
+  "keyType",
+  "valueType",
+  "left",
+  "right"
+];
 function hasContainerOrRootRefine(schema, seen) {
   return walkSchemaTree(
     schema,
     (node) => {
       const def = readDef(node);
       if (def === void 0) return false;
-      const isContainer = def.shape !== void 0 || def.entries !== void 0 || def.element !== void 0 || def.options !== void 0 || def.items !== void 0 || def.keyType !== void 0 || def.valueType !== void 0 || def.left !== void 0 || def.right !== void 0;
-      if (!isContainer) return false;
+      const slots = def;
+      if (!CONTAINER_SLOTS.some((key) => slots[key] !== void 0)) return false;
       return getChecks(node).length > 0;
     },
     seen
@@ -384,7 +350,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
   const kind = kindOf(schema);
   if (UNSUPPORTED.includes(kind)) {
     throw new UnsupportedSchemaError(
-      `[attaform/zod] unsupported kind '${kind}' at '${labelPath(path)}'`
+      `[attaform/zod] unsupported kind '${kind}' at '${labelPath(path)}'` 
     );
   }
   switch (kind) {
@@ -479,7 +445,9 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
       return;
     default: {
       const _exhaustive = kind;
-      throw new Error(`assertSupportedKinds: unhandled ZodKind '${_exhaustive}'`);
+      throw new Error(
+        `assertSupportedKinds: unhandled ZodKind '${_exhaustive}'` 
+      );
     }
   }
 }
@@ -509,10 +477,6 @@ function unwrapToDiscriminatedUnion(schema) {
   }
   return void 0;
 }
-function getDiscriminatedUnionFirstOption(schema) {
-  const options = getDiscriminatedOptions(schema);
-  return options[0];
-}
 
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
@@ -525,6 +489,7 @@ const V4_INTROSPECTOR = {
   isCoercePrimitive,
   containsAsyncRefine,
   containsAsyncTransform,
+  containsDiscriminatedUnion,
   hasContainerOrRootRefine,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
@@ -555,6 +520,31 @@ function slimPrimitivesOf(schema, maxRecursionDepth) {
   return new Set(slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
 }
 
+function deriveDefault(schema, useDefault, maxRecursionDepth) {
+  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
+    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
+    // unknown kinds genuinely shouldn't appear, so return undefined.
+    unsupportedKindFallback: () => void 0
+  });
+}
+function getDefaultValuesFromZodSchema(opts) {
+  const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
+  const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
+  const merged = mergeDeep(initial, constraints);
+  return fixStructuralDefaults(
+    schema,
+    merged,
+    useDefaultSchemaValues,
+    maxRecursionDepth,
+    {
+      intro: V4_INTROSPECTOR,
+      slimPrimitivesOf: (s) => slimPrimitivesOf(s, maxRecursionDepth),
+      deriveDefault: (s, useDefault) => deriveDefault(s, useDefault, maxRecursionDepth),
+      unwrapToDiscriminatedUnion
+    }
+  );
+}
+
 const PATH_SEPARATOR = ".";
 function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
   if (Array.isArray(path)) {
@@ -571,127 +561,15 @@ function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
   );
 }
 
-function carryChecks(rebuilt, original, stripConfig) {
-  if (stripConfig.stripRefinements === true) return rebuilt;
+function carrySyncChecks(rebuilt, original) {
   if (!hasChecks(original)) return rebuilt;
-  const all = getChecks(original);
-  const checks = stripConfig.shouldKeepCheck === void 0 ? all : all.filter(stripConfig.shouldKeepCheck);
+  const checks = getChecks(original).filter((c) => !isAsyncCheck(c));
   if (checks.length === 0) return rebuilt;
   return rebuilt.check(
     ...checks
   );
 }
-function unhandledZodKind(fnName, kind) {
-  throw new Error(`${fnName}: unhandled ZodKind '${kind}'`);
-}
-function stripRefinements(schema) {
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "string":
-      return hasChecks(schema) ? z.string() : schema;
-    case "number":
-      return hasChecks(schema) ? z.number() : schema;
-    case "bigint":
-      return hasChecks(schema) ? z.bigint() : schema;
-    case "array": {
-      const element = getArrayElement(schema);
-      return z.array(stripRefinements(element));
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return z.set(stripRefinements(valueType));
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(stripRefinements);
-      return z.tuple(items);
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      const next = {};
-      for (const [k, v] of Object.entries(shape)) {
-        next[k] = stripRefinements(v);
-      }
-      return z.object(next);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(
-        schema
-      );
-      const valueType = stripRefinements(getRecordValueType(schema));
-      return z.record(keyType, valueType);
-    }
-    case "union": {
-      const options = getUnionOptions(schema).map(stripRefinements);
-      return z.union(options);
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema).map(
-        (opt) => stripRefinements(opt)
-      );
-      const discriminator = getDiscriminator(schema);
-      if (discriminator === void 0) return schema;
-      return z.discriminatedUnion(
-        discriminator,
-        options
-      );
-    }
-    // Wrappers: strip the inner, preserve the wrapper semantics where
-    // possible. For stripping refinements we typically want wrappers to
-    // survive (optional/nullable/default), so leave them alone.
-    case "optional":
-    case "nullable":
-    case "default":
-    case "readonly":
-    case "pipe":
-      return schema;
-    case "lazy": {
-      const inner = unwrapLazy(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = stripRefinements(inner);
-      return z.lazy(() => slimmedInner);
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left === void 0 || right === void 0) return schema;
-      return z.intersection(stripRefinements(left), stripRefinements(right));
-    }
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = stripRefinements(inner);
-      return slimmedInner.catch(getCatchDefault(schema));
-    }
-    // Leaf types without refinements, or Zod features we don't rewrite.
-    case "boolean":
-    case "date":
-    case "enum":
-    case "literal":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "nan":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return schema;
-    default:
-      return unhandledZodKind("stripRefinements", kind);
-  }
-}
 function stripAsyncChecks(schema) {
-  const config = {
-    stripRefinements: false,
-    shouldKeepCheck: (c) => !isAsyncCheck(c)
-  };
   const seen = /* @__PURE__ */ new WeakSet();
   function recurse(s) {
     if (seen.has(s)) return s;
@@ -699,25 +577,24 @@ function stripAsyncChecks(schema) {
     const kind = kindOf(s);
     switch (kind) {
       case "string":
-        return hasChecks(s) ? carryChecks(z.string(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.string(), s) : s;
       case "number":
-        return hasChecks(s) ? carryChecks(z.number(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.number(), s) : s;
       case "bigint":
-        return hasChecks(s) ? carryChecks(z.bigint(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.bigint(), s) : s;
       case "array": {
         const element = getArrayElement(s);
-        return carryChecks(z.array(recurse(element)), s, config);
+        return carrySyncChecks(z.array(recurse(element)), s);
       }
       case "set": {
-        const valueType = getSetValueType(s);
-        return carryChecks(z.set(recurse(valueType)), s, config);
+        return carrySyncChecks(z.set(recurse(getSetValueType(s))), s);
       }
       case "tuple": {
         const items = getTupleItems(s).map(recurse);
         const rebuilt = z.tuple(
           items
         );
-        return carryChecks(rebuilt, s, config);
+        return carrySyncChecks(rebuilt, s);
       }
       case "object": {
         const shape = getObjectShape(s);
@@ -725,20 +602,22 @@ function stripAsyncChecks(schema) {
         for (const [k, v] of Object.entries(shape)) {
           next[k] = recurse(v);
         }
-        return carryChecks(z.object(next), s, config);
+        return carrySyncChecks(z.object(next), s);
       }
       case "record": {
         const keyType = getRecordKeyType(s);
         const valueType = recurse(getRecordValueType(s));
-        const rebuilt = z.record(keyType, valueType);
-        return carryChecks(rebuilt, s, config);
+        return carrySyncChecks(
+          z.record(keyType, valueType),
+          s
+        );
       }
       case "union": {
         const options = getUnionOptions(s).map(recurse);
-        const rebuilt = z.union(
-          options
+        return carrySyncChecks(
+          z.union(options),
+          s
         );
-        return carryChecks(rebuilt, s, config);
       }
       case "discriminated-union": {
         const options = getDiscriminatedOptions(s).map((opt) => recurse(opt));
@@ -751,13 +630,11 @@ function stripAsyncChecks(schema) {
       }
       case "optional": {
         const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).optional();
+        return inner === void 0 ? s : recurse(inner).optional();
       }
       case "nullable": {
         const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).nullable();
+        return inner === void 0 ? s : recurse(inner).nullable();
       }
       case "default": {
         const inner = unwrapInner(s);
@@ -766,11 +643,8 @@ function stripAsyncChecks(schema) {
       }
       case "readonly": {
         const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).readonly();
+        return inner === void 0 ? s : recurse(inner).readonly();
       }
-      case "pipe":
-        return s;
       case "lazy": {
         const inner = unwrapLazy(s);
         if (inner === void 0) return s;
@@ -788,7 +662,11 @@ function stripAsyncChecks(schema) {
         if (inner === void 0) return s;
         return recurse(inner).catch(getCatchDefault(s));
       }
-      // Leaves with no checks — pass through unchanged.
+      // Pipes pass through (see the docblock); the rest are leaves
+      // whose checks the strip walker deliberately leaves in place —
+      // an async check on one of these still poisons the sync parse
+      // and the callers' defensive catch owns that case.
+      case "pipe":
       case "boolean":
       case "date":
       case "enum":
@@ -809,235 +687,10 @@ function stripAsyncChecks(schema) {
       case "symbol":
       case "function":
         return s;
-      default:
-        return unhandledZodKind("stripAsyncChecks", kind);
     }
   }
   return recurse(schema);
 }
-function getSlimSchema(schema, stripConfig, maxRecursionDepth) {
-  return walkSlim(schema, stripConfig, maxRecursionDepth, 0);
-}
-function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "optional": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return stripConfig.stripOptional === true ? slimmedInner : slimmedInner.optional();
-    }
-    case "nullable": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return stripConfig.stripNullable === true ? slimmedInner : slimmedInner.nullable();
-    }
-    case "default": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      if (stripConfig.stripDefaultValues === true) return slimmedInner;
-      const defaultValue = getDefaultValue(schema);
-      return slimmedInner.default(defaultValue);
-    }
-    case "readonly": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? schema : walkSlim(inner, stripConfig, maxDepth, lazyDepth).readonly();
-    }
-    case "pipe": {
-      if (stripConfig.stripPipe === true) {
-        const pipeIn = unwrapPipeIn(schema);
-        const pipeOut = unwrapPipeOut(schema);
-        const real = pipeIn !== void 0 && kindOf(pipeIn) !== "transform" ? pipeIn : pipeOut !== void 0 && kindOf(pipeOut) !== "transform" ? pipeOut : pipeIn ?? pipeOut ?? schema;
-        return walkSlim(real, stripConfig, maxDepth, lazyDepth);
-      }
-      return schema;
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      const next = {};
-      for (const [k, v] of Object.entries(shape)) {
-        next[k] = walkSlim(v, stripConfig, maxDepth, lazyDepth);
-      }
-      return carryChecks(z.object(next), schema, stripConfig);
-    }
-    case "array": {
-      const element = getArrayElement(schema);
-      return carryChecks(
-        z.array(walkSlim(element, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return carryChecks(
-        z.set(walkSlim(valueType, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(
-        (it) => walkSlim(it, stripConfig, maxDepth, lazyDepth)
-      );
-      const rebuilt = z.tuple(
-        items
-      );
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(schema);
-      const valueType = walkSlim(getRecordValueType(schema), stripConfig, maxDepth, lazyDepth);
-      const rebuilt = z.record(keyType, valueType);
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "union": {
-      const options = getUnionOptions(schema).map(
-        (opt) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
-      );
-      const rebuilt = z.union(options);
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema).map(
-        (opt) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
-      );
-      const discriminator = getDiscriminator(schema);
-      if (discriminator === void 0) return schema;
-      return z.discriminatedUnion(
-        discriminator,
-        options
-      );
-    }
-    // Leaves: strip refinements if requested, otherwise pass through.
-    case "string":
-    case "number":
-    case "bigint":
-      return stripConfig.stripRefinements === true && hasChecks(schema) ? stripRefinements(schema) : schema;
-    case "boolean":
-    case "date":
-    case "enum":
-    case "literal":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "nan":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "map":
-    case "symbol":
-    case "function":
-      return schema;
-    case "lazy": {
-      if (lazyDepth >= maxDepth) return schema;
-      const inner = unwrapLazy(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth + 1);
-      return z.lazy(() => slimmedInner);
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left === void 0 || right === void 0) return schema;
-      return z.intersection(
-        walkSlim(left, stripConfig, maxDepth, lazyDepth),
-        walkSlim(right, stripConfig, maxDepth, lazyDepth)
-      );
-    }
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return slimmedInner.catch(getCatchDefault(schema));
-    }
-    case "transform":
-    case "file":
-      return schema;
-    default:
-      return unhandledZodKind("getSlimSchema", kind);
-  }
-}
-
-function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
-    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
-    // unknown kinds genuinely shouldn't appear, so return undefined.
-    unsupportedKindFallback: () => void 0,
-    // v4 historically recurses into the inner on `useDefault=false`
-    // so a `.catch(v)` slot returns the leaf empty rather than the
-    // fallback. Pinned by `test/adapters/zod-v4/unsupported-kinds.test.ts`
-    // (`z.catch falls through to inner leaf default when useDefault=false`).
-    catchOnUseDefaultFalse: "recurseInner"
-  });
-}
-function getDefaultValuesFromZodSchema(opts) {
-  const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
-  const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
-  const merged = mergeDeep(initial, constraints);
-  const slimSchema = getSlimSchema(
-    schema,
-    {
-      stripDefaultValues: true,
-      stripPipe: true,
-      stripRefinements: true
-    },
-    maxRecursionDepth
-  );
-  const firstParse = slimSchema.safeParse(merged);
-  if (firstParse.success) {
-    return { data: firstParse.data, success: true, slimSchema };
-  }
-  let fixedData = merged;
-  for (const issue of firstParse.error.issues) {
-    const pathSegments = issue.path.map((seg) => typeof seg === "number" ? seg : String(seg));
-    const originalCandidate = getNestedZodSchemasAtPath(schema, pathSegments, maxRecursionDepth)[0];
-    if (originalCandidate !== void 0) {
-      if (isCoercePrimitive(originalCandidate)) continue;
-      if (kindOf(originalCandidate) === "pipe") {
-        const pipeIn = unwrapPipeIn(originalCandidate);
-        if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") continue;
-      }
-    }
-    const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments, maxRecursionDepth);
-    if (candidates.length === 0) continue;
-    const candidate = candidates[0];
-    if (candidate === void 0) continue;
-    const valueAtPath = getAtPath(merged, pathSegments);
-    const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
-    if (slimKinds.size > 0 && slimKinds.has(slimKindOf(valueAtPath))) {
-      continue;
-    }
-    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth);
-    if (fixValue === SKIP) continue;
-    fixedData = pathSegments.length === 0 ? fixValue : setAtPath(fixedData, pathSegments, fixValue);
-  }
-  const secondParse = slimSchema.safeParse(fixedData);
-  if (secondParse.success) {
-    return { data: secondParse.data, success: true, slimSchema };
-  }
-  return { data: fixedData, success: false, slimSchema };
-}
-const SKIP = /* @__PURE__ */ Symbol("atta:skip-fix");
-function defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth) {
-  if (issue.code === "invalid_type") {
-    const du = unwrapToDiscriminatedUnion(candidate);
-    if (du !== void 0) {
-      const first = getDiscriminatedUnionFirstOption(du);
-      if (first !== void 0)
-        return deriveDefault(first, useDefaultSchemaValues, maxRecursionDepth);
-    }
-    return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-  }
-  if (issue.code === "invalid_value") {
-    const values = issue.values;
-    if (values !== void 0 && values.length > 0) return values[0];
-    return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-  }
-  return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-}
 
 function unwrapStructuralWrappers(schema) {
   let current = schema;
@@ -1153,7 +806,7 @@ function buildV4Services() {
     peelAllWrappers: (schema) => peelAllWrappers(schema),
     isLeafRequired: (schema) => isLeafRequired(schema),
     resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPath(schema, path, maxRecursionDepth),
-    issuesToValidationErrors: (issues, fk) => zodIssuesToValidationErrors(issues, fk),
+    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 };
@@ -1186,7 +839,7 @@ function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth)
     }
     return {
       data,
-      errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+      errors: zodIssuesToValidationErrors(strictResult.error.issues),
       success: false,
       formKey
     };
@@ -1217,7 +870,7 @@ function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
       }
       return {
         data: void 0,
-        errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+        errors: zodIssuesToValidationErrors(result.error.issues),
         success: false,
         formKey
       };
@@ -1236,14 +889,14 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
       meta: Object.freeze({})
     };
   }
-  const pathMap = getFieldMetaPathMap(rootSchema, {
+  const pathMap = buildFieldMetaPathMap(rootSchema, {
     intro: V4_INTROSPECTOR,
     peelAllWrappers,
-    getFieldMetaList
+    getFieldMetaList: getFieldMetaListForSchema
   });
   const pathKey = canonicalizePath(path).key;
   const peeled = peelAllWrappers(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 = readDescription(target);
   const peeledDescription = peeled !== target ? readDescription(peeled) : void 0;
   const schemaDescription = targetDescription ?? peeledDescription;
@@ -1271,5 +924,4 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, fieldMeta as f, getIntersectionLeft as g, getDiscriminator as h, getDiscriminatedOptions as i, getUnionOptions as j, kindOf as k, getRecordKeyType as l, getRecordValueType as m, getTupleItems as n, getSetValueType as o, getArrayElement as p, getObjectShape as q, getEnumValues as r, getLiteralValues as s, getChecks as t, useForm as u, getCatchDefault as v, withMeta as w, getDefaultValue as x, zodV4Adapter as z };
-//# sourceMappingURL=attaform.DMxM2kol.mjs.map
+export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };