attaform 0.18.2 → 0.20.0

package/dist/shared/attaform.DvA-CJJW.mjs

@@ -0,0 +1,1876 @@
+import { isFunction, cloneDeep } from 'lodash-es';
+import { z } from 'zod';
+import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.BWgAFnsj.mjs';
+import { h as humanize, g as getAtPath, j as slimKindOf, s as setAtPath, e as isPlainRecord, k as useAbstractForm } from './attaform.CKFbKFb6.mjs';
+import { a as AttaformError, _ as __DEV__, j as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.BKozEdTr.mjs';
+
+const fieldMeta = fieldMetaStore;
+function withMeta(schema, payload) {
+  const existing = getFieldMetaForSchema(schema) ?? {};
+  const Ctor = schema.constructor;
+  const cloned = new Ctor(schema._def);
+  fieldMetaStore.add(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function getFieldMeta(schema) {
+  return getFieldMetaForSchema(schema);
+}
+function getFieldMetaList(schema) {
+  return getFieldMetaListForSchema(schema);
+}
+
+class UnsupportedSchemaError extends AttaformError {
+}
+
+function isZodSchemaType(schema, expectedType) {
+  if (typeof schema !== "object" || schema === null) return false;
+  const maybeDef = schema._def;
+  return maybeDef?.typeName === expectedType;
+}
+
+const MAX_UNWRAP_STEPS$1 = 64;
+function readDef(schema) {
+  if (schema === null || typeof schema !== "object") return void 0;
+  return schema._def;
+}
+function kindOf(schema) {
+  const def = readDef(schema);
+  const typeName = def?.typeName;
+  if (typeName === void 0) return "unknown";
+  switch (typeName) {
+    case "ZodObject":
+      return "object";
+    case "ZodArray":
+      return "array";
+    case "ZodSet":
+      return "set";
+    case "ZodRecord":
+      return "record";
+    case "ZodTuple":
+      return "tuple";
+    case "ZodUnion":
+      return "union";
+    case "ZodDiscriminatedUnion":
+      return "discriminated-union";
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodBigInt":
+      return "bigint";
+    case "ZodDate":
+      return "date";
+    case "ZodEnum":
+      return "enum";
+    case "ZodNativeEnum":
+      return "native-enum";
+    case "ZodLiteral":
+      return "literal";
+    case "ZodNull":
+      return "null";
+    case "ZodUndefined":
+      return "undefined";
+    case "ZodOptional":
+      return "optional";
+    case "ZodNullable":
+      return "nullable";
+    case "ZodDefault":
+      return "default";
+    case "ZodCatch":
+      return "catch";
+    case "ZodReadonly":
+      return "readonly";
+    case "ZodBranded":
+      return "branded";
+    case "ZodEffects":
+      return "effects";
+    case "ZodPipeline":
+      return "pipeline";
+    case "ZodLazy":
+      return "lazy";
+    case "ZodIntersection":
+      return "intersection";
+    case "ZodAny":
+      return "any";
+    case "ZodUnknown":
+      return "unknown";
+    case "ZodNever":
+      return "never";
+    case "ZodNaN":
+      return "nan";
+    case "ZodVoid":
+      return "void";
+    case "ZodPromise":
+      return "promise";
+    case "ZodFunction":
+      return "function";
+    case "ZodMap":
+      return "map";
+    case "ZodSymbol":
+      return "symbol";
+    default:
+      return "unknown";
+  }
+}
+function getTypeName(schema) {
+  return readDef(schema)?.typeName;
+}
+function getObjectShape(schema) {
+  const def = readDef(schema);
+  const raw = def?.shape;
+  if (typeof raw === "function") return raw();
+  if (raw !== void 0) return raw;
+  return schema.shape ?? {};
+}
+function getArrayElement(schema) {
+  const def = readDef(schema);
+  return def?.type;
+}
+function getSetValueType(schema) {
+  const def = readDef(schema);
+  return def?.valueType;
+}
+function getRecordKeyType(schema) {
+  const def = readDef(schema);
+  return def?.keyType;
+}
+function getRecordValueType(schema) {
+  const def = readDef(schema);
+  return def?.valueType;
+}
+function getTupleItems(schema) {
+  const def = readDef(schema);
+  return def?.items ?? [];
+}
+function getUnionOptions(schema) {
+  const def = readDef(schema);
+  return def?.options ?? [];
+}
+function getDiscriminatedOptions(schema) {
+  const def = readDef(schema);
+  return def?.options ?? [];
+}
+function getDiscriminator(schema) {
+  const def = readDef(schema);
+  return def?.discriminator;
+}
+function getIntersectionLeft(schema) {
+  const def = readDef(schema);
+  return def?.left;
+}
+function getIntersectionRight(schema) {
+  const def = readDef(schema);
+  return def?.right;
+}
+function unwrapInner(schema) {
+  const def = readDef(schema);
+  return def?.innerType;
+}
+function unwrapBranded(schema) {
+  const def = readDef(schema);
+  return def?.type;
+}
+function unwrapEffectsSource(schema) {
+  const def = readDef(schema);
+  return def?.schema;
+}
+function getEffectsKind(schema) {
+  const def = readDef(schema);
+  const type = def?.effect?.type;
+  if (type === "refinement" || type === "transform" || type === "preprocess") return type;
+  return void 0;
+}
+function isCoercePrimitive(schema) {
+  return readDef(schema)?.coerce === true;
+}
+function isPreprocessNode(schema) {
+  if (!isZodSchemaType(schema, "ZodEffects")) return false;
+  return getEffectsKind(schema) === "preprocess";
+}
+function isAsyncEffect(schema) {
+  const def = readDef(schema);
+  const effect = def?.effect;
+  if (effect === void 0) return false;
+  if (effect.type === "refinement") return false;
+  const fn = effect.transform;
+  if (typeof fn !== "function") return false;
+  return fn.constructor.name === "AsyncFunction";
+}
+function containsAsyncRefine(schema, seen) {
+  return walkForAsync(schema, "refinement", /* @__PURE__ */ new WeakSet());
+}
+function containsAsyncTransform(schema, seen) {
+  return walkForAsync(schema, "transform-or-preprocess", /* @__PURE__ */ new WeakSet());
+}
+function walkForAsync(schema, target, visited) {
+  const candidate = schema;
+  if (typeof candidate !== "object" || candidate === null) return false;
+  if (visited.has(candidate)) return false;
+  visited.add(candidate);
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const kind = getEffectsKind(schema);
+    if (target === "refinement" && kind === "refinement") return true;
+    if (target === "transform-or-preprocess" && (kind === "transform" || kind === "preprocess") && isAsyncEffect(schema)) {
+      return true;
+    }
+    const inner = unwrapEffectsSource(schema);
+    return inner !== void 0 && walkForAsync(inner, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodReadonly")) {
+    const inner = unwrapInner(schema);
+    return inner !== void 0 && walkForAsync(inner, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodBranded")) {
+    const inner = unwrapBranded(schema);
+    return inner !== void 0 && walkForAsync(inner, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodLazy")) {
+    const inner = unwrapLazy(schema);
+    return inner !== void 0 && walkForAsync(inner, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inSide = unwrapPipeIn(schema);
+    if (inSide !== void 0 && walkForAsync(inSide, target, visited)) return true;
+    const outSide = unwrapPipeOut(schema);
+    if (outSide !== void 0 && walkForAsync(outSide, target, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodObject")) {
+    for (const sub of Object.values(getObjectShape(schema))) {
+      if (walkForAsync(sub, target, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodArray")) {
+    const elem = getArrayElement(schema);
+    return elem !== void 0 && walkForAsync(elem, target, visited);
+  }
+  if (isZodSchemaType(schema, "ZodTuple")) {
+    for (const it of getTupleItems(schema)) {
+      if (walkForAsync(it, target, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    for (const opt of getUnionOptions(schema)) {
+      if (walkForAsync(opt, target, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const left = getIntersectionLeft(schema);
+    if (left !== void 0 && walkForAsync(left, target, visited)) return true;
+    const right = getIntersectionRight(schema);
+    if (right !== void 0 && walkForAsync(right, target, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodRecord")) {
+    const keyType = getRecordKeyType(schema);
+    if (keyType !== void 0 && walkForAsync(keyType, target, visited)) return true;
+    const valueType = getRecordValueType(schema);
+    if (valueType !== void 0 && walkForAsync(valueType, target, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodSet")) {
+    const elem = getSetValueType(schema);
+    return elem !== void 0 && walkForAsync(elem, target, visited);
+  }
+  return false;
+}
+function unwrapPipeIn(schema) {
+  const def = readDef(schema);
+  return def?.in;
+}
+function unwrapPipeOut(schema) {
+  const def = readDef(schema);
+  return def?.out;
+}
+function unwrapLazy(schema) {
+  const def = readDef(schema);
+  const getter = def?.getter;
+  if (typeof getter !== "function") return void 0;
+  try {
+    return getter();
+  } catch {
+    return void 0;
+  }
+}
+function getLazyGetter(schema) {
+  const def = readDef(schema);
+  return typeof def?.getter === "function" ? def.getter : void 0;
+}
+function getLiteralValues(schema) {
+  const def = readDef(schema);
+  const v = def?.value;
+  if (Array.isArray(v)) return v;
+  if (v === void 0) return [];
+  return [v];
+}
+function getNativeEnumValues(schema) {
+  const def = readDef(schema);
+  return def?.values;
+}
+function getDefaultValue$1(schema) {
+  const def = readDef(schema);
+  const thunk = def?.defaultValue;
+  if (typeof thunk !== "function") return void 0;
+  try {
+    return thunk();
+  } catch {
+    return void 0;
+  }
+}
+function getCatchDefault(schema) {
+  const def = readDef(schema);
+  const cv = def?.catchValue;
+  if (typeof cv !== "function") return void 0;
+  try {
+    return cv({ error: null, input: void 0 });
+  } catch {
+    return void 0;
+  }
+}
+function hasCatchValue(schema) {
+  const def = readDef(schema);
+  return typeof def?.catchValue === "function";
+}
+function hasChecks(schema) {
+  const def = readDef(schema);
+  const checks = def?.checks;
+  return Array.isArray(checks) && checks.length > 0;
+}
+function hasContainerOrRootRefine(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);
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = unwrapEffectsSource(schema);
+    if (inner === void 0) return false;
+    if (isContainerAfterWrapperPeel(inner)) return true;
+    return hasContainerOrRootRefine(inner, visited);
+  }
+  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodReadonly")) {
+    const inner = unwrapInner(schema);
+    return inner !== void 0 && hasContainerOrRootRefine(inner, visited);
+  }
+  if (isZodSchemaType(schema, "ZodBranded")) {
+    const inner = unwrapBranded(schema);
+    return inner !== void 0 && hasContainerOrRootRefine(inner, visited);
+  }
+  if (isZodSchemaType(schema, "ZodLazy")) {
+    const inner = unwrapLazy(schema);
+    return inner !== void 0 && hasContainerOrRootRefine(inner, visited);
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inSide = unwrapPipeIn(schema);
+    if (inSide !== void 0 && hasContainerOrRootRefine(inSide, visited)) return true;
+    const outSide = unwrapPipeOut(schema);
+    if (outSide !== void 0 && hasContainerOrRootRefine(outSide, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodObject")) {
+    for (const sub of Object.values(getObjectShape(schema))) {
+      if (hasContainerOrRootRefine(sub, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodArray")) {
+    const elem = getArrayElement(schema);
+    return elem !== void 0 && hasContainerOrRootRefine(elem, visited);
+  }
+  if (isZodSchemaType(schema, "ZodTuple")) {
+    for (const it of getTupleItems(schema)) {
+      if (hasContainerOrRootRefine(it, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    for (const opt of getUnionOptions(schema)) {
+      if (hasContainerOrRootRefine(opt, visited)) return true;
+    }
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const left = getIntersectionLeft(schema);
+    if (left !== void 0 && hasContainerOrRootRefine(left, visited)) return true;
+    const right = getIntersectionRight(schema);
+    if (right !== void 0 && hasContainerOrRootRefine(right, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodRecord")) {
+    const keyType = getRecordKeyType(schema);
+    if (keyType !== void 0 && hasContainerOrRootRefine(keyType, visited)) return true;
+    const valueType = getRecordValueType(schema);
+    if (valueType !== void 0 && hasContainerOrRootRefine(valueType, visited)) return true;
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodSet")) {
+    const elem = getSetValueType(schema);
+    return elem !== void 0 && hasContainerOrRootRefine(elem, visited);
+  }
+  return false;
+}
+function isContainerAfterWrapperPeel(schema) {
+  let cur = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS$1; i++) {
+    if (isZodSchemaType(cur, "ZodOptional") || isZodSchemaType(cur, "ZodNullable") || isZodSchemaType(cur, "ZodDefault") || isZodSchemaType(cur, "ZodCatch") || isZodSchemaType(cur, "ZodReadonly")) {
+      const inner = unwrapInner(cur);
+      if (inner === void 0) return false;
+      cur = inner;
+    } else if (isZodSchemaType(cur, "ZodBranded")) {
+      const inner = unwrapBranded(cur);
+      if (inner === void 0) return false;
+      cur = inner;
+    } else if (isZodSchemaType(cur, "ZodLazy")) {
+      const inner = unwrapLazy(cur);
+      if (inner === void 0) return false;
+      cur = inner;
+    } else {
+      break;
+    }
+  }
+  return isZodSchemaType(cur, "ZodObject") || isZodSchemaType(cur, "ZodArray") || isZodSchemaType(cur, "ZodTuple") || isZodSchemaType(cur, "ZodIntersection") || isZodSchemaType(cur, "ZodUnion") || isZodSchemaType(cur, "ZodDiscriminatedUnion") || isZodSchemaType(cur, "ZodRecord") || isZodSchemaType(cur, "ZodSet");
+}
+
+const UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
+function labelPath(path) {
+  return path.length === 0 ? "<root>" : path.join(".");
+}
+function assertSupportedKinds(schema, path = [], lazyGetters = []) {
+  const typeName = getTypeName(schema);
+  if (typeName !== void 0 && UNSUPPORTED_TYPE_NAMES.has(typeName)) {
+    throw new UnsupportedSchemaError(
+      `[attaform/zod-v3] unsupported kind '${typeName}' at '${labelPath(path)}'`
+    );
+  }
+  if (isZodSchemaType(schema, "ZodObject")) {
+    for (const [key, sub] of Object.entries(getObjectShape(schema))) {
+      assertSupportedKinds(sub, [...path, key], lazyGetters);
+    }
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodArray")) {
+    const inner = getArrayElement(schema);
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodSet")) {
+    const inner = getSetValueType(schema);
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodRecord")) {
+    const inner = getRecordValueType(schema);
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodTuple")) {
+    const items = getTupleItems(schema);
+    items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodUnion")) {
+    const options = getUnionOptions(schema);
+    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    const options = getDiscriminatedOptions(schema);
+    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const left = getIntersectionLeft(schema);
+    if (left) assertSupportedKinds(left, [...path, "left"], lazyGetters);
+    const right = getIntersectionRight(schema);
+    if (right) assertSupportedKinds(right, [...path, "right"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch")) {
+    const inner = unwrapInner(schema);
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodBranded")) {
+    const inner = unwrapBranded(schema);
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = unwrapEffectsSource(schema);
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inner = unwrapPipeIn(schema);
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodLazy")) {
+    const getter = getLazyGetter(schema);
+    if (getter !== void 0 && lazyGetters.includes(getter)) return;
+    const inner = getter?.();
+    if (inner !== void 0) {
+      assertSupportedKinds(
+        inner,
+        path,
+        getter === void 0 ? lazyGetters : [...lazyGetters, getter]
+      );
+    }
+    return;
+  }
+}
+
+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),
+  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) => 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),
+  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)
+};
+
+function slimPrimitivesV3(schema) {
+  return new Set(slimPrimitivesWalk(schema, V3_INTROSPECTOR, 64));
+}
+
+function stripAsyncChecks(schema) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function recurse(s) {
+    const candidate = s;
+    if (typeof candidate !== "object" || candidate === null) return s;
+    if (seen.has(candidate)) return s;
+    seen.add(candidate);
+    if (isZodSchemaType(s, "ZodEffects")) {
+      const inner = unwrapEffectsSource(s);
+      return inner === void 0 ? s : recurse(inner);
+    }
+    if (isZodSchemaType(s, "ZodOptional")) {
+      const inner = unwrapInner(s);
+      return inner === void 0 ? s : z.optional(recurse(inner));
+    }
+    if (isZodSchemaType(s, "ZodNullable")) {
+      const inner = unwrapInner(s);
+      return inner === void 0 ? s : z.nullable(recurse(inner));
+    }
+    if (isZodSchemaType(s, "ZodDefault")) {
+      const inner = unwrapInner(s);
+      if (inner === void 0) return s;
+      const def = getDefaultValue$1(s);
+      return recurse(inner).default(def);
+    }
+    if (isZodSchemaType(s, "ZodCatch")) {
+      const inner = unwrapInner(s);
+      if (inner === void 0) return s;
+      const fallback = getCatchDefault(s);
+      return recurse(inner).catch(fallback);
+    }
+    if (isZodSchemaType(s, "ZodReadonly")) {
+      const inner = unwrapInner(s);
+      return inner === void 0 ? s : recurse(inner).readonly();
+    }
+    if (isZodSchemaType(s, "ZodBranded")) {
+      const inner = unwrapBranded(s);
+      return inner === void 0 ? s : recurse(inner);
+    }
+    if (isZodSchemaType(s, "ZodLazy")) {
+      const inner = unwrapLazy(s);
+      if (inner === void 0) return s;
+      const stripped = recurse(inner);
+      return z.lazy(() => stripped);
+    }
+    if (isZodSchemaType(s, "ZodPipeline")) {
+      const inSide = unwrapPipeIn(s);
+      return inSide === void 0 ? s : recurse(inSide);
+    }
+    if (isZodSchemaType(s, "ZodObject")) {
+      const shape = getObjectShape(s);
+      const next = {};
+      for (const [k, v] of Object.entries(shape)) {
+        next[k] = recurse(v);
+      }
+      return carryObjectChecks(z.object(next), s);
+    }
+    if (isZodSchemaType(s, "ZodArray")) {
+      const element = getArrayElement(s);
+      if (element === void 0) return s;
+      return carryArrayChecks(z.array(recurse(element)), s);
+    }
+    if (isZodSchemaType(s, "ZodSet")) {
+      const valueType = getSetValueType(s);
+      if (valueType === void 0) return s;
+      return carrySetChecks(z.set(recurse(valueType)), s);
+    }
+    if (isZodSchemaType(s, "ZodTuple")) {
+      const items = getTupleItems(s).map(recurse);
+      const rebuilt = z.tuple(items);
+      return rebuilt;
+    }
+    if (isZodSchemaType(s, "ZodRecord")) {
+      const keyType = getRecordKeyType(s);
+      const valueType = getRecordValueType(s);
+      if (valueType === void 0) return s;
+      const next = recurse(valueType);
+      return keyType === void 0 ? z.record(next) : z.record(keyType, next);
+    }
+    if (isZodSchemaType(s, "ZodUnion")) {
+      const options = getUnionOptions(s).map(recurse);
+      return z.union(options);
+    }
+    if (isZodSchemaType(s, "ZodDiscriminatedUnion")) {
+      const discKey = getDiscriminator(s);
+      const options = getDiscriminatedOptions(s).map(
+        (o) => recurse(o)
+      );
+      if (discKey === void 0 || options.length === 0) return s;
+      return z.discriminatedUnion(
+        discKey,
+        options
+      );
+    }
+    if (isZodSchemaType(s, "ZodIntersection")) {
+      const left = getIntersectionLeft(s);
+      const right = getIntersectionRight(s);
+      if (left === void 0 || right === void 0) return s;
+      return z.intersection(recurse(left), recurse(right));
+    }
+    return s;
+  }
+  return recurse(schema);
+}
+function readArrayLength(schema, key) {
+  const def = schema._def;
+  const slot = def?.[key];
+  if (slot === null || slot === void 0) return void 0;
+  return slot;
+}
+function readSetSize(schema, key) {
+  const def = schema._def;
+  const slot = def?.[key];
+  if (slot === null || slot === void 0) return void 0;
+  return slot;
+}
+function readObjectUnknownKeys(schema) {
+  const def = schema._def;
+  const v = def?.unknownKeys;
+  if (v === "strict" || v === "passthrough" || v === "strip") return v;
+  return void 0;
+}
+function readObjectCatchall(schema) {
+  const def = schema._def;
+  const ca = def?.catchall;
+  if (ca === void 0 || ca === null) return void 0;
+  if (typeof ca === "object" && ca._def?.typeName === "ZodNever") {
+    return void 0;
+  }
+  return ca;
+}
+function carryArrayChecks(rebuilt, original) {
+  let next = rebuilt;
+  const min = readArrayLength(original, "minLength");
+  if (min !== void 0) next = next.min(min.value, min.message);
+  const max = readArrayLength(original, "maxLength");
+  if (max !== void 0) next = next.max(max.value, max.message);
+  const exact = readArrayLength(original, "exactLength");
+  if (exact !== void 0) next = next.length(exact.value, exact.message);
+  return next;
+}
+function carrySetChecks(rebuilt, original) {
+  let next = rebuilt;
+  const min = readSetSize(original, "minSize");
+  if (min !== void 0) next = next.min(min.value, min.message);
+  const max = readSetSize(original, "maxSize");
+  if (max !== void 0) next = next.max(max.value, max.message);
+  return next;
+}
+function carryObjectChecks(rebuilt, original) {
+  let next = rebuilt;
+  const unknownKeys = readObjectUnknownKeys(original);
+  if (unknownKeys === "strict") next = next.strict();
+  else if (unknownKeys === "passthrough") next = next.passthrough();
+  const catchall = readObjectCatchall(original);
+  if (catchall !== void 0) next = next.catchall(catchall);
+  return next;
+}
+
+const PATH_SEPARATOR = ".";
+const MAX_UNWRAP_STEPS = 64;
+function isPrimitive(input) {
+  const type = typeof input;
+  if (type === "string" || type === "number" || type === "boolean" || type === "bigint" || type === "undefined")
+    return true;
+  return input === null;
+}
+function constraintsAreSlimValid(slimSchema, constraints) {
+  try {
+    return slimSchema.safeParse(constraints).success;
+  } catch {
+    return false;
+  }
+}
+function mergeDeepV3(base, override) {
+  if (override === void 0) return base;
+  if (!isPlainRecord(override)) return override;
+  if (!isPlainRecord(base)) return override;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const oVal = override[key];
+    const bVal = base[key];
+    if (isPlainRecord(oVal) && isPlainRecord(bVal)) {
+      result[key] = mergeDeepV3(bVal, oVal);
+    } else {
+      result[key] = oVal;
+    }
+  }
+  return result;
+}
+let warnedZodCodeMissing = false;
+function zodAdapter(zodSchema) {
+  assertSupportedKinds(zodSchema);
+  const [_strippedRoot] = stripRootSchema(zodSchema, {
+    stripDefaultValues: true,
+    stripNullable: true,
+    stripOptional: true,
+    stripZodEffects: true,
+    stripZodRefinements: true
+  });
+  if (!isZodSchemaType(_strippedRoot, "ZodObject")) {
+    const name = getTypeName(_strippedRoot);
+    throw new Error(`ZodAdapter: expected ZodObject, got ${name}`);
+  }
+  return (formKey, options) => createAbstractSchema(
+    zodSchema,
+    V3_INTROSPECTOR,
+    buildV3Services(),
+    formKey,
+    options
+  );
+}
+function buildV3Services() {
+  return {
+    fingerprint: (schema) => fingerprintZodSchema(schema),
+    getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
+    // v3 pre-strips refinements / defaults / wrappers off the root for
+    // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
+    // `getSchemasAtPath` both consume this variant so the yielded
+    // candidates reflect the slim shape.
+    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedSchemasInSlimModeV3(schema, path, maxRecursionDepth),
+    slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
+    deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
+    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth),
+    unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
+    unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
+    peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
+    isLeafRequired: (schema) => isLeafRequiredV3(schema),
+    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPathV3(schema, path, maxRecursionDepth),
+    issuesToValidationErrors: (issues, formKey) => zodIssuesToValidationErrors(issues, formKey),
+    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 };
+    },
+    // v3 returns the full recursive AbstractSchema for sub-schemas (the
+    // 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) => createAbstractSchema(
+      sub,
+      V3_INTROSPECTOR,
+      buildV3Services(),
+      formKey,
+      { maxRecursionDepth }
+    )
+  };
+}
+function zodIssuesToValidationErrors(issues, formKey) {
+  const validationErrors = [];
+  for (const issue of issues) {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+      if (__DEV__ && !warnedZodCodeMissing) {
+        warnedZodCodeMissing = true;
+        console.warn(
+          "[attaform] zod-v3 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."
+        );
+      }
+    }
+    validationErrors.push({
+      message: issue.message,
+      // `ValidationError.path` is `(string | number)[]` per the
+      // public type. v3's `issue.path` is the same in the standard
+      // case, but a custom check via `ctx.addIssue({ path: [...] })`
+      // can smuggle a Symbol through — the public surface promised
+      // strings/numbers, so coerce defensively to keep the contract.
+      // Mirrors v4's behaviour at the same site.
+      //
+      // Adapter-side paths stay schema-relative — the validation
+      // pipeline in `create-form-store.ts` prepends the parent path
+      // to absolutise, then routes form-level (absolute path length 0)
+      // entries to the empty-string bucket at storage time.
+      path: coercePathSegments(issue.path),
+      formKey,
+      code
+    });
+  }
+  return validationErrors;
+}
+function coercePathSegments(path) {
+  const out = [];
+  for (const seg of path) {
+    out.push(typeof seg === "number" ? seg : typeof seg === "string" ? seg : String(seg));
+  }
+  return out;
+}
+function getNestedZodSchemasAtPath(schema, segments, maxRecursionDepth) {
+  if (segments.length === 0) return [schema];
+  return walkPathSegments(schema, segments.map(String), V3_INTROSPECTOR, maxRecursionDepth, 0);
+}
+function unwrapStructuralLeafV3(schema) {
+  let current = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+    if (!(isZodSchemaType(current, "ZodOptional") || isZodSchemaType(current, "ZodNullable"))) {
+      break;
+    }
+    const inner = unwrapInner(current);
+    if (!inner) return current;
+    if (!isStructuralV3Kind(inner)) break;
+    current = inner;
+  }
+  return current;
+}
+function isStructuralV3Kind(schema) {
+  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type — keep
+  // peeling at the next iteration.
+  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+). Each wraps a single inner
+  // schema with no structural impact — `peelV3Wrappers` resolves them.
+  isZodSchemaType(schema, "ZodPipeline") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded");
+}
+function peelV3Wrappers(schema) {
+  let current = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+    if (isZodSchemaType(current, "ZodOptional") || isZodSchemaType(current, "ZodNullable") || isZodSchemaType(current, "ZodDefault") || isZodSchemaType(current, "ZodReadonly")) {
+      const inner = unwrapInner(current);
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodEffects")) {
+      const inner = unwrapEffectsSource(current);
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodPipeline")) {
+      const inner = unwrapPipeIn(current);
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodBranded")) {
+      const inner = unwrapBranded(current);
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+function isLeafRequiredV3(schema, depth = 0) {
+  if (depth > MAX_UNWRAP_STEPS) return true;
+  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodUndefined") || isZodSchemaType(schema, "ZodNull") || isZodSchemaType(schema, "ZodVoid")) {
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodReadonly")) {
+    const inner = unwrapInner(schema);
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodBranded")) {
+    const inner = unwrapBranded(schema);
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inner = unwrapPipeIn(schema);
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = unwrapEffectsSource(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;
+    return options.every((opt) => isLeafRequiredV3(opt, depth + 1));
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const left = getIntersectionLeft(schema);
+    const right = getIntersectionRight(schema);
+    const leftReq = left === void 0 ? true : isLeafRequiredV3(left, depth + 1);
+    const rightReq = right === void 0 ? true : isLeafRequiredV3(right, depth + 1);
+    return leftReq || rightReq;
+  }
+  return true;
+}
+function unwrapToDiscriminatedUnion(schema, depth = 0) {
+  if (depth > MAX_UNWRAP_STEPS) return void 0;
+  let currentSchema = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+    if (isZodSchemaType(currentSchema, "ZodDiscriminatedUnion")) {
+      return currentSchema;
+    }
+    if (isZodSchemaType(currentSchema, "ZodDefault") || isZodSchemaType(currentSchema, "ZodOptional") || isZodSchemaType(currentSchema, "ZodNullable") || isZodSchemaType(currentSchema, "ZodCatch")) {
+      const inner = unwrapInner(currentSchema);
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodReadonly")) {
+      const inner = unwrapInner(currentSchema);
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodBranded")) {
+      const inner = unwrapBranded(currentSchema);
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodPipeline")) {
+      const inner = unwrapPipeIn(currentSchema);
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodEffects")) {
+      const inner = unwrapEffectsSource(currentSchema);
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodIntersection")) {
+      const left = getIntersectionLeft(currentSchema);
+      const right = getIntersectionRight(currentSchema);
+      const leftDU = left ? unwrapToDiscriminatedUnion(left, depth + 1) : void 0;
+      const rightDU = right ? unwrapToDiscriminatedUnion(right, depth + 1) : void 0;
+      if (leftDU !== void 0 && rightDU !== void 0) {
+        return leftDU === rightDU ? leftDU : void 0;
+      }
+      return leftDU ?? rightDU;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function getDefaultValue(expected, context) {
+  const discriminatorContext = context.discriminator;
+  if (discriminatorContext.isDiscriminatorKey) {
+    if (!discriminatorContext.schema) {
+      throw new Error("discriminatorContext.schema unspecified");
+    }
+    if (!isZodSchemaType(discriminatorContext.schema, "ZodDiscriminatedUnion")) {
+      throw new TypeError(
+        "Programming error: discriminatorContext.schema is not a ZodDiscriminatedUnion schema."
+      );
+    }
+    const optionDiscriminator = getSchemaByDiscriminatorKey(
+      discriminatorContext.schema);
+    if (!optionDiscriminator) {
+      throw new Error("ZodDiscriminatedUnion: default option not found");
+    }
+    return getDefaultValuesFromZodSchema(
+      optionDiscriminator,
+      discriminatorContext.useDefaultSchemaValues,
+      context.formKey
+    );
+  }
+  if (expected === "string") return "";
+  if (expected === "number") return 0;
+  if (expected === "array") return [];
+  if (expected === "boolean") return false;
+  if (expected === "bigint") return 0n;
+  if (expected === "float") return 0;
+  if (expected === "integer") return 0;
+  if (expected === "null") return null;
+  if (expected === "object") return {};
+  if (expected === "set") return /* @__PURE__ */ new Set();
+  if (expected === "date") return /* @__PURE__ */ new Date();
+  if (expected === "undefined") return void 0;
+  if (expected === "unknown") return void 0;
+  if (expected === "nan") return Number("nan");
+  return void 0;
+}
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
+  return 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.`
+      );
+      return null;
+    },
+    // v3 historically surfaces the `.catch(v)` fallback even when
+    // `useDefaultSchemaValues=false`. Pinned by
+    // `test/adapters/zod-v3/wrappers.test.ts` ('surfaces the catch
+    // fallback even when useDefaultSchemaValues is false').
+    catchOnUseDefaultFalse: "preserveCatch"
+  });
+}
+function getSchemaByDiscriminatorKey(unionSchema, key) {
+  if (!isZodSchemaType(unionSchema, "ZodDiscriminatedUnion")) {
+    throw new TypeError("Provided schema is not a discriminated union.");
+  }
+  {
+    const options = getDiscriminatedOptions(unionSchema);
+    if (!options.length) {
+      throw new TypeError("Provided ZodDiscriminatedUnion does not have any options");
+    }
+    return options[0];
+  }
+}
+function stripRefinements(schema) {
+  function _stripRefinements(_schema, depth) {
+    if (depth >= MAX_UNWRAP_STEPS) return _schema;
+    if (isZodSchemaType(_schema, "ZodString") && hasChecks(_schema)) {
+      return z.string();
+    }
+    if (isZodSchemaType(_schema, "ZodNumber") && hasChecks(_schema)) {
+      return z.number();
+    }
+    if (isZodSchemaType(_schema, "ZodArray")) {
+      const inner = getArrayElement(_schema);
+      if (!inner) return _schema;
+      return z.array(_stripRefinements(inner, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodObject")) {
+      const strippedShape = Object.fromEntries(
+        Object.entries(getObjectShape(_schema)).map(([key, value]) => [
+          key,
+          _stripRefinements(value, depth + 1)
+        ])
+      );
+      return z.object(strippedShape);
+    }
+    if (isZodSchemaType(_schema, "ZodEffects")) {
+      const inner = unwrapEffectsSource(_schema);
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodOptional")) {
+      const inner = unwrapInner(_schema);
+      if (!inner) return _schema;
+      return z.optional(_stripRefinements(inner, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodNullable")) {
+      const inner = unwrapInner(_schema);
+      if (!inner) return _schema;
+      return z.nullable(_stripRefinements(inner, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodReadonly")) {
+      const inner = unwrapInner(_schema);
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodBranded")) {
+      const inner = unwrapBranded(_schema);
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodPipeline")) {
+      const inner = unwrapPipeIn(_schema);
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodSet")) {
+      const valueType = getSetValueType(_schema);
+      if (!valueType) return _schema;
+      return z.set(_stripRefinements(valueType, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodTuple")) {
+      const items = getTupleItems(_schema);
+      if (items.length === 0) return _schema;
+      const stripped = items.map((it) => _stripRefinements(it, depth + 1));
+      return z.tuple(stripped);
+    }
+    if (isZodSchemaType(_schema, "ZodRecord")) {
+      const valueType = getRecordValueType(_schema);
+      if (!valueType) return _schema;
+      const value = _stripRefinements(valueType, depth + 1);
+      const keyType = getRecordKeyType(_schema);
+      if (keyType) {
+        return z.record(keyType, value);
+      }
+      return z.record(value);
+    }
+    if (isZodSchemaType(_schema, "ZodUnion")) {
+      const options = getUnionOptions(_schema);
+      if (options.length === 0) return _schema;
+      const stripped = options.map((o) => _stripRefinements(o, depth + 1));
+      return z.union(stripped);
+    }
+    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
+      const discKey = getDiscriminator(_schema);
+      const options = getDiscriminatedOptions(_schema);
+      if (discKey === void 0 || options.length === 0) return _schema;
+      const stripped = options.map(
+        (o) => _stripRefinements(o, depth + 1)
+      );
+      return z.discriminatedUnion(
+        discKey,
+        stripped
+      );
+    }
+    if (isZodSchemaType(_schema, "ZodIntersection")) {
+      const left = getIntersectionLeft(_schema);
+      const right = getIntersectionRight(_schema);
+      if (!left || !right) return _schema;
+      return z.intersection(_stripRefinements(left, depth + 1), _stripRefinements(right, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodLazy")) {
+      const inner = unwrapLazy(_schema);
+      if (!inner) return _schema;
+      const stripped = _stripRefinements(inner, depth + 1);
+      return z.lazy(() => stripped);
+    }
+    return _schema;
+  }
+  return _stripRefinements(schema, 0);
+}
+function stripRootSchema(schema, stripConfig) {
+  function recursion(_schema, _stripped = false) {
+    if (getStripInstruction(stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
+      return recursion(_schema.unwrap(), true);
+    }
+    if (getStripInstruction(stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
+      return recursion(_schema.unwrap(), true);
+    }
+    if (getStripInstruction(stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
+      const inner = unwrapEffectsSource(_schema);
+      if (inner) return recursion(inner, true);
+    }
+    if (getStripInstruction(stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
+      const inner = unwrapInner(_schema);
+      if (inner) return recursion(inner, true);
+    }
+    if (getStripInstruction(stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
+      return recursion(stripRefinements(_schema));
+    }
+    return [_schema, _stripped];
+  }
+  return recursion(schema, false);
+}
+const getStripInstruction = (stripValueOrCallback, schema) => {
+  if (stripValueOrCallback === void 0 || stripValueOrCallback === false) return false;
+  return isFunction(stripValueOrCallback) ? stripValueOrCallback(schema) : stripValueOrCallback;
+};
+function getSlimSchema(config) {
+  function _getSlimSchema(_schema) {
+    if (isZodSchemaType(_schema, "ZodObject")) {
+      const newShape = {};
+      for (const [key, value] of Object.entries(getObjectShape(_schema))) {
+        newShape[key] = _getSlimSchema(value);
+      }
+      return z.object(newShape);
+    }
+    if (isZodSchemaType(_schema, "ZodArray")) {
+      const inner = getArrayElement(_schema);
+      if (!inner) return _schema;
+      return z.array(_getSlimSchema(inner));
+    }
+    if (isZodSchemaType(_schema, "ZodRecord")) {
+      const keyType = getRecordKeyType(_schema);
+      const valueType = getRecordValueType(_schema);
+      if (!keyType || !valueType) return _schema;
+      const key = _getSlimSchema(keyType);
+      const value = _getSlimSchema(valueType);
+      return z.record(key, value);
+    }
+    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
+      const slimmedSchemas = [];
+      const discKey = getDiscriminator(_schema);
+      if (discKey === void 0) return _schema;
+      for (const option of getDiscriminatedOptions(_schema)) {
+        const slimmedSchema = _getSlimSchema(option);
+        const deepCloneSlimmedSchema = cloneDeep(slimmedSchema);
+        slimmedSchemas.push(deepCloneSlimmedSchema);
+      }
+      return z.discriminatedUnion(
+        discKey,
+        slimmedSchemas
+      );
+    }
+    if (getStripInstruction(config.stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
+      const inner = unwrapEffectsSource(_schema);
+      if (inner) return _getSlimSchema(inner);
+    }
+    if (getStripInstruction(config.stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
+      const inner = unwrapInner(_schema);
+      if (inner) return _getSlimSchema(inner);
+    }
+    if (getStripInstruction(config.stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
+      const inner = unwrapInner(_schema);
+      if (inner) return _getSlimSchema(inner);
+    }
+    if (getStripInstruction(config.stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
+      return stripRefinements(_schema);
+    }
+    if (getStripInstruction(config.stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
+      const inner = unwrapInner(_schema);
+      if (inner) return _getSlimSchema(inner);
+    }
+    const unionSchema = unwrapToDiscriminatedUnion(_schema);
+    if (unionSchema && getStripInstruction(config.stripConfig.stripDefaultValues, unionSchema)) {
+      return _getSlimSchema(unionSchema);
+    }
+    return _schema;
+  }
+  const processedRootSchema = stripRootSchema(config.schema, config.stripConfig)[0];
+  return _getSlimSchema(processedRootSchema);
+}
+function peelAllV3Wrappers(schema) {
+  let current = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+    let inner;
+    if (isZodSchemaType(current, "ZodOptional") || isZodSchemaType(current, "ZodNullable") || isZodSchemaType(current, "ZodDefault") || isZodSchemaType(current, "ZodReadonly") || isZodSchemaType(current, "ZodCatch")) {
+      inner = unwrapInner(current);
+    } else if (isZodSchemaType(current, "ZodEffects")) {
+      inner = unwrapEffectsSource(current);
+    } else if (isZodSchemaType(current, "ZodPipeline")) {
+      inner = unwrapPipeIn(current);
+    } else if (isZodSchemaType(current, "ZodBranded")) {
+      inner = unwrapBranded(current);
+    } else if (isZodSchemaType(current, "ZodLazy")) {
+      try {
+        inner = unwrapLazy(current);
+      } catch {
+        return current;
+      }
+    } else {
+      return current;
+    }
+    if (!inner) return current;
+    current = inner;
+  }
+  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 = 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];
+  if (target === void 0) {
+    return {
+      label: humanize(lastSegment),
+      description: void 0,
+      placeholder: void 0,
+      meta: Object.freeze({})
+    };
+  }
+  const pathMap = getPathMetaMapV3(rootSchema);
+  const pathKey = canonicalizePath(path).key;
+  const peeled = peelV3Wrappers(target);
+  const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
+  const targetDescription = typeof target.description === "string" ? target.description : void 0;
+  const peeledDescription = peeled !== target && typeof peeled.description === "string" ? peeled.description : void 0;
+  const schemaDescription = targetDescription ?? peeledDescription;
+  return {
+    label: payload?.label ?? humanize(lastSegment),
+    description: payload?.description ?? schemaDescription ?? void 0,
+    placeholder: payload?.placeholder ?? void 0,
+    meta: Object.freeze({ ...payload ?? {} })
+  };
+}
+function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth) {
+  const defaultValuesWithoutConstraints = getDefaultValuesFromZodSchema(
+    rootSchema,
+    config.useDefaultSchemaValues,
+    formKey
+  );
+  const slimSchema = getSlimSchema({
+    schema: rootSchema,
+    stripConfig: {
+      stripZodEffects: true,
+      stripDefaultValues: true,
+      // `strict: false` strips refinements (so empty defaults pass);
+      // strict keeps them so the slim parse below surfaces refinement
+      // errors. Async refines are guarded by the try/catch — they
+      // can't be surfaced synchronously regardless.
+      stripZodRefinements: (config.strict ?? true) === false
+    }
+  });
+  let rawDefaultValues = defaultValuesWithoutConstraints;
+  if (!isPrimitive(rawDefaultValues)) {
+    rawDefaultValues = mergeDeepV3(defaultValuesWithoutConstraints, config.constraints);
+  } else if (constraintsAreSlimValid(slimSchema, config.constraints)) {
+    rawDefaultValues = config.constraints;
+  }
+  if ((config.strict ?? true) !== false) {
+    if (containsAsyncTransform(rootSchema)) {
+      return {
+        data: rawDefaultValues,
+        errors: void 0,
+        success: true,
+        formKey
+      };
+    }
+    try {
+      const strictResult = rootSchema.safeParse(rawDefaultValues);
+      if (strictResult.success) {
+        return {
+          data: rawDefaultValues,
+          errors: void 0,
+          success: true,
+          formKey
+        };
+      }
+      return {
+        data: rawDefaultValues,
+        errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+        success: false,
+        formKey
+      };
+    } catch (err) {
+      const isAsyncDetect = err instanceof Error && err.message.includes("Async refinement encountered");
+      if (isAsyncDetect) {
+        try {
+          const strippedResult = stripAsyncChecks(rootSchema).safeParse(rawDefaultValues);
+          if (strippedResult.success) {
+            return {
+              data: rawDefaultValues,
+              errors: void 0,
+              success: true,
+              formKey
+            };
+          }
+          return {
+            data: rawDefaultValues,
+            errors: zodIssuesToValidationErrors(strippedResult.error.issues, formKey),
+            success: false,
+            formKey
+          };
+        } catch {
+          return {
+            data: rawDefaultValues,
+            errors: void 0,
+            success: true,
+            formKey
+          };
+        }
+      }
+      return {
+        data: rawDefaultValues,
+        errors: void 0,
+        success: true,
+        formKey
+      };
+    }
+  }
+  let parseResult;
+  try {
+    parseResult = slimSchema.safeParse(rawDefaultValues);
+  } catch {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true,
+      formKey
+    };
+  }
+  const { data, success, error } = parseResult;
+  if (success) {
+    return {
+      data,
+      errors: void 0,
+      success,
+      formKey
+    };
+  }
+  let fixedData = {};
+  for (const issue of error.issues) {
+    const schemasAtPath = getNestedZodSchemasAtPath(slimSchema, issue.path, maxRecursionDepth);
+    const path = coercePathSegments(issue.path);
+    if (!schemasAtPath.length) {
+      console.error(
+        `[attaform] zod-v3 adapter: no schema at path '${path.join(PATH_SEPARATOR)}' for key '${formKey}'. Skipping the issue. (This is a library-internal invariant \u2014 please file a bug.)`
+      );
+      continue;
+    }
+    const candidate = schemasAtPath[0];
+    if (candidate !== void 0) {
+      const valueAtPath = getAtPath(rawDefaultValues, path);
+      const slimKinds = slimPrimitivesV3(candidate);
+      if (slimKinds.size > 0 && slimKinds.has(slimKindOf(valueAtPath))) {
+        continue;
+      }
+    }
+    for (const schemaAtPath of schemasAtPath) {
+      if (issue.code === "invalid_type") {
+        const isDiscriminatedUnion = isZodSchemaType(schemaAtPath, "ZodDiscriminatedUnion");
+        const defaultValueContext = isDiscriminatedUnion ? {
+          formKey,
+          discriminator: {
+            isDiscriminatorKey: true,
+            schema: schemaAtPath,
+            useDefaultSchemaValues: false
+          }
+        } : {
+          formKey,
+          discriminator: {
+            isDiscriminatorKey: false,
+            schema: void 0,
+            useDefaultSchemaValues: false
+          }
+        };
+        const defaultValue = getDefaultValue(issue.expected, defaultValueContext);
+        fixedData = setAtPath(fixedData, path, defaultValue);
+        continue;
+      }
+      const peeled = peelEmbeddedDefault(schemaAtPath, V3_INTROSPECTOR);
+      if (peeled !== NO_EMBEDDED_DEFAULT) {
+        fixedData = setAtPath(fixedData, path, peeled);
+        continue;
+      }
+      const ctx = {
+        formKey,
+        discriminator: {
+          isDiscriminatorKey: false,
+          schema: void 0,
+          useDefaultSchemaValues: false
+        }
+      };
+      const slimKinds = slimPrimitivesV3(schemaAtPath);
+      const firstKind = [...slimKinds][0];
+      if (firstKind !== void 0) {
+        const expected = firstKind === "string" ? "string" : firstKind === "number" ? "number" : firstKind === "boolean" ? "boolean" : firstKind === "bigint" ? "bigint" : firstKind === "date" ? "date" : firstKind === "array" ? "array" : firstKind === "object" ? "object" : null;
+        if (expected !== null) {
+          fixedData = setAtPath(fixedData, path, getDefaultValue(expected, ctx));
+        }
+      }
+    }
+  }
+  fixedData = mergeDeepV3(rawDefaultValues, fixedData);
+  const secondParse = slimSchema.safeParse(fixedData);
+  const finalData = secondParse.success ? secondParse.data : fixedData;
+  return {
+    data: finalData,
+    errors: void 0,
+    success: true,
+    formKey
+  };
+}
+function getNestedSchemasInSlimModeV3(rootSchema, path, maxRecursionDepth) {
+  const [strippedSchema] = stripRootSchema(rootSchema, {
+    stripDefaultValues: true,
+    stripNullable: true,
+    stripOptional: true,
+    stripZodEffects: true
+  });
+  const slimSchema = getSlimSchema({
+    schema: strippedSchema,
+    stripConfig: { stripDefaultValues: true, stripZodEffects: true }
+  });
+  return getNestedZodSchemasAtPath(slimSchema, path, maxRecursionDepth);
+}
+
+function useForm(configuration) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new InvalidUseFormConfigError();
+  }
+  function isZodType(value) {
+    return typeof value === "object" && value !== null && "_def" in value;
+  }
+  const { schema } = configuration;
+  const abstractSchema = isZodType(schema) ? zodAdapter(schema) : schema;
+  return useAbstractForm({
+    ...configuration,
+    schema: abstractSchema,
+    defaultValues: configuration.defaultValues
+  });
+}
+
+export { fieldMeta as f, isZodSchemaType as i, useForm as u, withMeta as w, zodAdapter as z };
+//# sourceMappingURL=attaform.DvA-CJJW.mjs.map