attaform 0.15.1 → 0.16.0

package/dist/shared/attaform.DdnithOf.mjs

@@ -0,0 +1,1555 @@
+import { merge, set, isFunction, cloneDeep } from 'lodash-es';
+import { z } from 'zod';
+import { g as getAtPath, s as slimKindOf, A as AttaformErrorCode, h as humanize, c as useAbstractForm } from './attaform.DILbdvfo.mjs';
+import { c as canonicalizePath } from './attaform.jrxE_xZw.mjs';
+import { a as AttaformError, _ as __DEV__, b as InvalidUseFormConfigError } from './attaform.BfMxsfmE.mjs';
+
+const store = /* @__PURE__ */ new WeakMap();
+const fieldMeta = {
+  add(schema, payload) {
+    store.set(schema, payload);
+    return fieldMeta;
+  },
+  get(schema) {
+    return store.get(schema);
+  },
+  has(schema) {
+    return store.has(schema);
+  }
+};
+function withMeta(schema, payload) {
+  const existing = store.get(schema) ?? {};
+  const Ctor = schema.constructor;
+  const cloned = new Ctor(schema._def);
+  store.set(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function getFieldMeta(schema) {
+  return store.get(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 UNSUPPORTED_TYPE_NAMES = /* @__PURE__ */ new Set(["ZodPromise", "ZodFunction", "ZodMap", "ZodSymbol"]);
+function labelPath(path) {
+  return path.length === 0 ? "<root>" : path.join(".");
+}
+function getTypeName(schema) {
+  const def = schema._def;
+  return def?.typeName;
+}
+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")) {
+    const shape = schema.shape;
+    for (const [key, sub] of Object.entries(shape)) {
+      assertSupportedKinds(sub, [...path, key], lazyGetters);
+    }
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodArray")) {
+    const inner = schema._def.type;
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodSet")) {
+    const inner = schema._def.valueType;
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodRecord")) {
+    const inner = schema._def.valueType;
+    if (inner) assertSupportedKinds(inner, [...path, "*"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodTuple")) {
+    const items = schema._def.items ?? [];
+    items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodUnion")) {
+    const options = schema._def.options ?? [];
+    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    const options = schema._def.options ?? [];
+    options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const def = schema._def;
+    if (def.left) assertSupportedKinds(def.left, [...path, "left"], lazyGetters);
+    if (def.right) assertSupportedKinds(def.right, [...path, "right"], lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodBranded")) {
+    const inner = schema._def.innerType ?? schema._def.type;
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = schema.innerType();
+    assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inner = schema._def.in;
+    if (inner) assertSupportedKinds(inner, path, lazyGetters);
+    return;
+  }
+  if (isZodSchemaType(schema, "ZodLazy")) {
+    const getter = schema._def.getter;
+    if (getter !== void 0 && lazyGetters.includes(getter)) {
+      throw new UnsupportedSchemaError(
+        `[attaform/zod-v3] Recursive z.lazy() at '${labelPath(path)}'`
+      );
+    }
+    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":
+    case "ZodNativeEnum": {
+      const 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 `${kind}:${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(",")}}`;
+    }
+    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.schema;
+      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("&")})`;
+    }
+    // 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 "ZodSet":
+    case "ZodSymbol":
+    case "ZodBranded":
+    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 PERMISSIVE_V3 = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "date",
+  "null",
+  "undefined",
+  "object",
+  "array",
+  "symbol",
+  "function",
+  "map",
+  "set"
+]);
+const MAX_LAZY_DEPTH_V3 = 64;
+function slimPrimitivesV3(schema, depth = 0) {
+  if (depth > MAX_LAZY_DEPTH_V3) return new Set(PERMISSIVE_V3);
+  const def = schema._def;
+  const typeName = def?.typeName;
+  if (isZodSchemaType(schema, "ZodString")) return /* @__PURE__ */ new Set(["string"]);
+  if (isZodSchemaType(schema, "ZodNumber")) return /* @__PURE__ */ new Set(["number"]);
+  if (isZodSchemaType(schema, "ZodBoolean")) return /* @__PURE__ */ new Set(["boolean"]);
+  if (isZodSchemaType(schema, "ZodBigInt")) return /* @__PURE__ */ new Set(["bigint"]);
+  if (isZodSchemaType(schema, "ZodDate")) return /* @__PURE__ */ new Set(["date"]);
+  if (isZodSchemaType(schema, "ZodNull")) return /* @__PURE__ */ new Set(["null"]);
+  if (isZodSchemaType(schema, "ZodUndefined")) return /* @__PURE__ */ new Set(["undefined"]);
+  if (typeName === "ZodVoid") return /* @__PURE__ */ new Set(["undefined"]);
+  if (typeName === "ZodNaN") return /* @__PURE__ */ new Set(["number"]);
+  if (isZodSchemaType(schema, "ZodEnum")) {
+    const options = schema.options;
+    const out = /* @__PURE__ */ new Set();
+    for (const v of options) {
+      if (typeof v === "string") out.add("string");
+      else if (typeof v === "number") out.add("number");
+    }
+    return out.size === 0 ? /* @__PURE__ */ new Set(["string"]) : out;
+  }
+  if (isZodSchemaType(schema, "ZodLiteral")) {
+    const value = schema.value;
+    return /* @__PURE__ */ new Set([slimKindOfRawV3(value)]);
+  }
+  if (isZodSchemaType(schema, "ZodObject") || typeName === "ZodRecord") {
+    return /* @__PURE__ */ new Set(["object"]);
+  }
+  if (isZodSchemaType(schema, "ZodArray") || typeName === "ZodTuple") {
+    return /* @__PURE__ */ new Set(["array"]);
+  }
+  if (isZodSchemaType(schema, "ZodSet")) {
+    return /* @__PURE__ */ new Set(["set"]);
+  }
+  if (isZodSchemaType(schema, "ZodOptional")) {
+    const inner = def?.innerType;
+    const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : slimPrimitivesV3(inner, depth + 1);
+    innerSet.add("undefined");
+    return innerSet;
+  }
+  if (isZodSchemaType(schema, "ZodNullable")) {
+    const inner = def?.innerType;
+    const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : slimPrimitivesV3(inner, depth + 1);
+    innerSet.add("null");
+    return innerSet;
+  }
+  if (isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodCatch") || isZodSchemaType(schema, "ZodBranded")) {
+    const inner = def?.innerType ?? def?.type;
+    return inner === void 0 ? new Set(PERMISSIVE_V3) : slimPrimitivesV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = def?.schema;
+    return inner === void 0 ? new Set(PERMISSIVE_V3) : slimPrimitivesV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inner = def?.in;
+    return inner === void 0 ? new Set(PERMISSIVE_V3) : slimPrimitivesV3(inner, depth + 1);
+  }
+  if (typeName === "ZodLazy") {
+    const getter = def?.getter;
+    if (typeof getter !== "function") return new Set(PERMISSIVE_V3);
+    return slimPrimitivesV3(getter(), depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    const options = def?.options ?? [];
+    const out = /* @__PURE__ */ new Set();
+    for (const opt of options) {
+      for (const k of slimPrimitivesV3(opt, depth + 1)) out.add(k);
+    }
+    return out.size === 0 ? new Set(PERMISSIVE_V3) : out;
+  }
+  if (typeName === "ZodIntersection") {
+    const left = def?.left;
+    const right = def?.right;
+    const leftSet = left === void 0 ? new Set(PERMISSIVE_V3) : slimPrimitivesV3(left, depth + 1);
+    const rightSet = right === void 0 ? new Set(PERMISSIVE_V3) : slimPrimitivesV3(right, depth + 1);
+    const out = /* @__PURE__ */ new Set();
+    for (const k of leftSet) if (rightSet.has(k)) out.add(k);
+    return out;
+  }
+  if (typeName === "ZodNever") return /* @__PURE__ */ new Set();
+  if (typeName === "ZodAny" || typeName === "ZodUnknown") return new Set(PERMISSIVE_V3);
+  return new Set(PERMISSIVE_V3);
+}
+function slimKindOfRawV3(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  const t = typeof value;
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "function":
+      return "function";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return "object";
+    default:
+      return "object";
+  }
+}
+
+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;
+  }
+}
+let warnedZodCodeMissing = false;
+function zodAdapter(zodSchema) {
+  function getAbstractSchema(_formKey, _zodSchema, _isRootSchema) {
+    if (_isRootSchema) {
+      assertSupportedKinds(_zodSchema);
+      const [_schema] = stripRootSchema(_zodSchema, {
+        stripDefaultValues: true,
+        stripNullable: true,
+        stripOptional: true,
+        stripZodEffects: true,
+        stripZodRefinements: true
+      });
+      if (!isZodSchemaType(_schema, "ZodObject")) {
+        const name = _schema._def.typeName;
+        throw new Error(`ZodAdapter: expected ZodObject, got ${name}`);
+      }
+    }
+    const leafCache = /* @__PURE__ */ new Map();
+    const abstractSchema = {
+      fingerprint: () => fingerprintZodSchema(_zodSchema),
+      getDefaultValues(config) {
+        const defaultValuesWithoutConstraints = getDefaultValuesFromZodSchema(
+          _zodSchema,
+          config.useDefaultSchemaValues,
+          _formKey
+        );
+        const slimSchema = getSlimSchema({
+          schema: _zodSchema,
+          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 below — they can't be surfaced
+            // synchronously regardless.
+            stripZodRefinements: (config.strict ?? true) === false
+          }
+        });
+        let rawDefaultValues = defaultValuesWithoutConstraints;
+        if (!isPrimitive(rawDefaultValues)) {
+          rawDefaultValues = merge(defaultValuesWithoutConstraints, config.constraints);
+        } else if (constraintsAreSlimValid(slimSchema, config.constraints)) {
+          rawDefaultValues = config.constraints;
+        }
+        let parseResult;
+        try {
+          parseResult = slimSchema.safeParse(rawDefaultValues);
+        } catch {
+          return {
+            data: rawDefaultValues,
+            errors: void 0,
+            success: true,
+            formKey: _formKey
+          };
+        }
+        const { data, success, error } = parseResult;
+        if (success) {
+          return {
+            data,
+            errors: void 0,
+            success,
+            formKey: _formKey
+          };
+        }
+        let fixedData = {};
+        {
+          for (const issue of error.issues) {
+            const schemasAtPath = getNestedZodSchemasAtPath(slimSchema, issue.path);
+            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: _formKey,
+                  discriminator: {
+                    isDiscriminatorKey: true,
+                    schema: schemaAtPath,
+                    useDefaultSchemaValues: false
+                  }
+                } : {
+                  formKey: _formKey,
+                  discriminator: {
+                    isDiscriminatorKey: false,
+                    schema: void 0,
+                    useDefaultSchemaValues: false
+                  }
+                };
+                const defaultValue2 = getDefaultValue(issue.expected, defaultValueContext);
+                set(fixedData, path, defaultValue2);
+                continue;
+              }
+              const [defaultValue, found] = unwrapDefault(schemaAtPath);
+              if (found) {
+                set(fixedData, path, defaultValue);
+                continue;
+              }
+              const ctx = {
+                formKey: _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) {
+                  set(fixedData, path, getDefaultValue(expected, ctx));
+                }
+              }
+            }
+          }
+          fixedData = merge(rawDefaultValues, fixedData);
+        }
+        const secondParse = slimSchema.safeParse(fixedData);
+        const finalData = secondParse.success ? secondParse.data : fixedData;
+        if ((config.strict ?? true) === false) {
+          return {
+            data: finalData,
+            errors: void 0,
+            success: true,
+            formKey: _formKey
+          };
+        }
+        if (secondParse.success) {
+          return {
+            data: finalData,
+            errors: void 0,
+            success: true,
+            formKey: _formKey
+          };
+        }
+        return {
+          data: finalData,
+          errors: zodIssuesToValidationErrors(error.issues, _formKey),
+          success: false,
+          formKey: _formKey
+        };
+      },
+      getDefaultAtPath(path) {
+        if (path.length === 0) {
+          return getDefaultValuesFromZodSchema(_zodSchema, true, _formKey);
+        }
+        const leaf = walkV3ToLeafSchema(_zodSchema, path);
+        if (!leaf) return void 0;
+        const peeled = unwrapStructuralLeafV3(leaf);
+        return getDefaultValuesFromZodSchema(peeled, true, _formKey);
+      },
+      arrayShapeAtPath(path) {
+        if (path.length === 0) return void 0;
+        const leaf = walkV3ToLeafSchema(_zodSchema, path);
+        if (!leaf) return void 0;
+        let peeled = peelV3Wrappers(leaf);
+        for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+          if (!isZodSchemaType(peeled, "ZodCatch")) break;
+          const inner = peeled._def.innerType;
+          if (!inner) break;
+          peeled = peelV3Wrappers(inner);
+        }
+        if (isZodSchemaType(peeled, "ZodTuple")) {
+          const items = peeled._def.items;
+          return Array.isArray(items) ? items.length : void 0;
+        }
+        if (isZodSchemaType(peeled, "ZodArray")) return null;
+        return void 0;
+      },
+      getSchemasAtPath(path) {
+        const [strippedSchema] = stripRootSchema(_zodSchema, {
+          stripDefaultValues: true,
+          stripNullable: true,
+          stripOptional: true,
+          stripZodEffects: true
+        });
+        const slimSchema = getSlimSchema({
+          schema: strippedSchema,
+          stripConfig: {
+            stripDefaultValues: true,
+            stripZodEffects: true
+          }
+        });
+        const nestedZodSchemas = getNestedZodSchemasAtPath(slimSchema, path);
+        if (!nestedZodSchemas.length) return [];
+        return nestedZodSchemas.map(
+          (n) => getAbstractSchema(_formKey, n, false)
+        );
+      },
+      isRequiredAtPath(path) {
+        if (path.length === 0) return true;
+        const leaf = walkV3ToLeafSchema(_zodSchema, path);
+        if (!leaf) return false;
+        return isLeafRequiredV3(leaf);
+      },
+      getFieldMetaAtPath(path) {
+        return resolveFieldMetaAtPathV3(_zodSchema, path);
+      },
+      getUnionDiscriminatorAtPath(path) {
+        const candidates = path.length === 0 ? [_zodSchema] : getNestedZodSchemasAtPath(_zodSchema, path);
+        let matchedUnion;
+        for (const candidate of candidates) {
+          const peeled = peelV3Wrappers(candidate);
+          if (!isZodSchemaType(peeled, "ZodDiscriminatedUnion")) continue;
+          if (matchedUnion !== void 0 && matchedUnion !== peeled) return void 0;
+          matchedUnion = peeled;
+        }
+        if (matchedUnion === void 0) return void 0;
+        const discKey = matchedUnion._def.discriminator;
+        const options = matchedUnion._def.options;
+        return {
+          discriminatorKey: discKey,
+          getVariantDefault(value) {
+            for (const opt of options) {
+              const litSchema = opt.shape[discKey];
+              if (!litSchema) continue;
+              if (!isZodSchemaType(litSchema, "ZodLiteral")) continue;
+              if (litSchema._def.value === value) {
+                return getDefaultValuesFromZodSchema(opt, true, _formKey);
+              }
+            }
+            return void 0;
+          }
+        };
+      },
+      getSlimPrimitiveTypesAtPath(path) {
+        if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
+        const [strippedSchema] = stripRootSchema(_zodSchema, {
+          stripDefaultValues: true,
+          stripNullable: true,
+          stripOptional: true,
+          stripZodEffects: true
+        });
+        const slimSchema = getSlimSchema({
+          schema: strippedSchema,
+          stripConfig: { stripDefaultValues: true, stripZodEffects: true }
+        });
+        const resolved = getNestedZodSchemasAtPath(slimSchema, path);
+        if (resolved.length === 0) return /* @__PURE__ */ new Set();
+        const out = /* @__PURE__ */ new Set();
+        for (const candidate of resolved) {
+          for (const k of slimPrimitivesV3(candidate)) out.add(k);
+        }
+        return out;
+      },
+      isLeafAtPath(path) {
+        const cacheKey = canonicalizePath(path).key;
+        const cached = leafCache.get(cacheKey);
+        if (cached !== void 0) return cached;
+        const prim = abstractSchema.getSlimPrimitiveTypesAtPath(path);
+        const isLeaf = prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
+        leafCache.set(cacheKey, isLeaf);
+        return isLeaf;
+      },
+      validateAtPath(data, path, options) {
+        const trySync = options?.sync === true;
+        if (trySync) {
+          try {
+            return runSync();
+          } catch {
+          }
+        }
+        return runAsync();
+        function runSync() {
+          if (path === void 0) {
+            const { success, data: successData, error } = _zodSchema.safeParse(data);
+            return success ? { data: successData, success, errors: void 0, formKey: _formKey } : {
+              success,
+              data: void 0,
+              errors: zodIssuesToValidationErrors(error.issues, _formKey),
+              formKey: _formKey
+            };
+          }
+          const nestedZodSchemas = nestedSchemasAtPath(path);
+          if (!nestedZodSchemas.length) return pathNotFound(path);
+          const accumulatedErrors = [];
+          for (const nestedSchema of nestedZodSchemas) {
+            const { data: successData, success, error } = nestedSchema.safeParse(data);
+            if (!success) {
+              accumulatedErrors.push(error);
+              continue;
+            }
+            return { data: successData, errors: void 0, success: true, formKey: _formKey };
+          }
+          return aggregatedFailure(accumulatedErrors);
+        }
+        async function runAsync() {
+          if (path === void 0) {
+            const { success, data: successData, error } = await _zodSchema.safeParseAsync(data);
+            return success ? { data: successData, success, errors: void 0, formKey: _formKey } : {
+              success,
+              data: void 0,
+              errors: zodIssuesToValidationErrors(error.issues, _formKey),
+              formKey: _formKey
+            };
+          }
+          const nestedZodSchemas = nestedSchemasAtPath(path);
+          if (!nestedZodSchemas.length) return pathNotFound(path);
+          const accumulatedErrors = [];
+          for (const nestedSchema of nestedZodSchemas) {
+            const { data: successData, success, error } = await nestedSchema.safeParseAsync(data);
+            if (!success) {
+              accumulatedErrors.push(error);
+              continue;
+            }
+            return { data: successData, errors: void 0, success: true, formKey: _formKey };
+          }
+          return aggregatedFailure(accumulatedErrors);
+        }
+        function nestedSchemasAtPath(p) {
+          const [strippedSchema] = stripRootSchema(_zodSchema, {
+            stripDefaultValues: true,
+            stripNullable: true,
+            stripOptional: true
+          });
+          const slimSchema = getSlimSchema({
+            schema: strippedSchema,
+            stripConfig: { stripDefaultValues: true }
+          });
+          return getNestedZodSchemasAtPath(slimSchema, p);
+        }
+        function pathNotFound(p) {
+          return {
+            data: void 0,
+            errors: NO_SCHEMAS_FOUND_AT_PATH_OF_CONCRETE_SCHEMA([...p], _formKey),
+            success: false,
+            formKey: _formKey
+          };
+        }
+        function aggregatedFailure(errors) {
+          const allIssues = errors.reduce((acc, e) => [...acc, ...e.issues], []);
+          return {
+            data: void 0,
+            errors: zodIssuesToValidationErrors(allIssues, _formKey),
+            success: false,
+            formKey: _formKey
+          };
+        }
+      }
+    };
+    return abstractSchema;
+  }
+  return (formKey) => getAbstractSchema(formKey, zodSchema, true);
+}
+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.
+      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;
+}
+const NO_SCHEMAS_FOUND_AT_PATH_OF_CONCRETE_SCHEMA = (path, formKey) => [
+  {
+    message: `Programming Error: useForm.validateAtPath failed to find 1 or more schemas corresponding to the path ${path} in the concrete schema. Does the nested schema exist on form with key '${formKey}'?`,
+    path,
+    formKey,
+    code: AttaformErrorCode.PathNotFound
+  }
+];
+function getNestedZodSchemasAtPath(zodSchema, segments) {
+  function getOptionSchemasFromDiscriminatorByArbitraryKey(schema, key) {
+    const successfulOptions = [];
+    const options = schema._def.options;
+    for (const option of options) {
+      if (!(key in option.shape)) continue;
+      successfulOptions.push(option);
+    }
+    return successfulOptions;
+  }
+  let currentSchema = zodSchema;
+  for (let index = 0; index < segments.length; index++) {
+    const key = String(segments[index] ?? "");
+    if (isZodSchemaType(currentSchema, "ZodObject")) {
+      const shape = currentSchema._def.shape();
+      currentSchema = Object.hasOwn(shape, key) ? shape[key] : void 0;
+    } else if (isZodSchemaType(currentSchema, "ZodArray")) {
+      currentSchema = currentSchema._def.type;
+    } else if (isZodSchemaType(currentSchema, "ZodSet")) {
+      currentSchema = currentSchema._def.valueType;
+    } else if (isZodSchemaType(currentSchema, "ZodRecord")) {
+      currentSchema = currentSchema._def.valueType;
+    } else if (isZodSchemaType(currentSchema, "ZodDiscriminatedUnion")) {
+      const optionalSchemas = getOptionSchemasFromDiscriminatorByArbitraryKey(currentSchema, key);
+      const remainingSegments = segments.slice(index);
+      if (!remainingSegments.length) return optionalSchemas;
+      const foundSchemas = [];
+      for (const optionSchema of optionalSchemas) {
+        getNestedZodSchemasAtPath(optionSchema, remainingSegments).forEach((schema) => {
+          foundSchemas.push(schema);
+        });
+      }
+      return foundSchemas;
+    } else {
+      return [];
+    }
+  }
+  if (!currentSchema) return [];
+  return [currentSchema];
+}
+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 = current._def.innerType;
+    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")) {
+      const inner = current._def.innerType;
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodEffects")) {
+      const inner = current._def.schema;
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodPipeline")) {
+      const inner = current._def.in;
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodReadonly")) {
+      const inner = current._def.innerType;
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodBranded")) {
+      const inner = current._def.type;
+      if (!inner) return current;
+      current = inner;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+function walkV3ToLeafSchema(schema, segments) {
+  let current = schema;
+  let i = 0;
+  let safetyTicks = 0;
+  while (i < segments.length && current && safetyTicks < segments.length * MAX_UNWRAP_STEPS + MAX_UNWRAP_STEPS) {
+    safetyTicks++;
+    current = peelV3Wrappers(current);
+    const key = String(segments[i] ?? "");
+    if (isZodSchemaType(current, "ZodObject")) {
+      const shape = current._def.shape();
+      current = Object.hasOwn(shape, key) ? shape[key] : void 0;
+      i++;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodArray")) {
+      current = current._def.type;
+      i++;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodRecord")) {
+      current = current._def.valueType;
+      i++;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodTuple")) {
+      const idx = Number(key);
+      if (!Number.isInteger(idx) || idx < 0) return void 0;
+      const items = current._def.items;
+      const item = items[idx];
+      if (!item) return void 0;
+      current = item;
+      i++;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodDiscriminatedUnion")) {
+      const options = current._def.options;
+      const matching = options.filter((o) => key in o.shape);
+      const candidates = matching.length > 0 ? matching : options;
+      const first = candidates[0];
+      if (!first) return void 0;
+      current = first;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodUnion")) {
+      const options = current._def.options;
+      const first = options[0];
+      if (!first) return void 0;
+      current = first;
+      continue;
+    }
+    return void 0;
+  }
+  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")) {
+    return false;
+  }
+  if (isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded")) {
+    const inner = schema._def.innerType;
+    const branded = schema._def.type;
+    const next = inner ?? branded;
+    return next === void 0 ? true : isLeafRequiredV3(next, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodPipeline")) {
+    const inner = schema._def.in;
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodEffects")) {
+    const inner = schema._def.schema;
+    return inner === void 0 ? true : isLeafRequiredV3(inner, depth + 1);
+  }
+  if (isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+    const options = schema._def.options ?? [];
+    if (options.length === 0) return true;
+    return options.every((opt) => isLeafRequiredV3(opt, depth + 1));
+  }
+  if (isZodSchemaType(schema, "ZodIntersection")) {
+    const def = schema._def;
+    const leftReq = def.left === void 0 ? true : isLeafRequiredV3(def.left, depth + 1);
+    const rightReq = def.right === void 0 ? true : isLeafRequiredV3(def.right, depth + 1);
+    return leftReq || rightReq;
+  }
+  return true;
+}
+function unwrapToDiscriminatedUnion(schema) {
+  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")) {
+      currentSchema = currentSchema._def.innerType;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodReadonly")) {
+      const inner = currentSchema._def.innerType;
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodBranded")) {
+      const inner = currentSchema._def.type;
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    if (isZodSchemaType(currentSchema, "ZodPipeline")) {
+      const inner = currentSchema._def.in;
+      if (!inner) return void 0;
+      currentSchema = inner;
+      continue;
+    }
+    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 === "map") return /* @__PURE__ */ new Map();
+  if (expected === "promise") return new Promise((res) => res(void 0));
+  if (expected === "symbol") return Symbol();
+  if (expected === "function") return () => void 0;
+  if (expected === "undefined") return void 0;
+  if (expected === "unknown") return void 0;
+  if (expected === "nan") return Number("nan");
+  return void 0;
+}
+function unwrapDefault(schema) {
+  let current = schema;
+  for (let i = 0; i < MAX_UNWRAP_STEPS; i++) {
+    if (isZodSchemaType(current, "ZodDefault")) {
+      const defaultValue = current._def.defaultValue();
+      return [defaultValue, true];
+    }
+    if (isZodSchemaType(current, "ZodCatch")) {
+      const catchValue = current._def.catchValue;
+      if (typeof catchValue === "function") {
+        return [catchValue({ error: null, input: void 0 }), true];
+      }
+      const inner = current._def.innerType;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodNullable") || isZodSchemaType(current, "ZodOptional")) {
+      current = current._def.innerType;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodReadonly")) {
+      const inner = current._def.innerType;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodBranded")) {
+      const inner = current._def.type;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodPipeline")) {
+      const inner = current._def.in;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (isZodSchemaType(current, "ZodEffects")) {
+      const effect = current._def.effect;
+      if (effect !== null && typeof effect === "object" && "_def" in effect) {
+        current = effect;
+        continue;
+      }
+      const inner = current.innerType?.();
+      if (inner) {
+        current = inner;
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+  return [null, false];
+}
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
+  function generateValue(schema) {
+    if (useDefaultSchemaValues) {
+      const [defaultValue, foundDefaultValue] = unwrapDefault(schema);
+      if (foundDefaultValue) {
+        return defaultValue;
+      }
+    }
+    if (isZodSchemaType(schema, "ZodNullable")) {
+      return null;
+    }
+    if (isZodSchemaType(schema, "ZodObject")) {
+      const shape = schema.shape;
+      return Object.keys(shape).reduce((acc, key) => {
+        acc[key] = generateValue(shape[key]);
+        return acc;
+      }, {});
+    }
+    if (isZodSchemaType(schema, "ZodArray")) {
+      return [];
+    }
+    if (isZodSchemaType(schema, "ZodString")) {
+      return "";
+    }
+    if (isZodSchemaType(schema, "ZodNumber")) {
+      return 0;
+    }
+    if (isZodSchemaType(schema, "ZodBigInt")) {
+      return 0n;
+    }
+    if (isZodSchemaType(schema, "ZodDate")) {
+      return /* @__PURE__ */ new Date(0);
+    }
+    if (isZodSchemaType(schema, "ZodBoolean")) {
+      return false;
+    }
+    if (isZodSchemaType(schema, "ZodEnum")) {
+      return schema.options[0];
+    }
+    if (isZodSchemaType(schema, "ZodNull")) {
+      return null;
+    }
+    if (isZodSchemaType(schema, "ZodUndefined")) {
+      return void 0;
+    }
+    if (isZodSchemaType(schema, "ZodLiteral")) {
+      return schema._def.value;
+    }
+    if (isZodSchemaType(schema, "ZodOptional")) {
+      return void 0;
+    }
+    if (isZodSchemaType(schema, "ZodUnion")) {
+      return generateValue(schema._def.options[0]);
+    }
+    if (isZodSchemaType(schema, "ZodTuple")) {
+      return schema._def.items.map((item) => generateValue(item));
+    }
+    if (isZodSchemaType(schema, "ZodRecord")) {
+      return {};
+    }
+    if (isZodSchemaType(schema, "ZodDefault")) {
+      return generateValue(schema._def.innerType);
+    }
+    if (isZodSchemaType(schema, "ZodEffects")) {
+      return generateValue(schema.innerType());
+    }
+    if (isZodSchemaType(schema, "ZodDiscriminatedUnion")) {
+      const discriminantSchema = getSchemaByDiscriminatorKey(schema);
+      return generateValue(discriminantSchema);
+    }
+    if (isZodSchemaType(schema, "ZodCatch")) {
+      const catchValue = schema._def.catchValue;
+      if (typeof catchValue === "function") {
+        return catchValue({ error: null, input: void 0 });
+      }
+      const inner = schema._def.innerType;
+      if (inner) return generateValue(inner);
+    }
+    if (isZodSchemaType(schema, "ZodReadonly")) {
+      const inner = schema._def.innerType;
+      if (inner) return generateValue(inner);
+    }
+    if (isZodSchemaType(schema, "ZodBranded")) {
+      const inner = schema._def.type;
+      if (inner) return generateValue(inner);
+    }
+    if (isZodSchemaType(schema, "ZodPipeline")) {
+      const inner = schema._def.in;
+      if (inner) return generateValue(inner);
+    }
+    if (isZodSchemaType(schema, "ZodLazy")) {
+      const inner = schema._def.getter?.();
+      if (inner) return generateValue(inner);
+    }
+    if (isZodSchemaType(schema, "ZodIntersection")) {
+      const def = schema._def;
+      const left = def.left ? generateValue(def.left) : void 0;
+      const right = def.right ? generateValue(def.right) : void 0;
+      return merge({}, left, right);
+    }
+    if (isZodSchemaType(schema, "ZodNativeEnum")) {
+      const values = schema._def.values;
+      if (values) {
+        const lookup = values;
+        const validKeys = Object.keys(lookup).filter(
+          (k) => typeof lookup[lookup[k]] !== "number"
+        );
+        if (validKeys.length > 0) {
+          const first = validKeys[0];
+          if (first !== void 0) return lookup[first];
+        }
+      }
+    }
+    if (isZodSchemaType(schema, "ZodSet")) {
+      return /* @__PURE__ */ new Set();
+    }
+    console.warn(
+      `[attaform] zod-v3 adapter: unsupported schema kind '${schema.constructor.name}' on form '${formKey}'. Defaulting the field to null. Use a supported zod kind (object/array/record/string/number/etc.) at this path.`
+    );
+    return null;
+  }
+  return generateValue(formSchema);
+}
+function getSchemaByDiscriminatorKey(unionSchema, key) {
+  if (!isZodSchemaType(unionSchema, "ZodDiscriminatedUnion")) {
+    throw new TypeError("Provided schema is not a discriminated union.");
+  }
+  {
+    const options = unionSchema._def.options;
+    if (!options.length) {
+      throw new TypeError("Provided ZodDiscriminatedUnion does not have any options");
+    }
+    return options[0];
+  }
+}
+function hasChecks(schema) {
+  if (!("_def" in schema)) return false;
+  const schemaDef = schema._def;
+  if (!("checks" in schemaDef)) return false;
+  const checks = schemaDef["checks"];
+  if (!Array.isArray(checks)) return false;
+  return checks.length > 0;
+}
+function stripRefinements(schema) {
+  function _stripRefinements(_schema, depth) {
+    if (depth >= MAX_UNWRAP_STEPS) return _schema;
+    if (isZodSchemaType(_schema, "ZodString") && _schema._def.checks.length > 0) {
+      return z.string();
+    }
+    if (isZodSchemaType(_schema, "ZodNumber") && _schema._def.checks.length > 0) {
+      return z.number();
+    }
+    if (isZodSchemaType(_schema, "ZodArray")) {
+      return z.array(_stripRefinements(_schema._def.type, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodObject")) {
+      const shape = _schema.shape;
+      const strippedShape = Object.fromEntries(
+        Object.entries(shape).map(([key, value]) => [
+          key,
+          _stripRefinements(value, depth + 1)
+        ])
+      );
+      return z.object(strippedShape);
+    }
+    if (isZodSchemaType(_schema, "ZodEffects")) {
+      return _stripRefinements(_schema.innerType(), depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodOptional")) {
+      return z.optional(_stripRefinements(_schema.unwrap(), depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodNullable")) {
+      return z.nullable(_stripRefinements(_schema.unwrap(), depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodReadonly")) {
+      const inner = _schema._def.innerType;
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodBranded")) {
+      const inner = _schema._def.type;
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodPipeline")) {
+      const inner = _schema._def.in;
+      if (!inner) return _schema;
+      return _stripRefinements(inner, depth + 1);
+    }
+    if (isZodSchemaType(_schema, "ZodSet")) {
+      const valueType = _schema._def.valueType;
+      if (!valueType) return _schema;
+      return z.set(_stripRefinements(valueType, depth + 1));
+    }
+    if (isZodSchemaType(_schema, "ZodTuple")) {
+      const items = _schema._def.items;
+      if (!items) return _schema;
+      const stripped = items.map((it) => _stripRefinements(it, depth + 1));
+      return z.tuple(stripped);
+    }
+    if (isZodSchemaType(_schema, "ZodRecord")) {
+      const def = _schema._def;
+      if (!def.valueType) return _schema;
+      const value = _stripRefinements(def.valueType, depth + 1);
+      if (def.keyType) {
+        return z.record(def.keyType, value);
+      }
+      return z.record(value);
+    }
+    if (isZodSchemaType(_schema, "ZodUnion")) {
+      const options = _schema._def.options;
+      if (!options) return _schema;
+      const stripped = options.map((o) => _stripRefinements(o, depth + 1));
+      return z.union(stripped);
+    }
+    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
+      const def = _schema._def;
+      if (def.discriminator === void 0 || !def.options) return _schema;
+      const stripped = def.options.map(
+        (o) => _stripRefinements(o, depth + 1)
+      );
+      return z.discriminatedUnion(
+        def.discriminator,
+        stripped
+      );
+    }
+    if (isZodSchemaType(_schema, "ZodIntersection")) {
+      const def = _schema._def;
+      if (!def.left || !def.right) return _schema;
+      return z.intersection(
+        _stripRefinements(def.left, depth + 1),
+        _stripRefinements(def.right, depth + 1)
+      );
+    }
+    if (isZodSchemaType(_schema, "ZodLazy")) {
+      const getter = _schema._def.getter;
+      if (!getter) return _schema;
+      const stripped = _stripRefinements(getter(), 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")) {
+      return recursion(_schema.innerType(), true);
+    }
+    if (getStripInstruction(stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
+      return recursion(_schema._def.innerType, 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 in _schema.shape) {
+        const value = _schema.shape[key];
+        newShape[key] = _getSlimSchema(value);
+      }
+      return z.object(newShape);
+    }
+    if (isZodSchemaType(_schema, "ZodArray")) {
+      return z.array(_getSlimSchema(_schema.element));
+    }
+    if (isZodSchemaType(_schema, "ZodRecord")) {
+      const key = _getSlimSchema(_schema._def.keyType);
+      const value = _getSlimSchema(_schema._def.valueType);
+      return z.record(key, value);
+    }
+    if (isZodSchemaType(_schema, "ZodDiscriminatedUnion")) {
+      const slimmedSchemas = [];
+      for (const option of _schema._def.options) {
+        const slimmedSchema = _getSlimSchema(option);
+        const deepCloneSlimmedSchema = cloneDeep(slimmedSchema);
+        slimmedSchemas.push(deepCloneSlimmedSchema);
+      }
+      return z.discriminatedUnion(
+        _schema._def.discriminator,
+        slimmedSchemas
+      );
+    }
+    if (getStripInstruction(config.stripConfig.stripZodEffects, _schema) && isZodSchemaType(_schema, "ZodEffects")) {
+      return _getSlimSchema(_schema.innerType());
+    }
+    if (getStripInstruction(config.stripConfig.stripNullable, _schema) && isZodSchemaType(_schema, "ZodNullable")) {
+      return _getSlimSchema(_schema._def.innerType);
+    }
+    if (getStripInstruction(config.stripConfig.stripOptional, _schema) && isZodSchemaType(_schema, "ZodOptional")) {
+      return _getSlimSchema(_schema._def.innerType);
+    }
+    if (getStripInstruction(config.stripConfig.stripZodRefinements, _schema) && hasChecks(_schema)) {
+      return stripRefinements(_schema);
+    }
+    if (getStripInstruction(config.stripConfig.stripDefaultValues, _schema) && isZodSchemaType(_schema, "ZodDefault")) {
+      return _getSlimSchema(_schema._def.innerType);
+    }
+    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 resolveFieldMetaAtPathV3(rootSchema, path) {
+  const lastSegment = path.length === 0 ? "" : path[path.length - 1];
+  const target = path.length === 0 ? rootSchema : walkV3ToLeafSchema(rootSchema, path);
+  if (target === void 0) {
+    return {
+      label: humanize(lastSegment),
+      description: void 0,
+      placeholder: void 0,
+      meta: Object.freeze({})
+    };
+  }
+  const peeled = peelV3Wrappers(target);
+  const payload = 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 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.DdnithOf.mjs.map