attaform 0.16.3 → 0.17.0

package/dist/shared/{attaform.DGuGGNg9.cjs → attaform.C6_zOf8x.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-const useFormContext = require('./attaform.C9Ph2SMx.cjs');
-const plugin = require('./attaform.rIRYSUI1.cjs');
+const useFormContext = require('./attaform.BFumZXY2.cjs');
+const plugin = require('./attaform.Dee2rU1P.cjs');
 const fieldMetaStore = require('./attaform.C8CyvYa_.cjs');
-const paths = require('./attaform.c_NzdRyc.cjs');
+const paths = require('./attaform.BBM2muQ9.cjs');
 const zod = require('zod');
 
 const fieldMeta = fieldMetaStore.fieldMetaStore;
@@ -37,6 +37,10 @@ function zodIssuesToValidationErrors(issues, formKey) {
     }
     return {
       message: issue.message,
+      // Adapter-side paths stay schema-relative — the validation
+      // pipeline in `create-form-store.ts` prepends the parent path
+      // 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
@@ -113,6 +117,8 @@ function kindOf(schema) {
       return "intersection";
     case "catch":
       return "catch";
+    case "transform":
+      return "transform";
     case "promise":
       return "promise";
     case "custom":
@@ -170,6 +176,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;
@@ -361,11 +379,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(
@@ -401,6 +415,7 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return;
     default: {
       const _exhaustive = kind;
@@ -419,6 +434,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;
@@ -546,6 +570,7 @@ function computeFingerprint(schema, cache, inProgress) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return `${kind}:*`;
     default: {
       const _ = kind;
@@ -627,12 +652,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":
@@ -676,13 +699,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;
     }
@@ -690,30 +713,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;
@@ -729,6 +753,8 @@ function walk(schema, depth) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
+      return new Set(PERMISSIVE);
     default:
       return new Set(PERMISSIVE);
   }
@@ -762,13 +788,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];
@@ -778,23 +804,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) => {
@@ -802,7 +830,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":
@@ -810,21 +838,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.
@@ -845,6 +874,7 @@ function walkSegments(schema, segments) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return [];
     default: {
       const _exhaustive = kind;
@@ -956,6 +986,7 @@ function stripRefinements(schema) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1079,6 +1110,7 @@ function stripAsyncChecks(schema) {
       case "promise":
       case "custom":
       case "template-literal":
+      case "transform":
         return s;
       default: {
         const _exhaustive = kind;
@@ -1088,34 +1120,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;
     }
@@ -1123,20 +1158,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(zod.z.object(next), schema, stripConfig);
     }
     case "array": {
       const element = getArrayElement(schema);
-      return carryChecks(zod.z.array(getSlimSchema(element, stripConfig)), schema, stripConfig);
+      return carryChecks(
+        zod.z.array(walkSlim(element, stripConfig, maxDepth, lazyDepth)),
+        schema,
+        stripConfig
+      );
     }
     case "set": {
       const valueType = getSetValueType(schema);
-      return carryChecks(zod.z.set(getSlimSchema(valueType, stripConfig)), schema, stripConfig);
+      return carryChecks(
+        zod.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 = zod.z.tuple(
         items
       );
@@ -1144,18 +1189,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 = zod.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 = zod.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;
@@ -1185,23 +1232,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 zod.z.lazy(() => slimmedInner);
     }
     case "intersection": {
       const left = getIntersectionLeft(schema);
       const right = getIntersectionRight(schema);
       if (left === void 0 || right === void 0) return schema;
-      return zod.z.intersection(getSlimSchema(left, stripConfig), getSlimSchema(right, stripConfig));
+      return zod.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}'`);
@@ -1209,23 +1262,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;
@@ -1233,11 +1286,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 [];
@@ -1247,16 +1300,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 "";
@@ -1283,20 +1338,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":
@@ -1305,6 +1361,7 @@ function defaultForKind(kind, schema, useDefault) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "transform":
       return void 0;
     default: {
       const _exhaustive = kind;
@@ -1329,14 +1386,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 };
@@ -1344,16 +1405,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 = useFormContext.getAtPath(merged, pathSegments);
-    const slimKinds = slimPrimitivesOf(candidate);
+    const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
     if (slimKinds.size > 0 && slimKinds.has(useFormContext.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 : useFormContext.setAtPath(fixedData, pathSegments, fixValue);
   }
@@ -1364,21 +1425,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 = ".";
@@ -1468,7 +1530,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 {
@@ -1481,13 +1544,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,
@@ -1515,15 +1581,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);
@@ -1532,13 +1629,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
@@ -1561,11 +1658,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;
       },
@@ -1580,15 +1677,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);
@@ -1599,24 +1696,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();
@@ -1634,13 +1742,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));
           }
@@ -1648,7 +1761,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),
@@ -1656,13 +1771,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));
           }
@@ -1840,6 +1960,7 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress)
       case "promise":
       case "custom":
       case "template-literal":
+      case "transform":
         return;
     }
   } finally {
@@ -1854,9 +1975,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 {
@@ -1890,9 +2011,7 @@ function useForm(configuration) {
   if (candidate === void 0 || candidate === null || candidate.schema === void 0) {
     throw new plugin.InvalidUseFormConfigError();
   }
-  const adapter = zodV4Adapter(
-    configuration.schema
-  );
+  const adapter = zodV4Adapter(configuration.schema);
   return useFormContext.useAbstractForm({
     ...configuration,
     schema: adapter
@@ -1906,4 +2025,4 @@ exports.kindOf = kindOf;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.DGuGGNg9.cjs.map
+//# sourceMappingURL=attaform.C6_zOf8x.cjs.map