attaform 0.27.5 → 0.28.0

package/dist/shared/{attaform.Crv0RNiz.cjs → attaform.NLmerepI.mjs}

@@ -1,38 +1,15 @@
-'use strict';
+import { o as humanize, h as useAbstractForm } from './attaform.B8k8JrmK.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.wfY8XFvm.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.C09fpdLS.mjs';
+import { z } from 'zod';
 
-const serializeScript = require('./attaform.Cg1rUfcF.cjs');
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
-const walkFieldMeta = require('./attaform.f2zyNh5d.cjs');
-const zod = require('zod');
-
-const fieldMeta = walkFieldMeta.fieldMetaStore;
-function getFieldMetaList(schema) {
-  return walkFieldMeta.getFieldMetaListForSchema(schema);
-}
-function withMeta(schema, payload) {
-  const existing = walkFieldMeta.getFieldMetaForSchema(schema) ?? {};
-  const cloned = schema.clone();
-  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
-  return cloned;
-}
-function getFieldMeta(schema) {
-  return walkFieldMeta.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 (devtoolsShared.__DEV__ && !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."
-        );
-      }
     }
     return {
       message: issue.message,
@@ -41,101 +18,70 @@ 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
     };
   });
 }
-class UnsupportedSchemaError extends devtoolsShared.AttaformError {
+class UnsupportedSchemaError extends AttaformError {
 }
 
 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;
@@ -267,10 +213,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] AF01 attaform.dev/e/af01"
     );
   }
 }
