attaform 0.16.4 → 0.17.0

package/dist/shared/{attaform.g7rfuXdz.mjs → attaform.Cj0pCNVn.mjs}

@@ -1,7 +1,7 @@
-import { g as getAtPath, s as slimKindOf, f as setAtPath, j as isPlainRecord, A as AttaformErrorCode, h as humanize, e as useAbstractForm } from './attaform.DyV1O4tI.mjs';
-import { a as AttaformError, _ as __DEV__, b as InvalidUseFormConfigError } from './attaform.BfMxsfmE.mjs';
+import { g as getAtPath, s as slimKindOf, f as setAtPath, j as isPlainRecord, A as AttaformErrorCode, h as humanize, e as useAbstractForm } from './attaform.BT55rDNN.mjs';
+import { a as AttaformError, _ as __DEV__, b as InvalidUseFormConfigError } from './attaform.CIEQgJnM.mjs';
 import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema } from './attaform.D13GMFgK.mjs';
-import { c as canonicalizePath } from './attaform.DZRj9s0s.mjs';
+import { c as canonicalizePath } from './attaform.h1sq3BFu.mjs';
 import { z } from 'zod';
 
 const fieldMeta = fieldMetaStore;
@@ -115,6 +115,8 @@ function kindOf(schema) {
       return "intersection";
     case "catch":
       return "catch";
+    case "transform":
+      return "transform";
     case "promise":
       return "promise";
     case "custom":
@@ -172,6 +174,18 @@ function unwrapPipe(schema) {
   const def = readDef(schema);
   return def?.in ?? def?.out;
 }
+function unwrapPipeIn(schema) {
+  const def = readDef(schema);
+  return def?.in;
+}
+function unwrapPipeOut(schema) {
+  const def = readDef(schema);
+  return def?.out;
+}
+function readTransformFn(schema) {
+  const def = readDef(schema);
+  return typeof def?.transform === "function" ? def.transform : void 0;
+}
 function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
@@ -363,11 +377,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     }
     case "lazy": {
       const getter = getLazyGetter(schema);
-      if (getter !== void 0 && lazyGetters.includes(getter)) {
-        throw new UnsupportedSchemaError(
-          `[attaform/zod] Recursive z.lazy() at '${labelPath(path)}'`
-        );
-      }
+      if (getter !== void 0 && lazyGetters.includes(getter)) return;
       const inner = unwrapLazy(schema);
       if (inner !== void 0) {
         assertSupportedKinds(
@@ -403,6 +413,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return;
     default: {
       const _exhaustive = kind;
@@ -421,6 +432,15 @@ function unwrapToDiscriminatedUnion(schema) {
       next = unwrapInner(current);
     } else if (kind === "pipe") {
       next = unwrapPipe(current);
+    } else if (kind === "intersection") {
+      const left = getIntersectionLeft(current);
+      const right = getIntersectionRight(current);
+      const leftDU = left !== void 0 ? unwrapToDiscriminatedUnion(left) : void 0;
+      const rightDU = right !== void 0 ? unwrapToDiscriminatedUnion(right) : void 0;
+      if (leftDU !== void 0 && rightDU !== void 0) {
+        return void 0;
+      }
+      return leftDU ?? rightDU;
     }
     if (next === void 0) return void 0;
     current = next;
@@ -548,6 +568,7 @@ function computeFingerprint(schema, cache, inProgress) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return `${kind}:*`;
     default: {
       const _ = kind;
@@ -629,12 +650,10 @@ const PERMISSIVE = /* @__PURE__ */ new Set([
   "map",
   "set"
 ]);
-const MAX_LAZY_DEPTH = 64;
-function slimPrimitivesOf(schema) {
-  return walk(schema, 0);
+function slimPrimitivesOf(schema, maxRecursionDepth) {
+  return walk(schema, 0, maxRecursionDepth);
 }
-function walk(schema, depth) {
-  if (depth > MAX_LAZY_DEPTH) return new Set(PERMISSIVE);
+function walk(schema, lazyDepth, maxDepth) {
   const kind = kindOf(schema);
   switch (kind) {
     case "string":
@@ -678,13 +697,13 @@ function walk(schema, depth) {
       return /* @__PURE__ */ new Set(["set"]);
     case "optional": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, depth + 1);
+      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
       innerSet.add("undefined");
       return innerSet;
     }
     case "nullable": {
       const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, depth + 1);
+      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, lazyDepth, maxDepth);
       innerSet.add("null");
       return innerSet;
     }
@@ -692,30 +711,31 @@ function walk(schema, depth) {
     case "readonly":
     case "catch": {
       const inner = unwrapInner(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
     }
     case "pipe": {
       const inner = unwrapPipe(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth, maxDepth);
     }
     case "lazy": {
+      if (lazyDepth >= maxDepth) return new Set(PERMISSIVE);
       const inner = unwrapLazy(schema);
-      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, lazyDepth + 1, maxDepth);
     }
     case "union":
     case "discriminated-union": {
       const options = getUnionOptions(schema);
       const out = /* @__PURE__ */ new Set();
       for (const opt of options) {
-        for (const k of walk(opt, depth + 1)) out.add(k);
+        for (const k of walk(opt, lazyDepth, maxDepth)) out.add(k);
       }
       return out.size === 0 ? new Set(PERMISSIVE) : out;
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
-      const leftSet = left === void 0 ? new Set(PERMISSIVE) : walk(left, depth + 1);
-      const rightSet = right === void 0 ? new Set(PERMISSIVE) : walk(right, depth + 1);
+      const leftSet = left === void 0 ? new Set(PERMISSIVE) : walk(left, lazyDepth, maxDepth);
+      const rightSet = right === void 0 ? new Set(PERMISSIVE) : walk(right, lazyDepth, maxDepth);
       const out = /* @__PURE__ */ new Set();
       for (const k of leftSet) if (rightSet.has(k)) out.add(k);
       return out;
@@ -731,6 +751,8 @@ function walk(schema, depth) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
+      return new Set(PERMISSIVE);
     default:
       return new Set(PERMISSIVE);
   }
@@ -764,13 +786,13 @@ function slimKindOfRaw(value) {
 }
 
 const PATH_SEPARATOR$1 = ".";
-function getNestedZodSchemasAtPath(schema, path) {
-  if (Array.isArray(path)) return walkSegments(schema, path.map(String));
+function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
+  if (Array.isArray(path)) return walkSegments(schema, path.map(String), maxRecursionDepth, 0);
   const pathString = path;
   if (pathString.length === 0) return [schema];
-  return walkSegments(schema, pathString.split(PATH_SEPARATOR$1));
+  return walkSegments(schema, pathString.split(PATH_SEPARATOR$1), maxRecursionDepth, 0);
 }
-function walkSegments(schema, segments) {
+function walkSegments(schema, segments, maxDepth, lazyDepth) {
   if (segments.length === 0) return [schema];
   const [head, ...rest] = segments;
   if (head === void 0) return [schema];
@@ -780,23 +802,25 @@ function walkSegments(schema, segments) {
       const shape = getObjectShape(schema);
       if (!Object.hasOwn(shape, head)) return [];
       const next = shape[head];
-      return next === void 0 ? [] : walkSegments(next, rest);
+      return next === void 0 ? [] : walkSegments(next, rest, maxDepth, lazyDepth);
     }
     case "array":
-      return walkSegments(getArrayElement(schema), rest);
+      return walkSegments(getArrayElement(schema), rest, maxDepth, lazyDepth);
     case "set":
-      return walkSegments(getSetValueType(schema), rest);
+      return walkSegments(getSetValueType(schema), rest, maxDepth, lazyDepth);
     case "record":
-      return walkSegments(getRecordValueType(schema), rest);
+      return walkSegments(getRecordValueType(schema), rest, maxDepth, lazyDepth);
     case "tuple": {
       const index = Number(head);
       if (!Number.isInteger(index)) return [];
       const items = getTupleItems(schema);
       const item = items[index];
-      return item === void 0 ? [] : walkSegments(item, rest);
+      return item === void 0 ? [] : walkSegments(item, rest, maxDepth, lazyDepth);
     }
     case "union":
-      return getUnionOptions(schema).flatMap((opt) => walkSegments(opt, segments));
+      return getUnionOptions(schema).flatMap(
+        (opt) => walkSegments(opt, segments, maxDepth, lazyDepth)
+      );
     case "discriminated-union": {
       const options = getDiscriminatedOptions(schema);
       const matching = options.filter((opt) => {
@@ -804,7 +828,7 @@ function walkSegments(schema, segments) {
         return Object.hasOwn(shape, head);
       });
       const candidates = matching.length > 0 ? matching : options;
-      return candidates.flatMap((opt) => walkSegments(opt, segments));
+      return candidates.flatMap((opt) => walkSegments(opt, segments, maxDepth, lazyDepth));
     }
     case "optional":
     case "nullable":
@@ -812,21 +836,22 @@ function walkSegments(schema, segments) {
     case "readonly":
     case "catch": {
       const inner = unwrapInner(schema);
-      return inner === void 0 ? [] : walkSegments(inner, segments);
+      return inner === void 0 ? [] : walkSegments(inner, segments, maxDepth, lazyDepth);
     }
     case "pipe": {
       const inner = unwrapPipe(schema);
-      return inner === void 0 ? [] : walkSegments(inner, segments);
+      return inner === void 0 ? [] : walkSegments(inner, segments, maxDepth, lazyDepth);
     }
     case "lazy": {
+      if (lazyDepth >= maxDepth) return [];
       const inner = unwrapLazy(schema);
-      return inner === void 0 ? [] : walkSegments(inner, segments);
+      return inner === void 0 ? [] : walkSegments(inner, segments, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
-      const leftResults = left === void 0 ? [] : walkSegments(left, segments);
-      const rightResults = right === void 0 ? [] : walkSegments(right, segments);
+      const leftResults = left === void 0 ? [] : walkSegments(left, segments, maxDepth, lazyDepth);
+      const rightResults = right === void 0 ? [] : walkSegments(right, segments, maxDepth, lazyDepth);
       return [...leftResults, ...rightResults];
     }
     // Leaf types — can't descend further.
@@ -847,6 +872,7 @@ function walkSegments(schema, segments) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return [];
     default: {
       const _exhaustive = kind;
@@ -958,6 +984,7 @@ function stripRefinements(schema) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1081,6 +1108,7 @@ function stripAsyncChecks(schema) {
       case "promise":
       case "custom":
       case "template-literal":
+      case "transform":
         return s;
       default: {
         const _exhaustive = kind;
@@ -1090,34 +1118,37 @@ function stripAsyncChecks(schema) {
   }
   return recurse(schema);
 }
-function getSlimSchema(schema, stripConfig) {
+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 = getSlimSchema(inner, stripConfig);
+      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
       return stripConfig.stripOptional === true ? slimmedInner : slimmedInner.optional();
     }
     case "nullable": {
       const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = getSlimSchema(inner, stripConfig);
+      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
       return stripConfig.stripNullable === true ? slimmedInner : slimmedInner.nullable();
     }
     case "default": {
       const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = getSlimSchema(inner, stripConfig);
+      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 : getSlimSchema(inner, stripConfig).readonly();
+      return inner === void 0 ? schema : walkSlim(inner, stripConfig, maxDepth, lazyDepth).readonly();
     }
     case "pipe": {
       if (stripConfig.stripPipe === true) {
         const inner = unwrapPipe(schema) ?? schema;
-        return getSlimSchema(inner, stripConfig);
+        return walkSlim(inner, stripConfig, maxDepth, lazyDepth);
       }
       return schema;
     }
@@ -1125,20 +1156,30 @@ function getSlimSchema(schema, stripConfig) {
       const shape = getObjectShape(schema);
       const next = {};
       for (const [k, v] of Object.entries(shape)) {
-        next[k] = getSlimSchema(v, stripConfig);
+        next[k] = walkSlim(v, stripConfig, maxDepth, lazyDepth);
       }
       return carryChecks(z.object(next), schema, stripConfig);
     }
     case "array": {
       const element = getArrayElement(schema);
-      return carryChecks(z.array(getSlimSchema(element, stripConfig)), schema, stripConfig);
+      return carryChecks(
+        z.array(walkSlim(element, stripConfig, maxDepth, lazyDepth)),
+        schema,
+        stripConfig
+      );
     }
     case "set": {
       const valueType = getSetValueType(schema);
-      return carryChecks(z.set(getSlimSchema(valueType, stripConfig)), schema, stripConfig);
+      return carryChecks(
+        z.set(walkSlim(valueType, stripConfig, maxDepth, lazyDepth)),
+        schema,
+        stripConfig
+      );
     }
     case "tuple": {
-      const items = getTupleItems(schema).map((it) => getSlimSchema(it, stripConfig));
+      const items = getTupleItems(schema).map(
+        (it) => walkSlim(it, stripConfig, maxDepth, lazyDepth)
+      );
       const rebuilt = z.tuple(
         items
       );
@@ -1146,18 +1187,20 @@ function getSlimSchema(schema, stripConfig) {
     }
     case "record": {
       const keyType = getRecordKeyType(schema);
-      const valueType = getSlimSchema(getRecordValueType(schema), stripConfig);
+      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) => getSlimSchema(opt, stripConfig));
+      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) => getSlimSchema(opt, stripConfig)
+        (opt) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
       );
       const discriminator = getDiscriminator(schema);
       if (discriminator === void 0) return schema;
@@ -1187,23 +1230,29 @@ function getSlimSchema(schema, stripConfig) {
     case "template-literal":
       return schema;
     case "lazy": {
+      if (lazyDepth >= maxDepth) return schema;
       const inner = unwrapLazy(schema);
       if (inner === void 0) return schema;
-      const slimmedInner = getSlimSchema(inner, stripConfig);
+      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(getSlimSchema(left, stripConfig), getSlimSchema(right, stripConfig));
+      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 = getSlimSchema(inner, stripConfig);
+      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
       return slimmedInner.catch(getCatchDefault(schema));
     }
+    case "transform":
+      return schema;
     default: {
       const _exhaustive = kind;
       throw new Error(`getSlimSchema: unhandled ZodKind '${_exhaustive}'`);
@@ -1211,23 +1260,23 @@ function getSlimSchema(schema, stripConfig) {
   }
 }
 
-function deriveDefault(schema, useDefault) {
-  return defaultForKind(kindOf(schema), schema, useDefault);
+function deriveDefault(schema, useDefault, maxRecursionDepth) {
+  return defaultForKind(kindOf(schema), schema, useDefault, maxRecursionDepth, 0);
 }
-function defaultForKind(kind, schema, useDefault) {
+function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
   switch (kind) {
     case "object": {
       const shape = getObjectShape(schema);
       const out = {};
       for (const [key, subSchema] of Object.entries(shape)) {
-        out[key] = deriveDefault(subSchema, useDefault);
+        out[key] = defaultForKind(kindOf(subSchema), subSchema, useDefault, maxDepth, lazyDepth);
       }
       return out;
     }
     case "default": {
       if (useDefault) return getDefaultValue(schema);
       const inner = unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "optional":
       return void 0;
@@ -1235,11 +1284,11 @@ function defaultForKind(kind, schema, useDefault) {
       return null;
     case "readonly": {
       const inner = unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "pipe": {
       const inner = unwrapPipe(schema);
-      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "array":
       return [];
@@ -1249,16 +1298,18 @@ function defaultForKind(kind, schema, useDefault) {
       return {};
     case "tuple": {
       const items = getTupleItems(schema);
-      return items.map((item) => deriveDefault(item, useDefault));
+      return items.map(
+        (item) => defaultForKind(kindOf(item), item, useDefault, maxDepth, lazyDepth)
+      );
     }
     case "union": {
       const options = getUnionOptions(schema);
       const first = options[0];
-      return first === void 0 ? void 0 : deriveDefault(first, useDefault);
+      return first === void 0 ? void 0 : defaultForKind(kindOf(first), first, useDefault, maxDepth, lazyDepth);
     }
     case "discriminated-union": {
       const first = getDiscriminatedUnionFirstOption(schema);
-      return first === void 0 ? void 0 : deriveDefault(first, useDefault);
+      return first === void 0 ? void 0 : defaultForKind(kindOf(first), first, useDefault, maxDepth, lazyDepth);
     }
     case "string":
       return "";
@@ -1285,20 +1336,21 @@ function defaultForKind(kind, schema, useDefault) {
     case "nan":
       return NaN;
     case "lazy": {
+      if (lazyDepth >= maxDepth) return void 0;
       const inner = unwrapLazy(schema);
-      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth + 1);
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
-      const l = left === void 0 ? void 0 : deriveDefault(left, useDefault);
-      const r = right === void 0 ? void 0 : deriveDefault(right, useDefault);
+      const l = left === void 0 ? void 0 : defaultForKind(kindOf(left), left, useDefault, maxDepth, lazyDepth);
+      const r = right === void 0 ? void 0 : defaultForKind(kindOf(right), right, useDefault, maxDepth, lazyDepth);
       return mergeDeep(l, r);
     }
     case "catch": {
       if (useDefault) return getCatchDefault(schema);
       const inner = unwrapInner(schema);
-      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
     }
     case "any":
     case "unknown":
@@ -1307,6 +1359,7 @@ function defaultForKind(kind, schema, useDefault) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return void 0;
     default: {
       const _exhaustive = kind;
@@ -1331,14 +1384,18 @@ function mergeDeep(base, override) {
   return result;
 }
 function getDefaultValuesFromZodSchema(opts) {
-  const { schema, useDefaultSchemaValues, constraints } = opts;
-  const initial = deriveDefault(schema, useDefaultSchemaValues);
+  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
-  });
+  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 };
@@ -1346,16 +1403,16 @@ function getDefaultValuesFromZodSchema(opts) {
   let fixedData = merged;
   for (const issue of firstParse.error.issues) {
     const pathSegments = issue.path.map((seg) => typeof seg === "number" ? seg : String(seg));
-    const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments);
+    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);
+    const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
     if (slimKinds.size > 0 && slimKinds.has(slimKindOf(valueAtPath))) {
       continue;
     }
-    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues);
+    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth);
     if (fixValue === SKIP) continue;
     fixedData = pathSegments.length === 0 ? fixValue : setAtPath(fixedData, pathSegments, fixValue);
   }
@@ -1366,21 +1423,22 @@ function getDefaultValuesFromZodSchema(opts) {
   return { data: fixedData, success: false, slimSchema };
 }
 const SKIP = Symbol("atta:skip-fix");
-function defaultFromIssue(issue, candidate, useDefaultSchemaValues) {
+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);
+      if (first !== void 0)
+        return deriveDefault(first, useDefaultSchemaValues, maxRecursionDepth);
     }
-    return deriveDefault(candidate, useDefaultSchemaValues);
+    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);
+    return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
   }
-  return deriveDefault(candidate, useDefaultSchemaValues);
+  return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
 }
 
 const PATH_SEPARATOR = ".";
@@ -1470,7 +1528,8 @@ function isLeafRequired(schema, depth = 0) {
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
   assertSupportedKinds(rootSchema);
-  return (formKey) => {
+  return (formKey, options) => {
+    const maxRecursionDepth = options.maxRecursionDepth;
     const leafCache = /* @__PURE__ */ new Map();
     let asyncValidationFlag = null;
     return {
@@ -1483,13 +1542,16 @@ function zodV4Adapter(rootSchema) {
         const { data } = getDefaultValuesFromZodSchema({
           schema: rootSchema,
           useDefaultSchemaValues: config.useDefaultSchemaValues,
-          constraints: config.constraints
+          constraints: config.constraints,
+          maxRecursionDepth
         });
         if (config.strict !== false) {
           try {
-            const strictResult = rootSchema.safeParse(data);
+            const strictResult = rootSchema.safeParse(
+              data
+            );
             if (strictResult.success) {
-              return { data: strictResult.data, errors: void 0, success: true, formKey };
+              return { data, errors: void 0, success: true, formKey };
             }
             return {
               data,
@@ -1517,15 +1579,46 @@ function zodV4Adapter(rootSchema) {
         }
         return { data, errors: void 0, success: true, formKey };
       },
+      normalizeWriteValueAtPath(value, path) {
+        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
+        const [first] = candidates;
+        if (first === void 0) return value;
+        let current = first;
+        let result = value;
+        for (let i = 0; i < 64; i++) {
+          if (kindOf(current) !== "pipe") break;
+          const pipeIn = unwrapPipeIn(current);
+          if (pipeIn === void 0 || kindOf(pipeIn) !== "transform") break;
+          const fn = readTransformFn(pipeIn);
+          if (typeof fn !== "function") break;
+          let next;
+          try {
+            next = fn(result);
+          } catch (cause) {
+            throw new Error(
+              `[attaform] input normalization at path "${path.join(".")}" threw \u2014 write rejected.`,
+              { cause }
+            );
+          }
+          if (next instanceof Promise) {
+            return value;
+          }
+          result = next;
+          const out = unwrapPipeOut(current);
+          if (out === void 0) break;
+          current = out;
+        }
+        return result;
+      },
       getDefaultAtPath(path) {
-        if (path.length === 0) return deriveDefault(rootSchema, true);
-        const [first] = getNestedZodSchemasAtPath(rootSchema, path);
+        if (path.length === 0) return deriveDefault(rootSchema, true, maxRecursionDepth);
+        const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         if (first === void 0) return void 0;
-        return deriveDefault(unwrapStructuralWrappers(first), true);
+        return deriveDefault(unwrapStructuralWrappers(first), true, maxRecursionDepth);
       },
       arrayShapeAtPath(path) {
         if (path.length === 0) return void 0;
-        const [first] = getNestedZodSchemasAtPath(rootSchema, path);
+        const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         if (first === void 0) return void 0;
         const peeled = peelAllWrappers(first);
         const kind = kindOf(peeled);
@@ -1534,13 +1627,13 @@ function zodV4Adapter(rootSchema) {
         return void 0;
       },
       getSchemasAtPath(path) {
-        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         return resolved.map(
           (schema) => ({
             fingerprint: () => fingerprintZodSchema(schema),
             needsAsyncValidation: () => containsAsyncRefine(schema),
             getDefaultValues: () => ({
-              data: deriveDefault(schema, true),
+              data: deriveDefault(schema, true, maxRecursionDepth),
               errors: void 0,
               success: true,
               formKey
@@ -1563,11 +1656,11 @@ function zodV4Adapter(rootSchema) {
       },
       getSlimPrimitiveTypesAtPath(path) {
         if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
-        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         if (resolved.length === 0) return /* @__PURE__ */ new Set();
         const out = /* @__PURE__ */ new Set();
         for (const candidate of resolved) {
-          for (const k of slimPrimitivesOf(candidate)) out.add(k);
+          for (const k of slimPrimitivesOf(candidate, maxRecursionDepth)) out.add(k);
         }
         return out;
       },
@@ -1582,15 +1675,15 @@ function zodV4Adapter(rootSchema) {
       },
       isRequiredAtPath(path) {
         if (path.length === 0) return true;
-        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         if (resolved.length === 0) return false;
         return resolved.every((candidate) => isLeafRequired(candidate));
       },
       getFieldMetaAtPath(path) {
-        return resolveFieldMetaAtPath(rootSchema, path);
+        return resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth);
       },
       getUnionDiscriminatorAtPath(path) {
-        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
+        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
         let matchedUnion;
         for (const candidate of candidates) {
           const du = unwrapToDiscriminatedUnion(candidate);
@@ -1601,24 +1694,35 @@ function zodV4Adapter(rootSchema) {
         if (matchedUnion === void 0) return void 0;
         const discKey = getDiscriminator(matchedUnion);
         if (discKey === void 0) return void 0;
-        const options = getDiscriminatedOptions(matchedUnion);
+        const options2 = getDiscriminatedOptions(matchedUnion);
+        const literalSet = /* @__PURE__ */ new Set();
+        for (const opt of options2) {
+          const shape = getObjectShape(opt);
+          const litSchema = shape[discKey];
+          if (litSchema === void 0) continue;
+          if (kindOf(litSchema) !== "literal") continue;
+          for (const v of getLiteralValues(litSchema)) literalSet.add(v);
+        }
         return {
           discriminatorKey: discKey,
           getVariantDefault(value) {
-            for (const opt of options) {
+            for (const opt of options2) {
               const shape = getObjectShape(opt);
               const litSchema = shape[discKey];
               if (litSchema === void 0) continue;
               if (kindOf(litSchema) !== "literal") continue;
               const literalValues = getLiteralValues(litSchema);
-              if (literalValues.includes(value)) return deriveDefault(opt, true);
+              if (literalValues.includes(value)) return deriveDefault(opt, true, maxRecursionDepth);
             }
             return void 0;
+          },
+          isVariantSelected(value) {
+            return literalSet.has(value);
           }
         };
       },
-      validateAtPath(data, path, options) {
-        const trySync = options?.sync === true;
+      validateAtPath(data, path, options2) {
+        const trySync = options2?.sync === true;
         if (trySync) {
           try {
             return runSync();
@@ -1636,13 +1740,18 @@ function zodV4Adapter(rootSchema) {
               formKey
             };
           }
-          const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+          const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
           if (resolved.length === 0) return pathNotFound(path);
           const aggregated = [];
           for (const candidate of resolved) {
             const result = candidate.safeParse(data);
             if (result.success) {
-              return { data: result.data, errors: void 0, success: true, formKey };
+              return {
+                data: result.data,
+                errors: void 0,
+                success: true,
+                formKey
+              };
             }
             aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
           }
@@ -1650,7 +1759,9 @@ function zodV4Adapter(rootSchema) {
         }
         async function runAsync() {
           if (path === void 0) {
-            const result = await rootSchema.safeParseAsync(data);
+            const result = await rootSchema.safeParseAsync(
+              data
+            );
             return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
               data: void 0,
               errors: zodIssuesToValidationErrors(result.error.issues, formKey),
@@ -1658,13 +1769,18 @@ function zodV4Adapter(rootSchema) {
               formKey
             };
           }
-          const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+          const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
           if (resolved.length === 0) return pathNotFound(path);
           const aggregated = [];
           for (const candidate of resolved) {
             const result = await candidate.safeParseAsync(data);
             if (result.success) {
-              return { data: result.data, errors: void 0, success: true, formKey };
+              return {
+                data: result.data,
+                errors: void 0,
+                success: true,
+                formKey
+              };
             }
             aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
           }
@@ -1842,6 +1958,7 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress)
       case "promise":
       case "custom":
       case "template-literal":
+      case "transform":
         return;
     }
   } finally {
@@ -1856,9 +1973,9 @@ function consumePayload(schema, counters) {
   counters.set(schema, idx + 1);
   return payload;
 }
-function resolveFieldMetaAtPath(rootSchema, path) {
+function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
-  const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
+  const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
   const target = candidates[0];
   if (target === void 0) {
     return {
@@ -1892,9 +2009,7 @@ function useForm(configuration) {
   if (candidate === void 0 || candidate === null || candidate.schema === void 0) {
     throw new InvalidUseFormConfigError();
   }
-  const adapter = zodV4Adapter(
-    configuration.schema
-  );
+  const adapter = zodV4Adapter(configuration.schema);
   return useAbstractForm({
     ...configuration,
     schema: adapter
@@ -1902,4 +2017,4 @@ function useForm(configuration) {
 }
 
 export { UnsupportedSchemaError as U, assertZodVersion as a, fieldMeta as f, kindOf as k, useForm as u, withMeta as w, zodV4Adapter as z };
-//# sourceMappingURL=attaform.g7rfuXdz.mjs.map
+//# sourceMappingURL=attaform.Cj0pCNVn.mjs.map