attaform 0.20.2 → 0.21.1

package/dist/shared/{attaform.DAKrGhxc.cjs → attaform.BSkvn43g.cjs}

@@ -1,24 +1,59 @@
 'use strict';
 
-const lodashEs = require('lodash-es');
 const zod = require('zod');
-const walkSlimPrimitives = require('./attaform.B_hph5AE.cjs');
-const injectWizard = require('./attaform.CwLjUqmQ.cjs');
-const paths = require('./attaform.z5j3LwJz.cjs');
+const walkFieldMeta = require('./attaform.CICFZ1iS.cjs');
+const injectWizard = require('./attaform.ClXwitZj.cjs');
+const paths = require('./attaform.D32WwKk6.cjs');
 
-const fieldMeta = walkSlimPrimitives.fieldMetaStore;
+const fieldMeta = walkFieldMeta.fieldMetaStore;
 function withMeta(schema, payload) {
-  const existing = walkSlimPrimitives.getFieldMetaForSchema(schema) ?? {};
+  const existing = walkFieldMeta.getFieldMetaForSchema(schema) ?? {};
   const Ctor = schema.constructor;
   const cloned = new Ctor(schema._def);
-  walkSlimPrimitives.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function getFieldMeta(schema) {
-  return walkSlimPrimitives.getFieldMetaForSchema(schema);
+  return walkFieldMeta.getFieldMetaForSchema(schema);
 }
 function getFieldMetaList(schema) {
-  return walkSlimPrimitives.getFieldMetaListForSchema(schema);
+  return walkFieldMeta.getFieldMetaListForSchema(schema);
+}
+
+function cloneSchemaDeep(value) {
+  return clone(value, /* @__PURE__ */ new WeakMap());
+}
+function clone(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof RegExp) {
+    const copy2 = new RegExp(value.source, value.flags);
+    copy2.lastIndex = value.lastIndex;
+    seen.set(value, copy2);
+    return copy2;
+  }
+  if (value instanceof Date) {
+    const copy2 = new Date(value.getTime());
+    seen.set(value, copy2);
+    return copy2;
+  }
+  if (Array.isArray(value)) {
+    const copy2 = [];
+    seen.set(value, copy2);
+    for (let i = 0; i < value.length; i++) {
+      copy2[i] = clone(value[i], seen);
+    }
+    return copy2;
+  }
+  const copy = Object.create(Object.getPrototypeOf(value));
+  seen.set(value, copy);
+  const source = value;
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor?.enumerable !== true) continue;
+    copy[key] = clone(source[key], seen);
+  }
+  return copy;
 }
 
 class UnsupportedSchemaError extends paths.AttaformError {
@@ -201,10 +236,10 @@ function isAsyncEffect(schema) {
   return fn.constructor.name === "AsyncFunction";
 }
 function containsAsyncRefine(schema, seen) {
-  return walkForAsync(schema, "refinement", /* @__PURE__ */ new WeakSet());
+  return walkForAsync(schema, "refinement", seen ?? /* @__PURE__ */ new WeakSet());
 }
 function containsAsyncTransform(schema, seen) {
-  return walkForAsync(schema, "transform-or-preprocess", /* @__PURE__ */ new WeakSet());
+  return walkForAsync(schema, "transform-or-preprocess", seen ?? /* @__PURE__ */ new WeakSet());
 }
 function walkForAsync(schema, target, visited) {
   const candidate = schema;
@@ -527,258 +562,45 @@ function assertSupportedKinds(schema, path = [], lazyGetters = []) {
   }
 }
 
-const cyclicSentinel = "<cyclic>";
-function fingerprintZodSchema(schema) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  return visit(schema, cache, inProgress);
-}
-function visit(schema, cache, inProgress) {
-  const key = schema;
-  const cached = cache.get(key);
-  if (cached !== void 0) return cached;
-  if (inProgress.has(key)) return cyclicSentinel;
-  inProgress.add(key);
-  try {
-    const computed = computeFingerprint(schema, cache, inProgress);
-    cache.set(key, computed);
-    return computed;
-  } finally {
-    inProgress.delete(key);
-  }
-}
-function getDef(schema) {
-  return schema._def;
-}
-function computeFingerprint(schema, cache, inProgress) {
-  const def = getDef(schema);
-  const kind = def.typeName ?? "ZodUnknown";
-  const recurse = (child) => visit(child, cache, inProgress);
-  switch (kind) {
-    case "ZodString":
-    case "ZodNumber":
-    case "ZodBigInt":
-    case "ZodDate":
-      return `${kind}${formatChecks(def.checks)}`;
-    case "ZodBoolean":
-    case "ZodNull":
-    case "ZodUndefined":
-    case "ZodAny":
-    case "ZodUnknown":
-    case "ZodNaN":
-    case "ZodVoid":
-    case "ZodNever":
-      return kind;
-    case "ZodLiteral":
-      return `ZodLiteral:${canonicalStringify(def.value)}`;
-    case "ZodEnum": {
-      const values = Array.isArray(def.values) ? def.values : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodNativeEnum": {
-      const values = def.values && typeof def.values === "object" && !Array.isArray(def.values) ? Object.values(def.values) : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodNativeEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodObject": {
-      const shape = readShapeSafely(def);
-      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
-      return `ZodObject{${sortedEntries.join(",")}}${formatChecks(def.checks)}`;
-    }
-    case "ZodArray":
-      return `ZodArray[${def.type === void 0 ? "?" : recurse(def.type)}]${formatChecks(def.checks)}`;
-    case "ZodTuple": {
-      const items = def.items ?? [];
-      return `ZodTuple[${items.map(recurse).join(",")}]`;
-    }
-    case "ZodRecord": {
-      const keyPart = def.keyType === void 0 ? "?" : recurse(def.keyType);
-      const valuePart = def.valueType === void 0 ? "?" : recurse(def.valueType);
-      return `ZodRecord<${keyPart},${valuePart}>`;
-    }
-    case "ZodUnion": {
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodUnion(${options.join("|")})`;
-    }
-    case "ZodDiscriminatedUnion": {
-      const disc = def.discriminator ?? "?";
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodDiscriminatedUnion[${JSON.stringify(disc)}](${options.join("|")})`;
-    }
-    case "ZodOptional": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodOptional(?)" : `ZodOptional(${recurse(inner)})`;
-    }
-    case "ZodNullable": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodNullable(?)" : `ZodNullable(${recurse(inner)})`;
-    }
-    case "ZodDefault": {
-      const inner = def.innerType;
-      return `ZodDefault[${defaultFactoryRepr(def.defaultValue)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodReadonly": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodReadonly(?)" : `ZodReadonly(${recurse(inner)})`;
-    }
-    case "ZodEffects": {
-      const effectType = def.effect?.type ?? "effect";
-      const inner = def.schema;
-      return `ZodEffects:${effectType}:fn:*(${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodPipeline": {
-      const inner = def.in ?? def.out;
-      return inner === void 0 ? "ZodPipeline(?)" : `ZodPipeline(${recurse(inner)})`;
-    }
-    case "ZodCatch": {
-      const inner = def.innerType ?? def.schema;
-      const catchRepr = defaultFactoryRepr(def.catchValue);
-      return `ZodCatch[${catchRepr}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodLazy": {
-      const resolve = def.getter;
-      if (typeof resolve !== "function") return "ZodLazy(?)";
-      try {
-        const inner = resolve();
-        return `ZodLazy(${recurse(inner)})`;
-      } catch {
-        return "ZodLazy(?)";
-      }
-    }
-    case "ZodIntersection": {
-      const leftPart = def.left === void 0 ? "?" : recurse(def.left);
-      const rightPart = def.right === void 0 ? "?" : recurse(def.right);
-      const parts = [leftPart, rightPart].sort();
-      return `ZodIntersection(${parts.join("&")})`;
-    }
-    case "ZodSet": {
-      const inner = def.valueType;
-      return inner === void 0 ? "ZodSet(?)" : `ZodSet<${recurse(inner)}>${formatChecks(def.checks)}`;
-    }
-    case "ZodBranded": {
-      const inner = def.type;
-      return inner === void 0 ? "ZodBranded(?)" : `ZodBranded(${recurse(inner)})`;
-    }
-    // Structural opacity — schemas whose runtime behaviour isn't
-    // introspectable via `_def` fall here. Still distinguishable
-    // from other kinds by the returned string.
-    case "ZodPromise":
-    case "ZodFunction":
-    case "ZodMap":
-    case "ZodSymbol":
-    default:
-      return `${kind}:*`;
-  }
-}
-function readShapeSafely(def) {
-  if (typeof def.shape !== "function") return {};
-  try {
-    return def.shape();
-  } catch {
-    return {};
-  }
-}
-function defaultFactoryRepr(factory) {
-  if (typeof factory !== "function") return "none";
-  let first;
-  let second;
-  try {
-    first = factory();
-    second = factory();
-  } catch {
-    return "fn:*";
-  }
-  if (!Object.is(first, second)) return "fn:*";
-  if (typeof first === "function") return "fn:*";
-  return canonicalStringify(first);
-}
-function formatChecks(checks) {
-  if (!Array.isArray(checks) || checks.length === 0) return "";
-  const parts = checks.map((c) => canonicalStringify(c)).sort();
-  return `[${parts.join(";")}]`;
-}
-function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const t = typeof value;
-  if (t === "string") return JSON.stringify(value);
-  if (t === "number" || t === "boolean") return String(value);
-  if (t === "bigint") return `${String(value)}n`;
-  if (t === "function") return "fn:*";
-  if (t === "symbol") return "symbol:*";
-  if (Array.isArray(value)) {
-    if (seen.has(value)) return "<cyclic>";
-    seen.add(value);
-    try {
-      return `[${value.map((v) => canonicalStringify(v, seen)).join(",")}]`;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  if (t === "object") {
-    const obj = value;
-    if (seen.has(obj)) return "<cyclic>";
-    seen.add(obj);
-    try {
-      if (value instanceof Date) return `date:${value.getTime()}`;
-      if (value instanceof RegExp) return `regex:${String(value)}`;
-      const entries = Object.entries(obj).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`);
-      return `{${entries.join(",")}}`;
-    } finally {
-      seen.delete(obj);
-    }
-  }
-  return "unknown";
-}
-
 const V3_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