+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;
@@ -280,40 +238,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") {
@@ -325,6 +268,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,
@@ -337,14 +283,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
@@ -386,7 +343,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] AF02 attaform.dev/e/af02 '${kind}' at '${labelPath(path)}'`
     );
   }
   switch (kind) {
@@ -481,7 +438,9 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
       return;
     default: {
       const _exhaustive = kind;
-      throw new Error(`assertSupportedKinds: unhandled ZodKind '${_exhaustive}'`);
+      throw new Error(
+        `[attaform] AF03 attaform.dev/e/af03 '${_exhaustive}'`
+      );
     }
   }
 }
@@ -511,10 +470,6 @@ function unwrapToDiscriminatedUnion(schema) {
   }
   return void 0;
 }
-function getDiscriminatedUnionFirstOption(schema) {
-  const options = getDiscriminatedOptions(schema);
-  return options[0];
-}
 
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
@@ -527,6 +482,7 @@ const V4_INTROSPECTOR = {
   isCoercePrimitive,
   containsAsyncRefine,
   containsAsyncTransform,
+  containsDiscriminatedUnion,
   hasContainerOrRootRefine,
   // Walker accessors (D2 / D3 / D5).
   getArrayElement: (schema) => {
@@ -554,17 +510,42 @@ const V4_INTROSPECTOR = {
 };
 
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return new Set(walkFieldMeta.slimPrimitivesWalk(schema, V4_INTROSPECTOR, 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)) {
-    return walkFieldMeta.walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
+    return walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
   }
   const pathString = path;
   if (pathString.length === 0) return [schema];
-  return walkFieldMeta.walkPathSegments(
+  return walkPathSegments(
     schema,
     pathString.split(PATH_SEPARATOR),
     V4_INTROSPECTOR,
@@ -573,127 +554,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) ? zod.z.string() : schema;
-    case "number":
-      return hasChecks(schema) ? zod.z.number() : schema;
-    case "bigint":
-      return hasChecks(schema) ? zod.z.bigint() : schema;
-    case "array": {
-      const element = getArrayElement(schema);
-      return zod.z.array(stripRefinements(element));
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return zod.z.set(stripRefinements(valueType));
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(stripRefinements);
-      return zod.z.tuple(items);
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      const next = {};
-      for (const [k, v] of Object.entries(shape)) {
-        next[k] = stripRefinements(v);
-      }
-      return zod.z.object(next);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(
-        schema
-      );
-      const valueType = stripRefinements(getRecordValueType(schema));
-      return zod.z.record(keyType, valueType);
-    }
-    case "union": {
-      const options = getUnionOptions(schema).map(stripRefinements);
-      return zod.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 zod.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 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(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;
@@ -701,25 +570,24 @@ function stripAsyncChecks(schema) {
     const kind = kindOf(s);
     switch (kind) {
       case "string":
-        return hasChecks(s) ? carryChecks(zod.z.string(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.string(), s) : s;
       case "number":
-        return hasChecks(s) ? carryChecks(zod.z.number(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.number(), s) : s;
       case "bigint":
-        return hasChecks(s) ? carryChecks(zod.z.bigint(), s, config) : s;
+        return hasChecks(s) ? carrySyncChecks(z.bigint(), s) : s;
       case "array": {
         const element = getArrayElement(s);
-        return carryChecks(zod.z.array(recurse(element)), s, config);
+        return carrySyncChecks(z.array(recurse(element)), s);
       }
       case "set": {
-        const valueType = getSetValueType(s);
-        return carryChecks(zod.z.set(recurse(valueType)), s, config);
+        return carrySyncChecks(z.set(recurse(getSetValueType(s))), s);
       }
       case "tuple": {
         const items = getTupleItems(s).map(recurse);
-        const rebuilt = zod.z.tuple(
+        const rebuilt = z.tuple(
           items
         );
-        return carryChecks(rebuilt, s, config);
+        return carrySyncChecks(rebuilt, s);
       }
       case "object": {
         const shape = getObjectShape(s);
@@ -727,39 +595,39 @@ function stripAsyncChecks(schema) {
         for (const [k, v] of Object.entries(shape)) {
           next[k] = recurse(v);
         }
-        return carryChecks(zod.z.object(next), s, config);
+        return carrySyncChecks(z.object(next), s);
       }
       case "record": {
         const keyType = getRecordKeyType(s);
         const valueType = recurse(getRecordValueType(s));
-        const rebuilt = zod.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 = zod.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));
         const discriminator = getDiscriminator(s);
         if (discriminator === void 0) return s;
-        return zod.z.discriminatedUnion(
+        return z.discriminatedUnion(
           discriminator,
           options
         );
       }
       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);
@@ -768,29 +636,30 @@ 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;
         const stripped = recurse(inner);
-        return zod.z.lazy(() => stripped);
+        return z.lazy(() => stripped);
       }
       case "intersection": {
         const left = getIntersectionLeft(s);
         const right = getIntersectionRight(s);
         if (left === void 0 || right === void 0) return s;
-        return zod.z.intersection(recurse(left), recurse(right));
+        return z.intersection(recurse(left), recurse(right));
       }
       case "catch": {
         const inner = unwrapInner(s);
         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":
@@ -811,235 +680,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(zod.z.object(next), schema, stripConfig);
-    }
-    case "array": {
-      const element = getArrayElement(schema);
-      return carryChecks(
-        zod.z.array(walkSlim(element, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return carryChecks(
-        zod.z.set(walkSlim(valueType, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(
-        (it) => walkSlim(it, stripConfig, maxDepth, lazyDepth)
-      );
-      const rebuilt = zod.z.tuple(
-        items
-      );
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(schema);
-      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) => 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) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
-      );
-      const discriminator = getDiscriminator(schema);
-      if (discriminator === void 0) return schema;
-      return zod.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 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(
-        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 walkFieldMeta.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 = walkFieldMeta.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 = serializeScript.getAtPath(merged, pathSegments);
-    const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
-    if (slimKinds.size > 0 && slimKinds.has(serializeScript.slimKindOf(valueAtPath))) {
-      continue;
-    }
-    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth);
-    if (fixValue === SKIP) continue;
-    fixedData = pathSegments.length === 0 ? fixValue : serializeScript.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;
@@ -1127,7 +771,7 @@ function isLeafRequired(schema, depth = 0) {
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
   assertSupportedKinds(rootSchema);
-  return (formKey, options) => walkFieldMeta.createAbstractSchema(
+  return (formKey, options) => createAbstractSchema(
     rootSchema,
     V4_INTROSPECTOR,
     buildV4Services(),
@@ -1136,7 +780,7 @@ function zodV4Adapter(rootSchema) {
   );
 }
 async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.cjs');
+  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.mjs');
   return fingerprintZodSchema(schema);
 }
 function buildV4Services() {
@@ -1155,7 +799,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 };
@@ -1188,7 +832,7 @@ function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth)
     }
     return {
       data,
-      errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+      errors: zodIssuesToValidationErrors(strictResult.error.issues),
       success: false,
       formKey
     };
@@ -1219,7 +863,7 @@ function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
       }
       return {
         data: void 0,
-        errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+        errors: zodIssuesToValidationErrors(result.error.issues),
         success: false,
         formKey
       };
@@ -1232,25 +876,25 @@ function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
   const target = candidates[0];
   if (target === void 0) {
     return {
-      label: serializeScript.humanize(lastSegment),
+      label: humanize(lastSegment),
       description: void 0,
       placeholder: void 0,
       meta: Object.freeze({})
     };
   }
-  const pathMap = walkFieldMeta.getFieldMetaPathMap(rootSchema, {
+  const pathMap = buildFieldMetaPathMap(rootSchema, {
     intro: V4_INTROSPECTOR,
     peelAllWrappers,
-    getFieldMetaList
+    getFieldMetaList: getFieldMetaListForSchema
   });
-  const pathKey = devtoolsShared.canonicalizePath(path).key;
+  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;
   return {
-    label: payload?.label ?? serializeScript.humanize(lastSegment),
+    label: payload?.label ?? humanize(lastSegment),
     description: payload?.description ?? schemaDescription ?? void 0,
     placeholder: payload?.placeholder ?? void 0,
     meta: Object.freeze({ ...payload ?? {} })
@@ -1264,39 +908,13 @@ function readDescription(schema) {
 function useForm(configuration) {
   const candidate = configuration;
   if (candidate === void 0 || candidate === null || candidate.schema === void 0) {
-    throw new devtoolsShared.InvalidUseFormConfigError();
+    throw new InvalidUseFormConfigError();
   }
   const adapter = zodV4Adapter(configuration.schema);
-  return serializeScript.useAbstractForm({
+  return useAbstractForm({
     ...configuration,
     schema: adapter
   });
 }
 
-exports.UnsupportedSchemaError = UnsupportedSchemaError;
-exports.assertZodVersion = assertZodVersion;
-exports.fieldMeta = fieldMeta;
-exports.getArrayElement = getArrayElement;
-exports.getCatchDefault = getCatchDefault;
-exports.getChecks = getChecks;
-exports.getDefaultValue = getDefaultValue;
-exports.getDiscriminatedOptions = getDiscriminatedOptions;
-exports.getDiscriminator = getDiscriminator;
-exports.getEnumValues = getEnumValues;
-exports.getIntersectionLeft = getIntersectionLeft;
-exports.getIntersectionRight = getIntersectionRight;
-exports.getLiteralValues = getLiteralValues;
-exports.getObjectShape = getObjectShape;
-exports.getRecordKeyType = getRecordKeyType;
-exports.getRecordValueType = getRecordValueType;
-exports.getSetValueType = getSetValueType;
-exports.getTupleItems = getTupleItems;
-exports.getUnionOptions = getUnionOptions;
-exports.kindOf = kindOf;
-exports.unwrapInner = unwrapInner;
-exports.unwrapLazy = unwrapLazy;
-exports.unwrapPipe = unwrapPipe;
-exports.useForm = useForm;
-exports.withMeta = withMeta;
-exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.Crv0RNiz.cjs.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 };