attaform 0.19.0 → 0.20.1

package/dist/shared/{attaform.JBx8cfMA.cjs → attaform.BrrXNmfK.cjs}

@@ -1,22 +1,22 @@
 'use strict';
 
-const injectWizard = require('./attaform.C1msmO2v.cjs');
-const paths = require('./attaform.BqEfHpVB.cjs');
-const fieldMetaStore = require('./attaform.C8CyvYa_.cjs');
+const injectWizard = require('./attaform.DLnE5bZa.cjs');
+const paths = require('./attaform.BPy-4qRx.cjs');
+const walkSlimPrimitives = require('./attaform.DHRWn-cu.cjs');
 const zod = require('zod');
 
-const fieldMeta = fieldMetaStore.fieldMetaStore;
+const fieldMeta = walkSlimPrimitives.fieldMetaStore;
 function getFieldMetaList(schema) {
-  return fieldMetaStore.getFieldMetaListForSchema(schema);
+  return walkSlimPrimitives.getFieldMetaListForSchema(schema);
 }
 function withMeta(schema, payload) {
-  const existing = fieldMetaStore.getFieldMetaForSchema(schema) ?? {};
+  const existing = walkSlimPrimitives.getFieldMetaForSchema(schema) ?? {};
   const cloned = schema.clone();
-  fieldMetaStore.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  walkSlimPrimitives.fieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function getFieldMeta(schema) {
-  return fieldMetaStore.getFieldMetaForSchema(schema);
+  return walkSlimPrimitives.getFieldMetaForSchema(schema);
 }
 
 let warnedZodCodeMissing = false;
@@ -127,6 +127,12 @@ function kindOf(schema) {
       return "template-literal";
     case "file":
       return "file";
+    case "map":
+      return "map";
+    case "symbol":
+      return "symbol";
+    case "function":
+      return "function";
     default:
       return "unknown";
   }
@@ -184,6 +190,11 @@ function unwrapPipeIn(schema) {
 function isCoercePrimitive(schema) {
   return readDef(schema)?.coerce === true;
 }
+function isPreprocessNode(schema) {
+  if (kindOf(schema) !== "pipe") return false;
+  const pipeIn = unwrapPipeIn(schema);
+  return pipeIn !== void 0 && kindOf(pipeIn) === "transform";
+}
 function unwrapPipeOut(schema) {
   const def = readDef(schema);
   return def?.out;
@@ -216,10 +227,23 @@ function getCatchDefault(schema) {
     return void 0;
   }
 }
+function hasCatchValue(schema) {
+  const def = readDef(schema);
+  return typeof def?.catchValue === "function";
+}
 function getDefaultValue(schema) {
   const def = readDef(schema);
   return def?.defaultValue;
 }
+function getNativeEnumValues(_schema) {
+  return void 0;
+}
+function unwrapEffectsSource(_schema) {
+  return void 0;
+}
+function unwrapBranded(_schema) {
+  return void 0;
+}
 function hasChecks(schema) {
   const def = readDef(schema);
   const checks = def?.checks;
@@ -247,134 +271,97 @@ function assertZodVersion(schema) {
     );
   }
 }
-function containsAsyncRefine(schema, seen) {
+function walkSchemaTree(schema, visit, seen) {
   const visited = seen ?? /* @__PURE__ */ new WeakSet();
   const candidate = schema;
   if (typeof candidate !== "object" || candidate === null) return false;
   if (visited.has(candidate)) return false;
   visited.add(candidate);
-  const checks = getChecks(schema);
-  for (const check of checks) {
-    if (isAsyncCheck(check)) return true;
-  }
+  if (visit(schema)) return true;
   const def = readDef(schema);
   if (def === void 0) return false;
-  if (def.innerType !== void 0 && containsAsyncRefine(def.innerType, visited)) {
-    return true;
-  }
-  if (def.element !== void 0 && containsAsyncRefine(def.element, visited)) {
+  if (def.innerType !== void 0 && walkSchemaTree(def.innerType, visit, visited)) {
     return true;
   }
-  if (def.in !== void 0 && containsAsyncRefine(def.in, visited)) {
+  if (def.element !== void 0 && walkSchemaTree(def.element, visit, visited)) {
     return true;
   }
-  if (def.out !== void 0 && containsAsyncRefine(def.out, visited)) {
+  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.left !== void 0 && containsAsyncRefine(def.left, visited)) {
-    return true;
-  }
-  if (def.right !== void 0 && containsAsyncRefine(def.right, visited)) {
-    return true;
-  }
-  if (def.keyType !== void 0 && containsAsyncRefine(def.keyType, visited)) {
-    return true;
-  }
-  if (def.valueType !== void 0 && containsAsyncRefine(def.valueType, visited)) {
+  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 (containsAsyncRefine(sub, visited)) return true;
+      if (walkSchemaTree(sub, visit, visited)) return true;
     }
   }
   if (def.entries !== void 0) {
     for (const sub of Object.values(def.entries)) {
-      if (containsAsyncRefine(sub, visited)) return true;
+      if (walkSchemaTree(sub, visit, visited)) return true;
     }
   }
   if (def.options !== void 0) {
     for (const sub of def.options) {
-      if (containsAsyncRefine(sub, visited)) return true;
+      if (walkSchemaTree(sub, visit, visited)) return true;
     }
   }
   if (def.items !== void 0) {
     for (const sub of def.items) {
-      if (containsAsyncRefine(sub, visited)) return true;
+      if (walkSchemaTree(sub, visit, visited)) return true;
     }
   }
   if (typeof def.getter === "function") {
     try {
       const inner = def.getter();
-      if (containsAsyncRefine(inner, visited)) return true;
+      if (walkSchemaTree(inner, visit, visited)) return true;
     } catch {
     }
   }
   return false;
 }
+function containsAsyncRefine(schema, seen) {
+  return walkSchemaTree(
+    schema,
+    (node) => {
+      for (const check of getChecks(node)) {
+        if (isAsyncCheck(check)) return true;
+      }
+      return false;
+    },
+    seen
+  );
+}
+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;
+      return getChecks(node).length > 0;
+    },
+    seen
+  );
+}
 function containsAsyncTransform(schema, seen) {
-  const visited = seen ?? /* @__PURE__ */ new WeakSet();
-  const candidate = schema;
-  if (typeof candidate !== "object" || candidate === null) return false;
-  if (visited.has(candidate)) return false;
-  visited.add(candidate);
-  const def = readDef(schema);
-  if (def === void 0) return false;
-  if (typeof def.transform === "function" && def.transform.constructor.name === "AsyncFunction") {
-    return true;
-  }
-  if (def.innerType !== void 0 && containsAsyncTransform(def.innerType, visited)) {
-    return true;
-  }
-  if (def.element !== void 0 && containsAsyncTransform(def.element, visited)) {
-    return true;
-  }
-  if (def.in !== void 0 && containsAsyncTransform(def.in, visited)) {
-    return true;
-  }
-  if (def.out !== void 0 && containsAsyncTransform(def.out, visited)) {
-    return true;
-  }
-  if (def.left !== void 0 && containsAsyncTransform(def.left, visited)) {
-    return true;
-  }
-  if (def.right !== void 0 && containsAsyncTransform(def.right, visited)) {
-    return true;
-  }
-  if (def.keyType !== void 0 && containsAsyncTransform(def.keyType, visited)) {
-    return true;
-  }
-  if (def.valueType !== void 0 && containsAsyncTransform(def.valueType, visited)) {
-    return true;
-  }
-  if (def.shape !== void 0) {
-    for (const sub of Object.values(def.shape)) {
-      if (containsAsyncTransform(sub, visited)) return true;
-    }
-  }
-  if (def.entries !== void 0) {
-    for (const sub of Object.values(def.entries)) {
-      if (containsAsyncTransform(sub, visited)) return true;
-    }
-  }
-  if (def.options !== void 0) {
-    for (const sub of def.options) {
-      if (containsAsyncTransform(sub, visited)) return true;
-    }
-  }
-  if (def.items !== void 0) {
-    for (const sub of def.items) {
-      if (containsAsyncTransform(sub, visited)) return true;
-    }
-  }
-  if (typeof def.getter === "function") {
-    try {
-      const inner = def.getter();
-      if (containsAsyncTransform(inner, visited)) return true;
-    } catch {
-    }
-  }
-  return false;
+  return walkSchemaTree(
+    schema,
+    (node) => {
+      const def = readDef(node);
+      if (def === void 0) return false;
+      const fn = def.transform;
+      if (typeof fn !== "function") return false;
+      return fn.constructor.name === "AsyncFunction";
+    },
+    seen
+  );
 }
 function isAsyncCheck(check) {
   if (typeof check !== "object" || check === null) return false;
@@ -384,7 +371,14 @@ function isAsyncCheck(check) {
   return fn.constructor.name === "AsyncFunction";
 }
 
-const UNSUPPORTED = ["promise", "custom", "template-literal"];
+const UNSUPPORTED = [
+  "promise",
+  "custom",
+  "template-literal",
+  "map",
+  "symbol",
+  "function"
+];
 function labelPath(path) {
   return path.length === 0 ? "<root>" : path.join(".");
 }
@@ -481,6 +475,9 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
     case "template-literal":
     case "transform":
     case "file":
+    case "map":
+    case "symbol":
+    case "function":
       return;
     default: {
       const _exhaustive = kind;
@@ -495,7 +492,7 @@ function unwrapToDiscriminatedUnion(schema) {
     const kind = kindOf(current);
     if (kind === "discriminated-union") return current;
     let next;
-    if (kind === "optional" || kind === "nullable" || kind === "default" || kind === "readonly") {
+    if (kind === "optional" || kind === "nullable" || kind === "default" || kind === "readonly" || kind === "catch") {
       next = unwrapInner(current);
     } else if (kind === "pipe") {
       next = unwrapPipe(current);
@@ -631,12 +628,17 @@ function computeFingerprint(schema, cache, inProgress) {
     // Structural shape isn't observable for these. Bucket them into
     // kind-only fingerprints — a schema-mismatch warning can't do
     // better than "both are `custom`" here, but that still catches
-    // `object` vs `custom` mismatches.
+    // `object` vs `custom` mismatches. `map` / `symbol` / `function`
+    // are rejected at adapter construction; kept here for exhaustive
+    // switch safety when `fingerprintSchema` is called from tooling.
     case "promise":
     case "custom":
     case "template-literal":
     case "transform":
     case "file":
+    case "map":
+    case "symbol":
+    case "function":
       return `${kind}:*`;
     default: {
       const _ = kind;
@@ -703,270 +705,61 @@ function compare(a, b) {
   return as < bs ? -1 : as > bs ? 1 : 0;
 }
 
-const PERMISSIVE = /* @__PURE__ */ new Set([
-  "string",
-  "number",
-  "boolean",
-  "bigint",
-  "date",
-  "null",
-  "undefined",
-  "object",
-  "array",
-  "symbol",
-  "function",
-  "map",
-  "set",
-  "file"
-]);
-const KIND_STRING = /* @__PURE__ */ new Set(["string"]);
-const KIND_NUMBER = /* @__PURE__ */ new Set(["number"]);
-const KIND_BOOLEAN = /* @__PURE__ */ new Set(["boolean"]);
-const KIND_BIGINT = /* @__PURE__ */ new Set(["bigint"]);
-const KIND_DATE = /* @__PURE__ */ new Set(["date"]);
-const KIND_NULL = /* @__PURE__ */ new Set(["null"]);
-const KIND_UNDEFINED = /* @__PURE__ */ new Set(["undefined"]);
-const KIND_OBJECT = /* @__PURE__ */ new Set(["object"]);
-const KIND_ARRAY = /* @__PURE__ */ new Set(["array"]);
-const KIND_SET = /* @__PURE__ */ new Set(["set"]);
-const KIND_FILE = /* @__PURE__ */ new Set(["file", "null"]);
-const EMPTY_KINDS = /* @__PURE__ */ new Set();
+const V4_INTROSPECTOR = {
+  kindOf: (schema) => kindOf(schema),
+  getObjectShape: (schema) => getObjectShape(schema),
+  getTupleItems: (schema) => getTupleItems(schema),
+  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
+  getDiscriminator: (schema) => getDiscriminator(schema),
+  getLiteralValues: (schema) => getLiteralValues(schema),
+  isPreprocessNode: (schema) => isPreprocessNode(schema),
+  isCoercePrimitive: (schema) => isCoercePrimitive(schema),
+  containsAsyncRefine: (schema) => containsAsyncRefine(schema),
+  containsAsyncTransform: (schema) => containsAsyncTransform(schema),
+  hasContainerOrRootRefine: (schema) => hasContainerOrRootRefine(schema),
+  // Walker accessors (D2 / D3 / D5).
+  getArrayElement: (schema) => {
+    if (kindOf(schema) !== "array") return void 0;
+    return getArrayElement(schema);
+  },
+  getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
+  getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
+  getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
+  getUnionOptions: (schema) => getUnionOptions(schema),
+  getIntersectionLeft: (schema) => getIntersectionLeft(schema),
+  getIntersectionRight: (schema) => getIntersectionRight(schema),
+  getEnumValues: (schema) => getEnumValues(schema),
+  getNativeEnumValues: (schema) => getNativeEnumValues(),
+  unwrapInner: (schema) => unwrapInner(schema),
+  unwrapBranded: (schema) => unwrapBranded(),
+  unwrapEffectsSource: (schema) => unwrapEffectsSource(),
+  unwrapPipeIn: (schema) => unwrapPipeIn(schema),
+  unwrapPipeOut: (schema) => unwrapPipeOut(schema),
+  unwrapLazy: (schema) => unwrapLazy(schema),
+  getLazyGetter: (schema) => getLazyGetter(schema),
+  getDefaultValue: (schema) => getDefaultValue(schema),
+  getCatchDefault: (schema) => getCatchDefault(schema),
+  hasCatchValue: (schema) => hasCatchValue(schema)
+};
+
 function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return new Set(walk(schema, 0, maxRecursionDepth));
-}
-function walk(schema, lazyDepth, maxDepth) {
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "string":
-      return KIND_STRING;
-    case "number":
-    case "nan":
-      return KIND_NUMBER;
-    case "boolean":
-      return KIND_BOOLEAN;
-    case "bigint":
-      return KIND_BIGINT;
-    case "date":
-      return KIND_DATE;
-    case "file":
-      return KIND_FILE;
-    case "null":
-      return KIND_NULL;
-    case "undefined":
-    case "void":
-      return KIND_UNDEFINED;
-    case "enum": {
-      const values = getEnumValues(schema);
-      const out = /* @__PURE__ */ new Set();
-      for (const v of values) {
-        if (typeof v === "string") out.add("string");
-        else if (typeof v === "number") out.add("number");
-      }
-      return out.size === 0 ? KIND_STRING : out;
-    }
-    case "literal": {
-      const values = getLiteralValues(schema);
-      const out = /* @__PURE__ */ new Set();
-      for (const v of values) out.add(slimKindOfRaw(v));
-      return out.size === 0 ? PERMISSIVE : out;
-    }
-    case "object":
-    case "record":
-      return KIND_OBJECT;
-    case "array":
-    case "tuple":
-      return KIND_ARRAY;
-    case "set":
-      return KIND_SET;
-    case "optional": {
-      const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
-      const out = new Set(innerSet);
-      out.add("undefined");
-      return out;
-    }
-    case "nullable": {
-      const inner = unwrapInner(schema);
-      const innerSet = inner === void 0 ? EMPTY_KINDS : walk(inner, lazyDepth, maxDepth);
-      const out = new Set(innerSet);
-      out.add("null");
-      return out;
-    }
-    case "default":
-    case "readonly":
-    case "catch": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
-    }
-    case "pipe": {
-      const pipeIn = unwrapPipeIn(schema);
-      const pipeOut = unwrapPipeOut(schema);
-      const inner = pipeIn !== void 0 && kindOf(pipeIn) === "transform" ? pipeOut : pipeIn ?? pipeOut;
-      return inner === void 0 ? PERMISSIVE : walk(inner, lazyDepth, maxDepth);
-    }
-    case "lazy": {
-      if (lazyDepth >= maxDepth) return PERMISSIVE;
-      const inner = unwrapLazy(schema);
-      return inner === void 0 ? 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, lazyDepth, maxDepth)) out.add(k);
-      }
-      return out.size === 0 ? PERMISSIVE : out;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      const leftSet = left === void 0 ? PERMISSIVE : walk(left, lazyDepth, maxDepth);
-      const rightSet = right === void 0 ? PERMISSIVE : walk(right, lazyDepth, maxDepth);
-      const out = /* @__PURE__ */ new Set();
-      for (const k of leftSet) if (rightSet.has(k)) out.add(k);
-      return out;
-    }
-    case "never":
-      return EMPTY_KINDS;
-    case "any":
-    case "unknown":
-      return PERMISSIVE;
-    // Kinds we don't understand at the slim level: be permissive to
-    // avoid false-rejecting legitimate writes against schema shapes
-    // we haven't characterised.
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-      return PERMISSIVE;
-    default:
-      return PERMISSIVE;
-  }
-}
-function slimKindOfRaw(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (Array.isArray(value)) return "array";
-  if (value instanceof Date) return "date";
-  const t = typeof value;
-  switch (t) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "bigint":
-      return "bigint";
-    case "symbol":
-      return "symbol";
-    case "undefined":
-      return "undefined";
-    case "object":
-      return "object";
-    case "function":
-      return "function";
-    default:
-      return "object";
-  }
+  return new Set(walkSlimPrimitives.slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
 }
 
-const PATH_SEPARATOR$1 = ".";
+const PATH_SEPARATOR = ".";
 function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
-  if (Array.isArray(path)) return walkSegments(schema, path.map(String), maxRecursionDepth, 0);
+  if (Array.isArray(path)) {
+    return walkSlimPrimitives.walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
+  }
   const pathString = path;
   if (pathString.length === 0) return [schema];
-  return walkSegments(schema, pathString.split(PATH_SEPARATOR$1), maxRecursionDepth, 0);
-}
-function walkSegments(schema, segments, maxDepth, lazyDepth) {
-  if (segments.length === 0) return [schema];
-  const [head, ...rest] = segments;
-  if (head === void 0) return [schema];
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "object": {
-      const shape = getObjectShape(schema);
-      if (!Object.hasOwn(shape, head)) return [];
-      const next = shape[head];
-      return next === void 0 ? [] : walkSegments(next, rest, maxDepth, lazyDepth);
-    }
-    case "array":
-      return walkSegments(getArrayElement(schema), rest, maxDepth, lazyDepth);
-    case "set":
-      return walkSegments(getSetValueType(schema), rest, maxDepth, lazyDepth);
-    case "record":
-      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, maxDepth, lazyDepth);
-    }
-    case "union":
-      return getUnionOptions(schema).flatMap(
-        (opt) => walkSegments(opt, segments, maxDepth, lazyDepth)
-      );
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema);
-      const matching = options.filter((opt) => {
-        const shape = getObjectShape(opt);
-        return Object.hasOwn(shape, head);
-      });
-      const candidates = matching.length > 0 ? matching : options;
-      return candidates.flatMap((opt) => walkSegments(opt, segments, maxDepth, lazyDepth));
-    }
-    case "optional":
-    case "nullable":
-    case "default":
-    case "readonly":
-    case "catch": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? [] : walkSegments(inner, segments, maxDepth, lazyDepth);
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      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, maxDepth, lazyDepth + 1);
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      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.
-    case "string":
-    case "number":
-    case "bigint":
-    case "boolean":
-    case "undefined":
-    case "null":
-    case "void":
-    case "never":
-    case "any":
-    case "unknown":
-    case "date":
-    case "enum":
-    case "literal":
-    case "nan":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-      return [];
-    default: {
-      const _exhaustive = kind;
-      throw new Error(`walkSegments: unhandled ZodKind '${_exhaustive}'`);
-    }
-  }
+  return walkSlimPrimitives.walkPathSegments(
+    schema,
+    pathString.split(PATH_SEPARATOR),
+    V4_INTROSPECTOR,
+    maxRecursionDepth,
+    0
+  );
 }
 
 function carryChecks(rebuilt, original, stripConfig) {
@@ -1074,6 +867,9 @@ function stripRefinements(schema) {
     case "template-literal":
     case "transform":
     case "file":
+    case "map":
+    case "symbol":
+    case "function":
       return schema;
     default: {
       const _exhaustive = kind;
@@ -1199,6 +995,9 @@ function stripAsyncChecks(schema) {
       case "template-literal":
       case "transform":
       case "file":
+      case "map":
+      case "symbol":
+      case "function":
         return s;
       default: {
         const _exhaustive = kind;
@@ -1320,6 +1119,9 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
     case "promise":
     case "custom":
     case "template-literal":
+    case "map":
+    case "symbol":
+    case "function":
       return schema;
     case "lazy": {
       if (lazyDepth >= maxDepth) return schema;
@@ -1353,164 +1155,22 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
   }
 }
 
-function hasDeclaredDefaultInChain(schema) {
-  let current = schema;
-  for (let i = 0; i < 32; i++) {
-    if (current === void 0) return false;
-    const k = kindOf(current);
-    if (k === "default") return true;
-    if (k === "optional" || k === "nullable" || k === "readonly" || k === "catch") {
-      current = unwrapInner(current);
-      continue;
-    }
-    return false;
-  }
-  return false;
-}
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return defaultForKind(kindOf(schema), schema, useDefault, maxRecursionDepth, 0);
-}
-function defaultForKind(kind, schema, useDefault, maxDepth, lazyDepth) {
-  if (isCoercePrimitive(schema)) return void 0;
-  switch (kind) {
-    case "object": {
-      const shape = getObjectShape(schema);
-      const out = {};
-      for (const [key, subSchema] of Object.entries(shape)) {
-        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 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
-    }
-    case "optional":
-      return void 0;
-    case "nullable":
-      return null;
-    case "readonly": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? void 0 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
-    }
-    case "pipe": {
-      const inn = unwrapPipeIn(schema);
-      if (inn !== void 0 && kindOf(inn) === "transform") {
-        const out2 = unwrapPipeOut(schema);
-        if (out2 !== void 0 && hasDeclaredDefaultInChain(out2)) {
-          return defaultForKind(kindOf(out2), out2, useDefault, maxDepth, lazyDepth);
-        }
-        return void 0;
-      }
-      const out = unwrapPipeOut(schema);
-      const real = inn !== void 0 && kindOf(inn) !== "transform" ? inn : out !== void 0 && kindOf(out) !== "transform" ? out : inn ?? out;
-      return real === void 0 ? void 0 : defaultForKind(kindOf(real), real, useDefault, maxDepth, lazyDepth);
-    }
-    case "array":
-      return [];
-    case "set":
-      return /* @__PURE__ */ new Set();
-    case "record":
-      return {};
-    case "tuple": {
-      const items = getTupleItems(schema);
-      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 : defaultForKind(kindOf(first), first, useDefault, maxDepth, lazyDepth);
-    }
-    case "discriminated-union": {
-      const first = getDiscriminatedUnionFirstOption(schema);
-      return first === void 0 ? void 0 : defaultForKind(kindOf(first), first, useDefault, maxDepth, lazyDepth);
-    }
-    case "string":
-      return "";
-    case "number":
-      return 0;
-    case "bigint":
-      return 0n;
-    case "boolean":
-      return false;
-    case "date":
-      return /* @__PURE__ */ new Date(0);
-    case "null":
-      return null;
-    case "undefined":
-      return void 0;
-    case "enum": {
-      const values = getEnumValues(schema);
-      return values[0];
-    }
-    case "literal": {
-      const values = getLiteralValues(schema);
-      return values[0];
-    }
-    case "nan":
-      return NaN;
-    case "lazy": {
-      if (lazyDepth >= maxDepth) return void 0;
-      let inner;
-      try {
-        inner = unwrapLazy(schema);
-      } catch {
-        return void 0;
-      }
-      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 : 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 : defaultForKind(kindOf(inner), inner, useDefault, maxDepth, lazyDepth);
-    }
-    case "any":
-    case "unknown":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-      return void 0;
-    case "file":
-      return null;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(`deriveDefault: unhandled ZodKind '${_exhaustive}'`);
-    }
-  }
-}
-function mergeDeep(base, override) {
-  if (override === void 0) return base;
-  if (!injectWizard.isPlainRecord(override)) return override;
-  if (!injectWizard.isPlainRecord(base)) return override;
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const oVal = override[key];
-    const bVal = base[key];
-    if (injectWizard.isPlainRecord(oVal) && injectWizard.isPlainRecord(bVal)) {
-      result[key] = mergeDeep(bVal, oVal);
-    } else {
-      result[key] = oVal;
-    }
-  }
-  return result;
+  return walkSlimPrimitives.deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
+    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
+    // unknown kinds genuinely shouldn't appear, so return undefined.
+    unsupportedKindFallback: () => void 0,
+    // v4 historically recurses into the inner on `useDefault=false`
+    // so a `.catch(v)` slot returns the leaf empty rather than the
+    // fallback. Pinned by `test/adapters/zod-v4/unsupported-kinds.test.ts`
+    // (`z.catch falls through to inner leaf default when useDefault=false`).
+    catchOnUseDefaultFalse: "recurseInner"
+  });
 }
 function getDefaultValuesFromZodSchema(opts) {
   const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
   const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
-  const merged = mergeDeep(initial, constraints);
+  const merged = walkSlimPrimitives.mergeDeep(initial, constraints);
   const slimSchema = getSlimSchema(
     schema,
     {
@@ -1573,7 +1233,6 @@ function defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursion
   return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
 }
 
-const PATH_SEPARATOR = ".";
 function unwrapStructuralWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -1660,297 +1319,99 @@ function isLeafRequired(schema, depth = 0) {
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
   assertSupportedKinds(rootSchema);
-  return (formKey, options) => {
-    const maxRecursionDepth = options.maxRecursionDepth;
-    const leafCache = /* @__PURE__ */ new Map();
-    const preprocessOrCoerceCache = /* @__PURE__ */ new Map();
-    let asyncValidationFlag = null;
+  return (formKey, options) => walkSlimPrimitives.createAbstractSchema(
+    rootSchema,
+    V4_INTROSPECTOR,
+    buildV4Services(),
+    formKey,
+    options
+  );
+}
+function buildV4Services() {
+  return {
+    fingerprint: (schema) => fingerprintZodSchema(schema),
+    getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    // v4 doesn't pre-strip for the slim-mode walk — its path walker
+    // already peels every transparent wrapper inline, so the slim and
+    // unstripped walks coincide.
+    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
+    deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
+    runStrictGetDefaults: (schema, config, fk, maxRecursionDepth) => runStrictGetDefaultsV4(schema, config, fk, maxRecursionDepth),
+    unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
+    unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
+    peelAllWrappers: (schema) => peelAllWrappers(schema),
+    isLeafRequired: (schema) => isLeafRequired(schema),
+    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPath(schema, path, maxRecursionDepth),
+    issuesToValidationErrors: (issues, fk) => zodIssuesToValidationErrors(issues, fk),
+    safeParseSync: (schema, data) => {
+      const result = schema.safeParse(data);
+      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+    },
+    safeParseAsync: async (schema, data) => {
+      const result = await schema.safeParseAsync(data);
+      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
+    },
+    makeSubSchema: (schema, fk, maxRecursionDepth) => buildSubSchemaStubV4(schema, fk, maxRecursionDepth)
+  };
+}
+function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth) {
+  const { data } = getDefaultValuesFromZodSchema({
+    schema: rootSchema,
+    useDefaultSchemaValues: config.useDefaultSchemaValues,
+    constraints: config.constraints,
+    maxRecursionDepth
+  });
+  if (config.strict === false) {
+    return { data, errors: void 0, success: true, formKey };
+  }
+  if (containsAsyncTransform(rootSchema)) {
+    return { data, errors: void 0, success: true, formKey };
+  }
+  const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
+  try {
+    const strictResult = parseTarget.safeParse(data);
+    if (strictResult.success) {
+      return { data, errors: void 0, success: true, formKey };
+    }
     return {
-      fingerprint: () => fingerprintZodSchema(rootSchema),
-      needsAsyncValidation() {
-        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema) || containsAsyncTransform(rootSchema));
-        return asyncValidationFlag;
-      },
-      getDefaultValues(config) {
-        const { data } = getDefaultValuesFromZodSchema({
-          schema: rootSchema,
-          useDefaultSchemaValues: config.useDefaultSchemaValues,
-          constraints: config.constraints,
-          maxRecursionDepth
-        });
-        if (config.strict !== false) {
-          if (containsAsyncTransform(rootSchema)) {
-            return { data, errors: void 0, success: true, formKey };
-          }
-          const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
-          try {
-            const strictResult = parseTarget.safeParse(
-              data
-            );
-            if (strictResult.success) {
-              return { data, errors: void 0, success: true, formKey };
-            }
-            return {
-              data,
-              errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
-              success: false,
-              formKey
-            };
-          } catch {
-            return { data, errors: void 0, success: true, formKey };
-          }
-        }
-        return { data, errors: void 0, success: true, formKey };
-      },
-      getDefaultAtPath(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, maxRecursionDepth);
-      },
-      getEmptyValueAtPath(path) {
-        if (path.length === 0) return deriveDefault(rootSchema, false, maxRecursionDepth);
-        const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        if (first === void 0) return void 0;
-        return deriveDefault(first, false, maxRecursionDepth);
-      },
-      arrayShapeAtPath(path) {
-        if (path.length === 0) return void 0;
-        const [first] = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        if (first === void 0) return void 0;
-        const peeled = peelAllWrappers(first);
-        const kind = kindOf(peeled);
-        if (kind === "tuple") return getTupleItems(peeled).length;
-        if (kind === "array") return null;
-        return void 0;
-      },
-      getSchemasAtPath(path) {
-        const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        return resolved.map(
-          (schema) => ({
-            fingerprint: () => fingerprintZodSchema(schema),
-            needsAsyncValidation: () => containsAsyncRefine(schema),
-            getDefaultValues: () => ({
-              data: deriveDefault(schema, true, maxRecursionDepth),
-              errors: void 0,
-              success: true,
-              formKey
-            }),
-            getSchemasAtPath: () => [],
-            validateAtPath: async (data) => {
-              const result = await schema.safeParseAsync(data);
-              if (result.success) {
-                return { data: result.data, errors: void 0, success: true, formKey };
-              }
-              return {
-                data: void 0,
-                errors: zodIssuesToValidationErrors(result.error.issues, formKey),
-                success: false,
-                formKey
-              };
-            }
-          })
-        );
-      },
-      getSlimPrimitiveTypesAtPath(path) {
-        if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
-        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, maxRecursionDepth)) out.add(k);
-        }
-        return out;
-      },
-      isLeafAtPath(path) {
-        const cacheKey = paths.canonicalizePath(path).key;
-        const cached = leafCache.get(cacheKey);
-        if (cached !== void 0) return cached;
-        const prim = this.getSlimPrimitiveTypesAtPath(path);
-        const isLeaf = prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
-        leafCache.set(cacheKey, isLeaf);
-        return isLeaf;
-      },
-      isPreprocessOrCoerceLeaf(path) {
-        const cacheKey = paths.canonicalizePath(path).key;
-        const cached = preprocessOrCoerceCache.get(cacheKey);
-        if (cached !== void 0) return cached;
-        let hit = false;
-        for (let i = 0; i <= path.length && !hit; i++) {
-          const prefix = path.slice(0, i);
-          const candidates = prefix.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, prefix, maxRecursionDepth);
-          for (const candidate of candidates) {
-            if (isCoercePrimitive(candidate)) {
-              hit = true;
-              break;
-            }
-            if (kindOf(candidate) !== "pipe") continue;
-            const pipeIn = unwrapPipeIn(candidate);
-            if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") {
-              hit = true;
-              break;
-            }
-          }
-        }
-        preprocessOrCoerceCache.set(cacheKey, hit);
-        return hit;
-      },
-      isRequiredAtPath(path) {
-        if (path.length === 0) return true;
-        const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        if (resolved.length === 0) return false;
-        return resolved.every((candidate) => isLeafRequired(candidate));
-      },
-      getFieldMetaAtPath(path) {
-        return resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth);
-      },
-      getUnionDiscriminatorAtPath(path) {
-        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-        let matchedUnion;
-        for (const candidate of candidates) {
-          const du = unwrapToDiscriminatedUnion(candidate);
-          if (du === void 0) continue;
-          if (matchedUnion !== void 0 && matchedUnion !== du) return void 0;
-          matchedUnion = du;
-        }
-        if (matchedUnion === void 0) return void 0;
-        const discKey = getDiscriminator(matchedUnion);
-        if (discKey === void 0) return void 0;
-        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);
-        }
+      data,
+      errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+      success: false,
+      formKey
+    };
+  } catch {
+    return { data, errors: void 0, success: true, formKey };
+  }
+}
+function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
+  return {
+    fingerprint: () => fingerprintZodSchema(schema),
+    needsAsyncValidation: () => containsAsyncRefine(schema),
+    getDefaultValues: () => ({
+      data: deriveDefault(schema, true, maxRecursionDepth),
+      errors: void 0,
+      success: true,
+      formKey
+    }),
+    getSchemasAtPath: () => [],
+    validateAtPath: async (data) => {
+      const result = await schema.safeParseAsync(data);
+      if (result.success) {
         return {
-          discriminatorKey: discKey,
-          getVariantDefault(value) {
-            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, maxRecursionDepth);
-            }
-            return void 0;
-          },
-          isVariantSelected(value) {
-            return literalSet.has(value);
-          }
+          data: result.data,
+          errors: void 0,
+          success: true,
+          formKey
         };
-      },
-      validateAtPath(data, path, options2) {
-        const trySync = options2?.sync === true;
-        if (trySync) {
-          try {
-            return runSync();
-          } catch {
-          }
-        }
-        return runAsync();
-        function runSync() {
-          if (path === void 0) {
-            const result = rootSchema.safeParse(data);
-            return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
-              data: void 0,
-              errors: zodIssuesToValidationErrors(result.error.issues, formKey),
-              success: false,
-              formKey
-            };
-          }
-          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
-              };
-            }
-            aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
-          }
-          return { data: void 0, errors: aggregated, success: false, formKey };
-        }
-        async function runAsync() {
-          if (path === void 0) {
-            let result;
-            try {
-              result = await rootSchema.safeParseAsync(
-                data
-              );
-            } catch (err) {
-              return validatorThrewResponse(err, []);
-            }
-            return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
-              data: void 0,
-              errors: zodIssuesToValidationErrors(result.error.issues, formKey),
-              success: false,
-              formKey
-            };
-          }
-          const resolved = getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-          if (resolved.length === 0) return pathNotFound(path);
-          const aggregated = [];
-          for (const candidate of resolved) {
-            let result;
-            try {
-              result = await candidate.safeParseAsync(data);
-            } catch (err) {
-              return validatorThrewResponse(err, path);
-            }
-            if (result.success) {
-              return {
-                data: result.data,
-                errors: void 0,
-                success: true,
-                formKey
-              };
-            }
-            aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
-          }
-          return { data: void 0, errors: aggregated, success: false, formKey };
-        }
-        function validatorThrewResponse(err, errPath) {
-          const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Validator threw";
-          return {
-            data: void 0,
-            errors: [
-              {
-                message,
-                path: [...errPath],
-                formKey,
-                code: injectWizard.AttaformErrorCode.ValidatorThrew
-              }
-            ],
-            success: false,
-            formKey
-          };
-        }
-        function pathNotFound(p) {
-          return {
-            data: void 0,
-            errors: [
-              {
-                message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
-                path: [...p],
-                formKey,
-                code: injectWizard.AttaformErrorCode.PathNotFound
-              }
-            ],
-            success: false,
-            formKey
-          };
-        }
       }
-    };
+      return {
+        data: void 0,
+        errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+        success: false,
+        formKey
+      };
+    }
   };
 }
 const pathMetaCache = /* @__PURE__ */ new WeakMap();
@@ -2108,6 +1569,9 @@ function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress)
       case "template-literal":
       case "transform":
       case "file":
+      case "map":
+      case "symbol":
+      case "function":
         return;
     }
   } finally {
@@ -2172,4 +1636,4 @@ exports.kindOf = kindOf;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.JBx8cfMA.cjs.map
+//# sourceMappingURL=attaform.BrrXNmfK.cjs.map