-  getObjectShape: (schema) => getObjectShape(schema),
-  getTupleItems: (schema) => getTupleItems(schema),
+  getObjectShape,
+  getTupleItems,
   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),
+  getDiscriminator,
+  getLiteralValues,
+  isPreprocessNode,
+  isCoercePrimitive,
+  containsAsyncRefine,
+  containsAsyncTransform,
+  hasContainerOrRootRefine,
   // Walker accessors (D2 / D3 / D5).
-  getArrayElement: (schema) => getArrayElement(schema),
-  getSetValueType: (schema) => getSetValueType(schema),
-  getRecordKeyType: (schema) => getRecordKeyType(schema),
-  getRecordValueType: (schema) => getRecordValueType(schema),
-  getUnionOptions: (schema) => getUnionOptions(schema),
-  getIntersectionLeft: (schema) => getIntersectionLeft(schema),
-  getIntersectionRight: (schema) => getIntersectionRight(schema),
+  getArrayElement,
+  getSetValueType,
+  getRecordKeyType,
+  getRecordValueType,
+  getUnionOptions,
+  getIntersectionLeft,
+  getIntersectionRight,
   getEnumValues: (schema) => {
     if (!isZodSchemaType(schema, "ZodEnum")) return [];
     return schema.options;
   },
-  getNativeEnumValues: (schema) => getNativeEnumValues(schema),
-  unwrapInner: (schema) => unwrapInner(schema),
-  unwrapBranded: (schema) => unwrapBranded(schema),
-  unwrapEffectsSource: (schema) => unwrapEffectsSource(schema),
-  unwrapPipeIn: (schema) => unwrapPipeIn(schema),
-  unwrapPipeOut: (schema) => unwrapPipeOut(schema),
-  unwrapLazy: (schema) => unwrapLazy(schema),
-  getLazyGetter: (schema) => getLazyGetter(schema),
-  getDefaultValue: (schema) => getDefaultValue$1(schema),
-  getCatchDefault: (schema) => getCatchDefault(schema),
-  hasCatchValue: (schema) => hasCatchValue(schema)
+  getNativeEnumValues,
+  unwrapInner,
+  unwrapBranded,
+  unwrapEffectsSource,
+  unwrapPipeIn,
+  unwrapPipeOut,
+  unwrapLazy,
+  getLazyGetter,
+  getDefaultValue: getDefaultValue$1,
+  getCatchDefault,
+  hasCatchValue
 };
 
 function slimPrimitivesV3(schema) {
-  return new Set(walkSlimPrimitives.slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+  return new Set(walkFieldMeta.slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
 }
 
 function stripAsyncChecks(schema) {
@@ -955,22 +777,6 @@ function constraintsAreSlimValid(slimSchema, constraints) {
     return false;
   }
 }
-function mergeDeepV3(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] = mergeDeepV3(bVal, oVal);
-    } else {
-      result[key] = oVal;
-    }
-  }
-  return result;
-}
 let warnedZodCodeMissing = false;
 function zodAdapter(zodSchema) {
   assertSupportedKinds(zodSchema);
@@ -985,7 +791,7 @@ function zodAdapter(zodSchema) {
     const name = getTypeName(_strippedRoot);
     throw new Error(`ZodAdapter: expected ZodObject, got ${name}`);
   }
-  return (formKey, options) => walkSlimPrimitives.createAbstractSchema(
+  return (formKey, options) => walkFieldMeta.createAbstractSchema(
     zodSchema,
     V3_INTROSPECTOR,
     buildV3Services(),
@@ -993,9 +799,13 @@ function zodAdapter(zodSchema) {
     options
   );
 }
+async function lazyFingerprint(schema) {
+  const { fingerprintZodSchema } = await import('../chunks/fingerprint.cjs');
+  return fingerprintZodSchema(schema);
+}
 function buildV3Services() {
   return {
-    fingerprint: (schema) => fingerprintZodSchema(schema),
+    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     // v3 pre-strips refinements / defaults / wrappers off the root for
     // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
@@ -1023,7 +833,7 @@ function buildV3Services() {
     // historical shape) — `getSchemasAtPath` consumers may probe any
     // method on the result. The factory call rebuilds the full surface
     // against the sub-schema with its own per-form caches.
-    makeSubSchema: (sub, formKey, maxRecursionDepth) => walkSlimPrimitives.createAbstractSchema(
+    makeSubSchema: (sub, formKey, maxRecursionDepth) => walkFieldMeta.createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
       buildV3Services(),
@@ -1076,7 +886,7 @@ function coercePathSegments(path) {
 }
 function getNestedZodSchemasAtPath(schema, segments, maxRecursionDepth) {
   if (segments.length === 0) return [schema];
-  return walkSlimPrimitives.walkPathSegments(schema, segments.map(String), V3_INTROSPECTOR, maxRecursionDepth, 0);
+  return walkFieldMeta.walkPathSegments(schema, segments.map(String), V3_INTROSPECTOR, maxRecursionDepth, 0);
 }
 function unwrapStructuralLeafV3(schema) {
   let current = schema;
@@ -1147,9 +957,14 @@ function isLeafRequiredV3(schema, depth = 0) {
     return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
   }
   if (isZodSchemaType(schema, "ZodEffects")) {
+    if (getEffectsKind(schema) === "preprocess") return true;
     const inner = unwrapEffectsSource(schema);
     return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
   }
+  if (isZodSchemaType(schema, "ZodLazy")) {
+    const inner = unwrapLazy(schema);
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
   if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
     const options = getUnionOptions(schema);
     if (options.length === 0) return true;
@@ -1196,6 +1011,7 @@ function unwrapToDiscriminatedUnion(schema, depth = 0) {
       continue;
     }
     if (isZodSchemaType(currentSchema, "ZodEffects")) {
+      if (getEffectsKind(currentSchema) === "preprocess") return void 0;
       const inner = unwrapEffectsSource(currentSchema);
       if (!inner) return void 0;
       currentSchema = inner;
@@ -1254,7 +1070,7 @@ function getDefaultValue(expected, context) {
   return void 0;
 }
 function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return walkSlimPrimitives.deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
+  return walkFieldMeta.deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
     unsupportedKindFallback: (schema) => {
       console.warn(
         `[attaform] zod-v3 adapter: unsupported schema kind '${schema.constructor?.name ?? "unknown"}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.`
@@ -1413,7 +1229,7 @@ function stripRootSchema(schema, stripConfig) {
 }
 const getStripInstruction = (stripValueOrCallback, schema) => {
   if (stripValueOrCallback === void 0 || stripValueOrCallback === false) return false;
-  return lodashEs.isFunction(stripValueOrCallback) ? stripValueOrCallback(schema) : stripValueOrCallback;
+  return typeof stripValueOrCallback === "function" ? stripValueOrCallback(schema) : stripValueOrCallback;
 };
 function getSlimSchema(config) {
   function _getSlimSchema(_schema) {
@@ -1443,7 +1259,7 @@ function getSlimSchema(config) {
       if (discKey === void 0) return _schema;
       for (const option of getDiscriminatedOptions(_schema)) {
         const slimmedSchema = _getSlimSchema(option);
-        const deepCloneSlimmedSchema = lodashEs.cloneDeep(slimmedSchema);
+        const deepCloneSlimmedSchema = cloneSchemaDeep(slimmedSchema);
         slimmedSchemas.push(deepCloneSlimmedSchema);
       }
       return zod.z.discriminatedUnion(
@@ -1505,142 +1321,6 @@ function peelAllV3Wrappers(schema) {
   }
   return current;
 }
-const pathMetaCacheV3 = /* @__PURE__ */ new WeakMap();
-function getPathMetaMapV3(rootSchema) {
-  const cached = pathMetaCacheV3.get(rootSchema);
-  if (cached !== void 0) return cached;
-  const map = /* @__PURE__ */ new Map();
-  const counters = /* @__PURE__ */ new Map();
-  const lastPathPerSchema = /* @__PURE__ */ new Map();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  walkForMetaV3(rootSchema, [], map, counters, lastPathPerSchema, inProgress);
-  for (const [schema, lastPath] of lastPathPerSchema) {
-    const list = getFieldMetaList(schema);
-    const consumed = counters.get(schema) ?? 0;
-    if (list.length <= consumed) continue;
-    const surplus = list.slice(consumed).reduce((acc, p) => ({ ...acc, ...p }), {});
-    const existing = map.get(lastPath) ?? {};
-    map.set(lastPath, { ...existing, ...surplus });
-  }
-  pathMetaCacheV3.set(rootSchema, map);
-  return map;
-}
-function consumePayloadV3(schema, counters) {
-  const list = getFieldMetaList(schema);
-  if (list.length === 0) return void 0;
-  const idx = counters.get(schema) ?? 0;
-  const payload = list[Math.min(idx, list.length - 1)];
-  counters.set(schema, idx + 1);
-  return payload;
-}
-function walkForMetaV3(schema, path, map, counters, lastPathPerSchema, inProgress) {
-  if (inProgress.has(schema)) return;
-  inProgress.add(schema);
-  try {
-    const pathKey = paths.canonicalizePath(path).key;
-    if (!map.has(pathKey)) {
-      const payload = consumePayloadV3(schema, counters);
-      if (payload !== void 0) {
-        map.set(pathKey, payload);
-        lastPathPerSchema.set(schema, pathKey);
-      }
-    }
-    const peeled = peelAllV3Wrappers(schema);
-    if (peeled !== schema && !map.has(pathKey)) {
-      const payload = consumePayloadV3(peeled, counters);
-      if (payload !== void 0) {
-        map.set(pathKey, payload);
-        lastPathPerSchema.set(peeled, pathKey);
-      }
-    }
-    if (isZodSchemaType(schema, "ZodObject")) {
-      const shape = getObjectShape(schema);
-      for (const [key, child] of Object.entries(shape)) {
-        walkForMetaV3(
-          child,
-          [...path, key],
-          map,
-          counters,
-          lastPathPerSchema,
-          inProgress
-        );
-      }
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodArray")) {
-      const inner = getArrayElement(schema);
-      if (inner) walkForMetaV3(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodTuple")) {
-      const items = getTupleItems(schema);
-      items.forEach((item, i) => {
-        walkForMetaV3(
-          item,
-          [...path, i],
-          map,
-          counters,
-          lastPathPerSchema,
-          inProgress
-        );
-      });
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodSet")) {
-      const inner = getSetValueType(schema);
-      if (inner) walkForMetaV3(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodRecord")) {
-      const inner = getRecordValueType(schema);
-      if (inner) walkForMetaV3(inner, [...path, "*"], map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
-      for (const opt of getUnionOptions(schema)) {
-        walkForMetaV3(opt, path, map, counters, lastPathPerSchema, inProgress);
-      }
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodIntersection")) {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left) walkForMetaV3(left, path, map, counters, lastPathPerSchema, inProgress);
-      if (right) walkForMetaV3(right, path, map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch")) {
-      const inner = unwrapInner(schema);
-      if (inner) walkForMetaV3(inner, path, map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodEffects")) {
-      const inner = unwrapEffectsSource(schema);
-      if (inner) walkForMetaV3(inner, path, map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodPipeline")) {
-      const inner = unwrapPipeIn(schema);
-      if (inner) walkForMetaV3(inner, path, map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodBranded")) {
-      const inner = unwrapBranded(schema);
-      if (inner) walkForMetaV3(inner, path, map, counters, lastPathPerSchema, inProgress);
-      return;
-    }
-    if (isZodSchemaType(schema, "ZodLazy")) {
-      try {
-        const inner = unwrapLazy(schema);
-        if (inner) walkForMetaV3(inner, path, map, counters, lastPathPerSchema, inProgress);
-      } catch {
-      }
-      return;
-    }
-  } finally {
-    inProgress.delete(schema);
-  }
-}
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
   const target = path.length === 0 ? rootSchema : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth)[0];
@@ -1652,7 +1332,11 @@ function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
       meta: Object.freeze({})
     };
   }
-  const pathMap = getPathMetaMapV3(rootSchema);
+  const pathMap = walkFieldMeta.getFieldMetaPathMap(rootSchema, {
+    intro: V3_INTROSPECTOR,
+    peelAllWrappers: peelAllV3Wrappers,
+    getFieldMetaList
+  });
   const pathKey = paths.canonicalizePath(path).key;
   const peeled = peelV3Wrappers(target);
   const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
@@ -1686,7 +1370,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
   });
   let rawDefaultValues = defaultValuesWithoutConstraints;
   if (!isPrimitive(rawDefaultValues)) {
-    rawDefaultValues = mergeDeepV3(defaultValuesWithoutConstraints, config.constraints);
+    rawDefaultValues = walkFieldMeta.mergeDeep(defaultValuesWithoutConstraints, config.constraints);
   } else if (constraintsAreSlimValid(slimSchema, config.constraints)) {
     rawDefaultValues = config.constraints;
   }
@@ -1811,8 +1495,8 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
         fixedData = injectWizard.setAtPath(fixedData, path, defaultValue);
         continue;
       }
-      const peeled = walkSlimPrimitives.peelEmbeddedDefault(schemaAtPath, V3_INTROSPECTOR);
-      if (peeled !== walkSlimPrimitives.NO_EMBEDDED_DEFAULT) {
+      const peeled = walkFieldMeta.peelEmbeddedDefault(schemaAtPath, V3_INTROSPECTOR);
+      if (peeled !== walkFieldMeta.NO_EMBEDDED_DEFAULT) {
         fixedData = injectWizard.setAtPath(fixedData, path, peeled);
         continue;
       }
@@ -1834,7 +1518,7 @@ function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth)
       }
     }
   }
-  fixedData = mergeDeepV3(rawDefaultValues, fixedData);
+  fixedData = walkFieldMeta.mergeDeep(rawDefaultValues, fixedData);
   const secondParse = slimSchema.safeParse(fixedData);
   const finalData = secondParse.success ? secondParse.data : fixedData;
   return {
@@ -1879,4 +1563,4 @@ exports.isZodSchemaType = isZodSchemaType;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodAdapter = zodAdapter;
-//# sourceMappingURL=attaform.DAKrGhxc.cjs.map
+//# sourceMappingURL=attaform.BSkvn43g.cjs.map