attaform 0.15.0 → 0.16.0

package/dist/shared/attaform.DfrYByDj.cjs

@@ -0,0 +1,1916 @@
+'use strict';
+
+const useFormContext = require('./attaform.C9Ph2SMx.cjs');
+const plugin = require('./attaform.rIRYSUI1.cjs');
+const zod = require('zod');
+const paths = require('./attaform.c_NzdRyc.cjs');
+
+const fieldMeta = zod.z.registry();
+const fieldMetaLists = /* @__PURE__ */ new WeakMap();
+const originalAdd = fieldMeta.add.bind(fieldMeta);
+fieldMeta.add = function add(schema, payload) {
+  const list = fieldMetaLists.get(schema) ?? [];
+  list.push(payload);
+  fieldMetaLists.set(schema, list);
+  return originalAdd(schema, payload);
+};
+function getFieldMetaList(schema) {
+  return fieldMetaLists.get(schema) ?? [];
+}
+function withMeta(schema, payload) {
+  const existing = fieldMeta.get(schema) ?? {};
+  const cloned = schema.clone();
+  fieldMeta.add(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function getFieldMeta(schema) {
+  return fieldMeta.get(schema);
+}
+
+let warnedZodCodeMissing = false;
+function zodIssuesToValidationErrors(issues, formKey) {
+  return issues.map((issue) => {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+      if (plugin.__DEV__ && !warnedZodCodeMissing) {
+        warnedZodCodeMissing = true;
+        console.warn(
+          "[attaform] zod-v4 adapter received an issue with no string `code`; stamping `'zod:unknown'`. This usually means a custom Zod plugin emitted an issue without the standard code field."
+        );
+      }
+    }
+    return {
+      message: issue.message,
+      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
+      formKey,
+      code
+    };
+  });
+}
+class UnsupportedSchemaError extends plugin.AttaformError {
+}
+
+function readDef(schema) {
+  if (schema === null || typeof schema !== "object") return void 0;
+  return schema.def;
+}
+function kindOf(schema) {
+  const def = readDef(schema);
+  const rawType = def?.type;
+  if (rawType === void 0) return "unknown";
+  switch (rawType) {
+    case "object":
+      return "object";
+    case "array":
+      return "array";
+    case "set":
+      return "set";
+    case "record":
+      return "record";
+    case "tuple":
+      return "tuple";
+    case "union":
+      return def?.discriminator !== void 0 ? "discriminated-union" : "union";
+    case "discriminated_union":
+    case "discriminatedUnion":
+      return "discriminated-union";
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "date":
+      return "date";
+    case "enum":
+      return "enum";
+    case "literal":
+      return "literal";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "optional":
+      return "optional";
+    case "nullable":
+      return "nullable";
+    case "default":
+    case "prefault":
+      return "default";
+    case "pipe":
+      return "pipe";
+    case "readonly":
+      return "readonly";
+    case "any":
+      return "any";
+    case "nan":
+      return "nan";
+    case "void":
+      return "void";
+    case "never":
+      return "never";
+    case "lazy":
+      return "lazy";
+    case "intersection":
+      return "intersection";
+    case "catch":
+      return "catch";
+    case "promise":
+      return "promise";
+    case "custom":
+      return "custom";
+    case "template_literal":
+    case "templateLiteral":
+      return "template-literal";
+    default:
+      return "unknown";
+  }
+}
+function getObjectShape(schema) {
+  const s = schema;
+  return s.shape;
+}
+function getArrayElement(schema) {
+  const def = readDef(schema);
+  return def?.element;
+}
+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 getLiteralValues(schema) {
+  const def = readDef(schema);
+  return def?.values ?? [];
+}
+function getEnumValues(schema) {
+  const def = readDef(schema);
+  const entries = def?.entries;
+  if (entries === void 0) return [];
+  return Object.values(entries);
+}
+function unwrapInner(schema) {
+  const def = readDef(schema);
+  return def?.innerType;
+}
+function unwrapPipe(schema) {
+  const def = readDef(schema);
+  return def?.in ?? def?.out;
+}
+function unwrapLazy(schema) {
+  const def = readDef(schema);
+  const getter = def?.getter;
+  if (typeof getter !== "function") return void 0;
+  return getter();
+}
+function getLazyGetter(schema) {
+  const def = readDef(schema);
+  return typeof def?.getter === "function" ? def.getter : void 0;
+}
+function getIntersectionLeft(schema) {
+  const def = readDef(schema);
+  return def?.left;
+}
+function getIntersectionRight(schema) {
+  const def = readDef(schema);
+  return def?.right;
+}
+function getCatchDefault(schema) {
+  const def = readDef(schema);
+  const cv = def?.catchValue;
+  if (typeof cv !== "function") return void 0;
+  try {
+    return cv({ error: new Error("atta:default-values"), input: void 0 });
+  } catch {
+    return void 0;
+  }
+}
+function getDefaultValue(schema) {
+  const def = readDef(schema);
+  return def?.defaultValue;
+}
+function hasChecks(schema) {
+  const def = readDef(schema);
+  const checks = def?.checks;
+  return Array.isArray(checks) && checks.length > 0;
+}
+function getChecks(schema) {
+  const def = readDef(schema);
+  const checks = def?.checks;
+  return Array.isArray(checks) ? checks : [];
+}
+function getDiscriminator(schema) {
+  const def = readDef(schema);
+  return def?.discriminator;
+}
+function getDiscriminatedOptions(schema) {
+  const def = readDef(schema);
+  const options = def?.options;
+  return Array.isArray(options) ? options : [];
+}
+function assertZodVersion(schema) {
+  const def = readDef(schema);
+  if (def?.type === void 0) {
+    throw new Error(
+      "[attaform/zod-v4] Schema is not a Zod v4 schema. The `attaform/zod-v4` adapter requires zod@^4. Either: (a) install zod@^4 in your project; (b) import from `attaform/zod`, which auto-detects the Zod version (and tree-shakes to a single adapter when the `attaform/vite` plugin is active); or (c) import from `attaform/zod-v3` if you are staying on Zod v3."
+    );
+  }
+}
+function containsAsyncRefine(schema, seen) {
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  const candidate = schema;
+  if (typeof candidate !== "object" || candidate === null) return false;
+  if (visited.has(candidate)) return false;
+  visited.add(candidate);
+  const checks = getChecks(schema);
+  for (const check of checks) {
+    if (isAsyncCheck(check)) return true;
+  }
+  const def = readDef(schema);
+  if (def === void 0) return false;
+  if (def.innerType !== void 0 && containsAsyncRefine(def.innerType, visited)) {
+    return true;
+  }
+  if (def.element !== void 0 && containsAsyncRefine(def.element, visited)) {
+    return true;
+  }
+  if (def.in !== void 0 && containsAsyncRefine(def.in, visited)) {
+    return true;
+  }
+  if (def.out !== void 0 && containsAsyncRefine(def.out, visited)) {
+    return true;
+  }
+  if (def.left !== void 0 && containsAsyncRefine(def.left, visited)) {
+    return true;
+  }
+  if (def.right !== void 0 && containsAsyncRefine(def.right, visited)) {
+    return true;
+  }
+  if (def.keyType !== void 0 && containsAsyncRefine(def.keyType, visited)) {
+    return true;
+  }
+  if (def.valueType !== void 0 && containsAsyncRefine(def.valueType, visited)) {
+    return true;
+  }
+  if (def.shape !== void 0) {
+    for (const sub of Object.values(def.shape)) {
+      if (containsAsyncRefine(sub, visited)) return true;
+    }
+  }
+  if (def.entries !== void 0) {
+    for (const sub of Object.values(def.entries)) {
+      if (containsAsyncRefine(sub, visited)) return true;
+    }
+  }
+  if (def.options !== void 0) {
+    for (const sub of def.options) {
+      if (containsAsyncRefine(sub, visited)) return true;
+    }
+  }
+  if (def.items !== void 0) {
+    for (const sub of def.items) {
+      if (containsAsyncRefine(sub, visited)) return true;
+    }
+  }
+  if (typeof def.getter === "function") {
+    try {
+      const inner = def.getter();
+      if (containsAsyncRefine(inner, visited)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function isAsyncCheck(check) {
+  if (typeof check !== "object" || check === null) return false;
+  const c = check;
+  const fn = c._def?.fn ?? c.def?.fn ?? c._zod?.def?.fn;
+  if (typeof fn !== "function") return false;
+  return fn.constructor.name === "AsyncFunction";
+}
+
+const UNSUPPORTED = ["promise", "custom", "template-literal"];
+function labelPath(path) {
+  return path.length === 0 ? "<root>" : path.join(".");
+}
+function assertSupportedKinds(schema, path = [], lazyGetters = []) {
+  const kind = kindOf(schema);
+  if (UNSUPPORTED.includes(kind)) {
+    throw new UnsupportedSchemaError(
+      `[attaform/zod] unsupported kind '${kind}' at '${labelPath(path)}'`
+    );
+  }
+  switch (kind) {
+    case "object": {
+      const shape = getObjectShape(schema);
+      for (const [key, sub] of Object.entries(shape)) {
+        assertSupportedKinds(sub, [...path, key], lazyGetters);
+      }
+      return;
+    }
+    case "array":
+      assertSupportedKinds(getArrayElement(schema), [...path, "*"], lazyGetters);
+      return;
+    case "set":
+      assertSupportedKinds(getSetValueType(schema), [...path, "*"], lazyGetters);
+      return;
+    case "record":
+      assertSupportedKinds(getRecordValueType(schema), [...path, "*"], lazyGetters);
+      return;
+    case "tuple": {
+      const items = getTupleItems(schema);
+      items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
+      return;
+    }
+    case "union": {
+      const options = getUnionOptions(schema);
+      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+      return;
+    }
+    case "discriminated-union": {
+      const options = getDiscriminatedOptions(schema);
+      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
+      return;
+    }
+    case "optional":
+    case "nullable":
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = unwrapInner(schema);
+      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
+      return;
+    }
+    case "pipe": {
+      const inner = unwrapPipe(schema);
+      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
+      return;
+    }
+    case "lazy": {
+      const getter = getLazyGetter(schema);
+      if (getter !== void 0 && lazyGetters.includes(getter)) {
+        throw new UnsupportedSchemaError(
+          `[attaform/zod] Recursive z.lazy() at '${labelPath(path)}'`
+        );
+      }
+      const inner = unwrapLazy(schema);
+      if (inner !== void 0) {
+        assertSupportedKinds(
+          inner,
+          path,
+          getter === void 0 ? lazyGetters : [...lazyGetters, getter]
+        );
+      }
+      return;
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      if (left !== void 0) assertSupportedKinds(left, [...path, "left"], lazyGetters);
+      if (right !== void 0) assertSupportedKinds(right, [...path, "right"], lazyGetters);
+      return;
+    }
+    // Leaves: nothing to descend into.
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "date":
+    case "enum":
+    case "literal":
+    case "null":
+    case "undefined":
+    case "nan":
+    case "any":
+    case "unknown":
+    case "void":
+    case "never":
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return;
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`assertSupportedKinds: unhandled ZodKind '${_exhaustive}'`);
+    }
+  }
+}
+
+function unwrapToDiscriminatedUnion(schema) {
+  let current = schema;
+  for (let i = 0; i < 64; i++) {
+    const kind = kindOf(current);
+    if (kind === "discriminated-union") return current;
+    let next;
+    if (kind === "optional" || kind === "nullable" || kind === "default" || kind === "readonly") {
+      next = unwrapInner(current);
+    } else if (kind === "pipe") {
+      next = unwrapPipe(current);
+    }
+    if (next === void 0) return void 0;
+    current = next;
+  }
+  return void 0;
+}
+function getDiscriminatedUnionFirstOption(schema) {
+  const options = getDiscriminatedOptions(schema);
+  return options[0];
+}
+
+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 cached = cache.get(schema);
+  if (cached !== void 0) return cached;
+  if (inProgress.has(schema)) return cyclicSentinel;
+  inProgress.add(schema);
+  try {
+    const computed = computeFingerprint(schema, cache, inProgress);
+    cache.set(schema, computed);
+    return computed;
+  } finally {
+    inProgress.delete(schema);
+  }
+}
+function computeFingerprint(schema, cache, inProgress) {
+  const kind = kindOf(schema);
+  const recurse = (child) => visit(child, cache, inProgress);
+  switch (kind) {
+    // Kind-only leaves: no further structure to descend into.
+    case "boolean":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "nan":
+    case "void":
+    case "never":
+      return kind;
+    // Leaves with checks (min/max/email/regex/...). Checks are
+    // canonicalised and sorted so `.min(3).max(10)` and `.max(10).min(3)`
+    // produce identical fingerprints.
+    case "string":
+    case "number":
+    case "bigint":
+    case "date":
+      return `${kind}${formatChecks(schema)}`;
+    case "literal": {
+      const values = [...getLiteralValues(schema)].sort((a, b) => {
+        const as = canonicalStringify(a);
+        const bs = canonicalStringify(b);
+        return as < bs ? -1 : as > bs ? 1 : 0;
+      });
+      return `literal:${canonicalStringify(values)}`;
+    }
+    case "enum":
+      return `enum:${canonicalStringify([...getEnumValues(schema)].sort((a, b) => compare(a, b)))}`;
+    case "object": {
+      const shape = getObjectShape(schema);
+      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
+      return `object{${sortedEntries.join(",")}}${formatChecks(schema)}`;
+    }
+    case "array":
+      return `array[${recurse(getArrayElement(schema))}]${formatChecks(schema)}`;
+    case "set":
+      return `set<${recurse(getSetValueType(schema))}>${formatChecks(schema)}`;
+    case "tuple":
+      return `tuple[${getTupleItems(schema).map(recurse).join(",")}]`;
+    case "record":
+      return `record<${recurse(getRecordKeyType(schema))},${recurse(getRecordValueType(schema))}>`;
+    case "union": {
+      const options = getUnionOptions(schema).map(recurse).sort();
+      return `union(${options.join("|")})`;
+    }
+    case "discriminated-union": {
+      const disc = getDiscriminator(schema) ?? "?";
+      const options = getDiscriminatedOptions(schema).map(recurse).sort();
+      return `dunion[${JSON.stringify(disc)}](${options.join("|")})`;
+    }
+    case "optional": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? "optional(?)" : `optional(${recurse(inner)})`;
+    }
+    case "nullable": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? "nullable(?)" : `nullable(${recurse(inner)})`;
+    }
+    case "default": {
+      const inner = unwrapInner(schema);
+      return `default[${stableValueRepr(getDefaultValue, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
+    }
+    case "readonly": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? "readonly(?)" : `readonly(${recurse(inner)})`;
+    }
+    case "pipe": {
+      const inner = unwrapPipe(schema);
+      return inner === void 0 ? "pipe(?)" : `pipe(${recurse(inner)})`;
+    }
+    case "catch": {
+      const inner = unwrapInner(schema);
+      return `catch[${stableValueRepr(getCatchDefault, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
+    }
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      return inner === void 0 ? "lazy(?)" : `lazy(${recurse(inner)})`;
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      const leftFp = left === void 0 ? "?" : recurse(left);
+      const rightFp = right === void 0 ? "?" : recurse(right);
+      const parts = [leftFp, rightFp].sort();
+      return `intersection(${parts.join("&")})`;
+    }
+    // Structural shape isn't observable for these. Bucket them into
+    // kind-only fingerprints — a schema-mismatch warning can't do
+    // better than "both are `custom`" here, but that still catches
+    // `object` vs `custom` mismatches.
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return `${kind}:*`;
+    default: {
+      const _ = kind;
+      return `unknown:${String(_)}`;
+    }
+  }
+}
+function stableValueRepr(get, schema) {
+  const first = get(schema);
+  const second = get(schema);
+  if (!Object.is(first, second) || typeof first === "function") return "fn:*";
+  return canonicalStringify(first);
+}
+function formatChecks(schema) {
+  const checks = getChecks(schema);
+  if (checks.length === 0) return "";
+  const parts = checks.map((c) => serializeCheck(c)).sort();
+  return `[${parts.join(";")}]`;
+}
+function serializeCheck(check) {
+  if (check !== null && typeof check === "object") {
+    const def = check._zod?.def;
+    if (def !== void 0) return canonicalStringify(def);
+  }
+  return canonicalStringify(check);
+}
+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 {
+      const parts = value.map((v) => canonicalStringify(v, seen));
+      return `[${parts.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";
+}
+function compare(a, b) {
+  const as = String(a);
+  const bs = String(b);
+  return as < bs ? -1 : as > bs ? 1 : 0;
+}
+
+const PERMISSIVE = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "date",
+  "null",
+  "undefined",
+  "object",
+  "array",
+  "symbol",
+  "function",
+  "map",
+  "set"
+]);
+const MAX_LAZY_DEPTH = 64;
+function slimPrimitivesOf(schema) {
+  return walk(schema, 0);
+}
+function walk(schema, depth) {
+  if (depth > MAX_LAZY_DEPTH) return new Set(PERMISSIVE);
+  const kind = kindOf(schema);
+  switch (kind) {
+    case "string":
+      return /* @__PURE__ */ new Set(["string"]);
+    case "number":
+    case "nan":
+      return /* @__PURE__ */ new Set(["number"]);
+    case "boolean":
+      return /* @__PURE__ */ new Set(["boolean"]);
+    case "bigint":
+      return /* @__PURE__ */ new Set(["bigint"]);
+    case "date":
+      return /* @__PURE__ */ new Set(["date"]);
+    case "null":
+      return /* @__PURE__ */ new Set(["null"]);
+    case "undefined":
+    case "void":
+      return /* @__PURE__ */ new Set(["undefined"]);
+    case "enum": {
+      const values = getEnumValues(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const v of values) {
+        if (typeof v === "string") out.add("string");
+        else if (typeof v === "number") out.add("number");
+      }
+      return out.size === 0 ? /* @__PURE__ */ new Set(["string"]) : out;
+    }
+    case "literal": {
+      const values = getLiteralValues(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const v of values) out.add(slimKindOfRaw(v));
+      return out.size === 0 ? new Set(PERMISSIVE) : out;
+    }
+    case "object":
+    case "record":
+      return /* @__PURE__ */ new Set(["object"]);
+    case "array":
+    case "tuple":
+      return /* @__PURE__ */ new Set(["array"]);
+    case "set":
+      return /* @__PURE__ */ new Set(["set"]);
+    case "optional": {
+      const inner = unwrapInner(schema);
+      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, depth + 1);
+      innerSet.add("undefined");
+      return innerSet;
+    }
+    case "nullable": {
+      const inner = unwrapInner(schema);
+      const innerSet = inner === void 0 ? /* @__PURE__ */ new Set() : walk(inner, depth + 1);
+      innerSet.add("null");
+      return innerSet;
+    }
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+    }
+    case "pipe": {
+      const inner = unwrapPipe(schema);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+    }
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      return inner === void 0 ? new Set(PERMISSIVE) : walk(inner, depth + 1);
+    }
+    case "union":
+    case "discriminated-union": {
+      const options = getUnionOptions(schema);
+      const out = /* @__PURE__ */ new Set();
+      for (const opt of options) {
+        for (const k of walk(opt, depth + 1)) out.add(k);
+      }
+      return out.size === 0 ? new Set(PERMISSIVE) : out;
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      const leftSet = left === void 0 ? new Set(PERMISSIVE) : walk(left, depth + 1);
+      const rightSet = right === void 0 ? new Set(PERMISSIVE) : walk(right, depth + 1);
+      const out = /* @__PURE__ */ new Set();
+      for (const k of leftSet) if (rightSet.has(k)) out.add(k);
+      return out;
+    }
+    case "never":
+      return /* @__PURE__ */ new Set();
+    case "any":
+    case "unknown":
+      return new Set(PERMISSIVE);
+    // Kinds we don't understand at the slim level: be permissive to
+    // avoid false-rejecting legitimate writes against schema shapes
+    // we haven't characterised.
+    case "promise":
+    case "custom":
+    case "template-literal":
+    default:
+      return new Set(PERMISSIVE);
+  }
+}
+function slimKindOfRaw(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  const t = typeof value;
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return "object";
+    case "function":
+      return "function";
+    default:
+      return "object";
+  }
+}
+
+const PATH_SEPARATOR$1 = ".";
+function getNestedZodSchemasAtPath(schema, path) {
+  if (Array.isArray(path)) return walkSegments(schema, path.map(String));
+  const pathString = path;
+  if (pathString.length === 0) return [schema];
+  return walkSegments(schema, pathString.split(PATH_SEPARATOR$1));
+}
+function walkSegments(schema, segments) {
+  if (segments.length === 0) return [schema];
+  const [head, ...rest] = segments;
+  if (head === void 0) return [schema];
+  const kind = kindOf(schema);
+  switch (kind) {
+    case "object": {
+      const shape = getObjectShape(schema);
+      if (!Object.hasOwn(shape, head)) return [];
+      const next = shape[head];
+      return next === void 0 ? [] : walkSegments(next, rest);
+    }
+    case "array":
+      return walkSegments(getArrayElement(schema), rest);
+    case "set":
+      return walkSegments(getSetValueType(schema), rest);
+    case "record":
+      return walkSegments(getRecordValueType(schema), rest);
+    case "tuple": {
+      const index = Number(head);
+      if (!Number.isInteger(index)) return [];
+      const items = getTupleItems(schema);
+      const item = items[index];
+      return item === void 0 ? [] : walkSegments(item, rest);
+    }
+    case "union":
+      return getUnionOptions(schema).flatMap((opt) => walkSegments(opt, segments));
+    case "discriminated-union": {
+      const options = getDiscriminatedOptions(schema);
+      const matching = options.filter((opt) => {
+        const shape = getObjectShape(opt);
+        return Object.hasOwn(shape, head);
+      });
+      const candidates = matching.length > 0 ? matching : options;
+      return candidates.flatMap((opt) => walkSegments(opt, segments));
+    }
+    case "optional":
+    case "nullable":
+    case "default":
+    case "readonly":
+    case "catch": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? [] : walkSegments(inner, segments);
+    }
+    case "pipe": {
+      const inner = unwrapPipe(schema);
+      return inner === void 0 ? [] : walkSegments(inner, segments);
+    }
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      return inner === void 0 ? [] : walkSegments(inner, segments);
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      const leftResults = left === void 0 ? [] : walkSegments(left, segments);
+      const rightResults = right === void 0 ? [] : walkSegments(right, segments);
+      return [...leftResults, ...rightResults];
+    }
+    // Leaf types — can't descend further.
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "undefined":
+    case "null":
+    case "void":
+    case "never":
+    case "any":
+    case "unknown":
+    case "date":
+    case "enum":
+    case "literal":
+    case "nan":
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return [];
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`walkSegments: unhandled ZodKind '${_exhaustive}'`);
+    }
+  }
+}
+
+function carryChecks(rebuilt, original, stripConfig) {
+  if (stripConfig.stripRefinements === true) return rebuilt;
+  if (!hasChecks(original)) return rebuilt;
+  const all = getChecks(original);
+  const checks = stripConfig.shouldKeepCheck === void 0 ? all : all.filter(stripConfig.shouldKeepCheck);
+  if (checks.length === 0) return rebuilt;
+  return rebuilt.check(
+    ...checks
+  );
+}
+function stripRefinements(schema) {
+  const kind = kindOf(schema);
+  switch (kind) {
+    case "string":
+      return hasChecks(schema) ? zod.z.string() : schema;
+    case "number":
+      return hasChecks(schema) ? zod.z.number() : schema;
+    case "bigint":
+      return hasChecks(schema) ? zod.z.bigint() : schema;
+    case "array": {
+      const element = getArrayElement(schema);
+      return zod.z.array(stripRefinements(element));
+    }
+    case "set": {
+      const valueType = getSetValueType(schema);
+      return zod.z.set(stripRefinements(valueType));
+    }
+    case "tuple": {
+      const items = getTupleItems(schema).map(stripRefinements);
+      return zod.z.tuple(items);
+    }
+    case "object": {
+      const shape = getObjectShape(schema);
+      const next = {};
+      for (const [k, v] of Object.entries(shape)) {
+        next[k] = stripRefinements(v);
+      }
+      return zod.z.object(next);
+    }
+    case "record": {
+      const keyType = getRecordKeyType(
+        schema
+      );
+      const valueType = stripRefinements(getRecordValueType(schema));
+      return zod.z.record(keyType, valueType);
+    }
+    case "union": {
+      const options = getUnionOptions(schema).map(stripRefinements);
+      return zod.z.union(options);
+    }
+    case "discriminated-union": {
+      const options = getDiscriminatedOptions(schema).map(
+        (opt) => stripRefinements(opt)
+      );
+      const discriminator = getDiscriminator(schema);
+      if (discriminator === void 0) return schema;
+      return zod.z.discriminatedUnion(
+        discriminator,
+        options
+      );
+    }
+    // Wrappers: strip the inner, preserve the wrapper semantics where
+    // possible. For stripping refinements we typically want wrappers to
+    // survive (optional/nullable/default), so leave them alone.
+    case "optional":
+    case "nullable":
+    case "default":
+    case "readonly":
+    case "pipe":
+      return schema;
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      if (inner === void 0) return schema;
+      const slimmedInner = stripRefinements(inner);
+      return zod.z.lazy(() => slimmedInner);
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      if (left === void 0 || right === void 0) return schema;
+      return zod.z.intersection(stripRefinements(left), stripRefinements(right));
+    }
+    case "catch": {
+      const inner = unwrapInner(schema);
+      if (inner === void 0) return schema;
+      const slimmedInner = stripRefinements(inner);
+      return slimmedInner.catch(getCatchDefault(schema));
+    }
+    // Leaf types without refinements, or Zod features we don't rewrite.
+    case "boolean":
+    case "date":
+    case "enum":
+    case "literal":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "nan":
+    case "void":
+    case "never":
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return schema;
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`stripRefinements: unhandled ZodKind '${_exhaustive}'`);
+    }
+  }
+}
+function stripAsyncChecks(schema) {
+  const config = {
+    stripRefinements: false,
+    shouldKeepCheck: (c) => !isAsyncCheck(c)
+  };
+  const seen = /* @__PURE__ */ new WeakSet();
+  function recurse(s) {
+    if (seen.has(s)) return s;
+    seen.add(s);
+    const kind = kindOf(s);
+    switch (kind) {
+      case "string":
+        return hasChecks(s) ? carryChecks(zod.z.string(), s, config) : s;
+      case "number":
+        return hasChecks(s) ? carryChecks(zod.z.number(), s, config) : s;
+      case "bigint":
+        return hasChecks(s) ? carryChecks(zod.z.bigint(), s, config) : s;
+      case "array": {
+        const element = getArrayElement(s);
+        return carryChecks(zod.z.array(recurse(element)), s, config);
+      }
+      case "set": {
+        const valueType = getSetValueType(s);
+        return carryChecks(zod.z.set(recurse(valueType)), s, config);
+      }
+      case "tuple": {
+        const items = getTupleItems(s).map(recurse);
+        const rebuilt = zod.z.tuple(
+          items
+        );
+        return carryChecks(rebuilt, s, config);
+      }
+      case "object": {
+        const shape = getObjectShape(s);
+        const next = {};
+        for (const [k, v] of Object.entries(shape)) {
+          next[k] = recurse(v);
+        }
+        return carryChecks(zod.z.object(next), s, config);
+      }
+      case "record": {
+        const keyType = getRecordKeyType(s);
+        const valueType = recurse(getRecordValueType(s));
+        const rebuilt = zod.z.record(keyType, valueType);
+        return carryChecks(rebuilt, s, config);
+      }
+      case "union": {
+        const options = getUnionOptions(s).map(recurse);
+        const rebuilt = zod.z.union(
+          options
+        );
+        return carryChecks(rebuilt, s, config);
+      }
+      case "discriminated-union": {
+        const options = getDiscriminatedOptions(s).map((opt) => recurse(opt));
+        const discriminator = getDiscriminator(s);
+        if (discriminator === void 0) return s;
+        return zod.z.discriminatedUnion(
+          discriminator,
+          options
+        );
+      }
+      case "optional": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).optional();
+      }
+      case "nullable": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).nullable();
+      }
+      case "default": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).default(getDefaultValue(s));
+      }
+      case "readonly": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).readonly();
+      }
+      case "pipe":
+        return s;
+      case "lazy": {
+        const inner = unwrapLazy(s);
+        if (inner === void 0) return s;
+        const stripped = recurse(inner);
+        return zod.z.lazy(() => stripped);
+      }
+      case "intersection": {
+        const left = getIntersectionLeft(s);
+        const right = getIntersectionRight(s);
+        if (left === void 0 || right === void 0) return s;
+        return zod.z.intersection(recurse(left), recurse(right));
+      }
+      case "catch": {
+        const inner = unwrapInner(s);
+        if (inner === void 0) return s;
+        return recurse(inner).catch(getCatchDefault(s));
+      }
+      // Leaves with no checks — pass through unchanged.
+      case "boolean":
+      case "date":
+      case "enum":
+      case "literal":
+      case "null":
+      case "undefined":
+      case "any":
+      case "unknown":
+      case "nan":
+      case "void":
+      case "never":
+      case "promise":
+      case "custom":
+      case "template-literal":
+        return s;
+      default: {
+        const _exhaustive = kind;
+        throw new Error(`stripAsyncChecks: unhandled ZodKind '${_exhaustive}'`);
+      }
+    }
+  }
+  return recurse(schema);
+}
+function getSlimSchema(schema, stripConfig) {
+  const kind = kindOf(schema);
+  switch (kind) {
+    case "optional": {
+      const inner = unwrapInner(schema) ?? schema;
+      const slimmedInner = getSlimSchema(inner, stripConfig);
+      return stripConfig.stripOptional === true ? slimmedInner : slimmedInner.optional();
+    }
+    case "nullable": {
+      const inner = unwrapInner(schema) ?? schema;
+      const slimmedInner = getSlimSchema(inner, stripConfig);
+      return stripConfig.stripNullable === true ? slimmedInner : slimmedInner.nullable();
+    }
+    case "default": {
+      const inner = unwrapInner(schema) ?? schema;
+      const slimmedInner = getSlimSchema(inner, stripConfig);
+      if (stripConfig.stripDefaultValues === true) return slimmedInner;
+      const defaultValue = getDefaultValue(schema);
+      return slimmedInner.default(defaultValue);
+    }
+    case "readonly": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? schema : getSlimSchema(inner, stripConfig).readonly();
+    }
+    case "pipe": {
+      if (stripConfig.stripPipe === true) {
+        const inner = unwrapPipe(schema) ?? schema;
+        return getSlimSchema(inner, stripConfig);
+      }
+      return schema;
+    }
+    case "object": {
+      const shape = getObjectShape(schema);
+      const next = {};
+      for (const [k, v] of Object.entries(shape)) {
+        next[k] = getSlimSchema(v, stripConfig);
+      }
+      return carryChecks(zod.z.object(next), schema, stripConfig);
+    }
+    case "array": {
+      const element = getArrayElement(schema);
+      return carryChecks(zod.z.array(getSlimSchema(element, stripConfig)), schema, stripConfig);
+    }
+    case "set": {
+      const valueType = getSetValueType(schema);
+      return carryChecks(zod.z.set(getSlimSchema(valueType, stripConfig)), schema, stripConfig);
+    }
+    case "tuple": {
+      const items = getTupleItems(schema).map((it) => getSlimSchema(it, stripConfig));
+      const rebuilt = zod.z.tuple(
+        items
+      );
+      return carryChecks(rebuilt, schema, stripConfig);
+    }
+    case "record": {
+      const keyType = getRecordKeyType(schema);
+      const valueType = getSlimSchema(getRecordValueType(schema), stripConfig);
+      const rebuilt = zod.z.record(keyType, valueType);
+      return carryChecks(rebuilt, schema, stripConfig);
+    }
+    case "union": {
+      const options = getUnionOptions(schema).map((opt) => getSlimSchema(opt, stripConfig));
+      const rebuilt = zod.z.union(options);
+      return carryChecks(rebuilt, schema, stripConfig);
+    }
+    case "discriminated-union": {
+      const options = getDiscriminatedOptions(schema).map(
+        (opt) => getSlimSchema(opt, stripConfig)
+      );
+      const discriminator = getDiscriminator(schema);
+      if (discriminator === void 0) return schema;
+      return zod.z.discriminatedUnion(
+        discriminator,
+        options
+      );
+    }
+    // Leaves: strip refinements if requested, otherwise pass through.
+    case "string":
+    case "number":
+    case "bigint":
+      return stripConfig.stripRefinements === true && hasChecks(schema) ? stripRefinements(schema) : schema;
+    case "boolean":
+    case "date":
+    case "enum":
+    case "literal":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "nan":
+    case "void":
+    case "never":
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return schema;
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      if (inner === void 0) return schema;
+      const slimmedInner = getSlimSchema(inner, stripConfig);
+      return zod.z.lazy(() => slimmedInner);
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      if (left === void 0 || right === void 0) return schema;
+      return zod.z.intersection(getSlimSchema(left, stripConfig), getSlimSchema(right, stripConfig));
+    }
+    case "catch": {
+      const inner = unwrapInner(schema);
+      if (inner === void 0) return schema;
+      const slimmedInner = getSlimSchema(inner, stripConfig);
+      return slimmedInner.catch(getCatchDefault(schema));
+    }
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`getSlimSchema: unhandled ZodKind '${_exhaustive}'`);
+    }
+  }
+}
+
+function deriveDefault(schema, useDefault) {
+  return defaultForKind(kindOf(schema), schema, useDefault);
+}
+function defaultForKind(kind, schema, useDefault) {
+  switch (kind) {
+    case "object": {
+      const shape = getObjectShape(schema);
+      const out = {};
+      for (const [key, subSchema] of Object.entries(shape)) {
+        out[key] = deriveDefault(subSchema, useDefault);
+      }
+      return out;
+    }
+    case "default": {
+      if (useDefault) return getDefaultValue(schema);
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+    }
+    case "optional":
+      return void 0;
+    case "nullable":
+      return null;
+    case "readonly": {
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+    }
+    case "pipe": {
+      const inner = unwrapPipe(schema);
+      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+    }
+    case "array":
+      return [];
+    case "set":
+      return /* @__PURE__ */ new Set();
+    case "record":
+      return {};
+    case "tuple": {
+      const items = getTupleItems(schema);
+      return items.map((item) => deriveDefault(item, useDefault));
+    }
+    case "union": {
+      const options = getUnionOptions(schema);
+      const first = options[0];
+      return first === void 0 ? void 0 : deriveDefault(first, useDefault);
+    }
+    case "discriminated-union": {
+      const first = getDiscriminatedUnionFirstOption(schema);
+      return first === void 0 ? void 0 : deriveDefault(first, useDefault);
+    }
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "bigint":
+      return 0n;
+    case "boolean":
+      return false;
+    case "date":
+      return /* @__PURE__ */ new Date(0);
+    case "null":
+      return null;
+    case "undefined":
+      return void 0;
+    case "enum": {
+      const values = getEnumValues(schema);
+      return values[0];
+    }
+    case "literal": {
+      const values = getLiteralValues(schema);
+      return values[0];
+    }
+    case "nan":
+      return NaN;
+    case "lazy": {
+      const inner = unwrapLazy(schema);
+      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+    }
+    case "intersection": {
+      const left = getIntersectionLeft(schema);
+      const right = getIntersectionRight(schema);
+      const l = left === void 0 ? void 0 : deriveDefault(left, useDefault);
+      const r = right === void 0 ? void 0 : deriveDefault(right, useDefault);
+      return mergeDeep(l, r);
+    }
+    case "catch": {
+      if (useDefault) return getCatchDefault(schema);
+      const inner = unwrapInner(schema);
+      return inner === void 0 ? void 0 : deriveDefault(inner, useDefault);
+    }
+    case "any":
+    case "unknown":
+    case "void":
+    case "never":
+    case "promise":
+    case "custom":
+    case "template-literal":
+      return void 0;
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`deriveDefault: unhandled ZodKind '${_exhaustive}'`);
+    }
+  }
+}
+function mergeDeep(base, override) {
+  if (override === void 0) return base;
+  if (!useFormContext.isPlainRecord(override)) return override;
+  if (!useFormContext.isPlainRecord(base)) return override;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const oVal = override[key];
+    const bVal = base[key];
+    if (useFormContext.isPlainRecord(oVal) && useFormContext.isPlainRecord(bVal)) {
+      result[key] = mergeDeep(bVal, oVal);
+    } else if (oVal !== void 0) {
+      result[key] = oVal;
+    }
+  }
+  return result;
+}
+function getDefaultValuesFromZodSchema(opts) {
+  const { schema, useDefaultSchemaValues, constraints } = opts;
+  const initial = deriveDefault(schema, useDefaultSchemaValues);
+  const merged = mergeDeep(initial, constraints);
+  const slimSchema = getSlimSchema(schema, {
+    stripDefaultValues: true,
+    stripPipe: true,
+    stripRefinements: true
+  });
+  const firstParse = slimSchema.safeParse(merged);
+  if (firstParse.success) {
+    return { data: firstParse.data, success: true, slimSchema };
+  }
+  let fixedData = merged;
+  for (const issue of firstParse.error.issues) {
+    const pathSegments = issue.path.map((seg) => typeof seg === "number" ? seg : String(seg));
+    const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments);
+    if (candidates.length === 0) continue;
+    const candidate = candidates[0];
+    if (candidate === void 0) continue;
+    const valueAtPath = useFormContext.getAtPath(merged, pathSegments);
+    const slimKinds = slimPrimitivesOf(candidate);
+    if (slimKinds.size > 0 && slimKinds.has(useFormContext.slimKindOf(valueAtPath))) {
+      continue;
+    }
+    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues);
+    if (fixValue === SKIP) continue;
+    fixedData = pathSegments.length === 0 ? fixValue : useFormContext.setAtPath(fixedData, pathSegments, fixValue);
+  }
+  const secondParse = slimSchema.safeParse(fixedData);
+  if (secondParse.success) {
+    return { data: secondParse.data, success: true, slimSchema };
+  }
+  return { data: fixedData, success: false, slimSchema };
+}
+const SKIP = Symbol("atta:skip-fix");
+function defaultFromIssue(issue, candidate, useDefaultSchemaValues) {
+  if (issue.code === "invalid_type") {
+    const du = unwrapToDiscriminatedUnion(candidate);
+    if (du !== void 0) {
+      const first = getDiscriminatedUnionFirstOption(du);
+      if (first !== void 0) return deriveDefault(first, useDefaultSchemaValues);
+    }
+    return deriveDefault(candidate, useDefaultSchemaValues);
+  }
+  if (issue.code === "invalid_value") {
+    const values = issue.values;
+    if (values !== void 0 && values.length > 0) return values[0];
+    return deriveDefault(candidate, useDefaultSchemaValues);
+  }
+  return deriveDefault(candidate, useDefaultSchemaValues);
+}
+
+const PATH_SEPARATOR = ".";
+function unwrapStructuralWrappers(schema) {
+  let current = schema;
+  for (let i = 0; i < 64; i++) {
+    const outerKind = kindOf(current);
+    if (outerKind !== "optional" && outerKind !== "nullable") break;
+    const inner = unwrapInner(current);
+    if (inner === void 0) return current;
+    if (!isStructuralKind(kindOf(inner))) break;
+    current = inner;
+  }
+  return current;
+}
+function peelAllWrappers(schema) {
+  let current = schema;
+  for (let i = 0; i < 64; i++) {
+    const k = kindOf(current);
+    let inner;
+    if (k === "optional" || k === "nullable" || k === "default" || k === "readonly" || k === "catch") {
+      inner = unwrapInner(current);
+    } else if (k === "pipe") {
+      inner = unwrapPipe(current);
+    } else if (k === "lazy") {
+      inner = unwrapLazy(current);
+    } else {
+      return current;
+    }
+    if (inner === void 0) return current;
+    current = inner;
+  }
+  return current;
+}
+const STRUCTURAL_KINDS = /* @__PURE__ */ new Set([
+  "object",
+  "array",
+  "tuple",
+  "record",
+  "discriminated-union",
+  "union",
+  "intersection",
+  "optional",
+  "nullable",
+  "default",
+  "readonly",
+  "catch",
+  "pipe",
+  "lazy"
+]);
+function isStructuralKind(kind) {
+  return STRUCTURAL_KINDS.has(kind);
+}
+const MAX_REQUIRED_DEPTH = 64;
+function isLeafRequired(schema, depth = 0) {
+  if (depth > MAX_REQUIRED_DEPTH) return true;
+  const kind = kindOf(schema);
+  if (kind === "optional" || kind === "nullable" || kind === "default" || kind === "catch" || kind === "undefined" || kind === "null" || kind === "void") {
+    return false;
+  }
+  if (kind === "readonly") {
+    const inner = unwrapInner(schema);
+    return inner === void 0 ? true : isLeafRequired(inner, depth + 1);
+  }
+  if (kind === "pipe") {
+    const inner = unwrapPipe(schema);
+    return inner === void 0 ? true : isLeafRequired(inner, depth + 1);
+  }
+  if (kind === "lazy") {
+    const inner = unwrapLazy(schema);
+    return inner === void 0 ? true : isLeafRequired(inner, depth + 1);
+  }
+  if (kind === "union" || kind === "discriminated-union") {
+    const options = kind === "discriminated-union" ? getDiscriminatedOptions(schema) : getUnionOptions(schema);
+    if (options.length === 0) return true;
+    return options.every((opt) => isLeafRequired(opt, depth + 1));
+  }
+  if (kind === "intersection") {
+    const left = getIntersectionLeft(schema);
+    const right = getIntersectionRight(schema);
+    const leftReq = left === void 0 ? true : isLeafRequired(left, depth + 1);
+    const rightReq = right === void 0 ? true : isLeafRequired(right, depth + 1);
+    return leftReq || rightReq;
+  }
+  return true;
+}
+function zodV4Adapter(rootSchema) {
+  assertZodVersion(rootSchema);
+  assertSupportedKinds(rootSchema);
+  return (formKey) => {
+    const leafCache = /* @__PURE__ */ new Map();
+    let asyncValidationFlag = null;
+    return {
+      fingerprint: () => fingerprintZodSchema(rootSchema),
+      needsAsyncValidation() {
+        asyncValidationFlag ?? (asyncValidationFlag = containsAsyncRefine(rootSchema));
+        return asyncValidationFlag;
+      },
+      getDefaultValues(config) {
+        const { data } = getDefaultValuesFromZodSchema({
+          schema: rootSchema,
+          useDefaultSchemaValues: config.useDefaultSchemaValues,
+          constraints: config.constraints
+        });
+        if (config.strict !== false) {
+          try {
+            const strictResult = rootSchema.safeParse(data);
+            if (strictResult.success) {
+              return { data: strictResult.data, errors: void 0, success: true, formKey };
+            }
+            return {
+              data,
+              errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
+              success: false,
+              formKey
+            };
+          } catch {
+            try {
+              const syncOnly = stripAsyncChecks(rootSchema);
+              const syncResult = syncOnly.safeParse(data);
+              if (syncResult.success) {
+                return { data, errors: void 0, success: true, formKey };
+              }
+              return {
+                data,
+                errors: zodIssuesToValidationErrors(syncResult.error.issues, formKey),
+                success: false,
+                formKey
+              };
+            } catch {
+              return { data, errors: void 0, success: true, formKey };
+            }
+          }
+        }
+        return { data, errors: void 0, success: true, formKey };
+      },
+      getDefaultAtPath(path) {
+        if (path.length === 0) return deriveDefault(rootSchema, true);
+        const [first] = getNestedZodSchemasAtPath(rootSchema, path);
+        if (first === void 0) return void 0;
+        return deriveDefault(unwrapStructuralWrappers(first), true);
+      },
+      arrayShapeAtPath(path) {
+        if (path.length === 0) return void 0;
+        const [first] = getNestedZodSchemasAtPath(rootSchema, path);
+        if (first === void 0) return void 0;
+        const peeled = peelAllWrappers(first);
+        const kind = kindOf(peeled);
+        if (kind === "tuple") return getTupleItems(peeled).length;
+        if (kind === "array") return null;
+        return void 0;
+      },
+      getSchemasAtPath(path) {
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        return resolved.map(
+          (schema) => ({
+            fingerprint: () => fingerprintZodSchema(schema),
+            needsAsyncValidation: () => containsAsyncRefine(schema),
+            getDefaultValues: () => ({
+              data: deriveDefault(schema, true),
+              errors: void 0,
+              success: true,
+              formKey
+            }),
+            getSchemasAtPath: () => [],
+            validateAtPath: async (data) => {
+              const result = await schema.safeParseAsync(data);
+              if (result.success) {
+                return { data: result.data, errors: void 0, success: true, formKey };
+              }
+              return {
+                data: void 0,
+                errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+                success: false,
+                formKey
+              };
+            }
+          })
+        );
+      },
+      getSlimPrimitiveTypesAtPath(path) {
+        if (path.length === 0) return /* @__PURE__ */ new Set(["object"]);
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        if (resolved.length === 0) return /* @__PURE__ */ new Set();
+        const out = /* @__PURE__ */ new Set();
+        for (const candidate of resolved) {
+          for (const k of slimPrimitivesOf(candidate)) out.add(k);
+        }
+        return out;
+      },
+      isLeafAtPath(path) {
+        const cacheKey = paths.canonicalizePath(path).key;
+        const cached = leafCache.get(cacheKey);
+        if (cached !== void 0) return cached;
+        const prim = this.getSlimPrimitiveTypesAtPath(path);
+        const isLeaf = prim.size > 0 && !prim.has("object") && !prim.has("array") && !prim.has("map") && !prim.has("set");
+        leafCache.set(cacheKey, isLeaf);
+        return isLeaf;
+      },
+      isRequiredAtPath(path) {
+        if (path.length === 0) return true;
+        const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+        if (resolved.length === 0) return false;
+        return resolved.every((candidate) => isLeafRequired(candidate));
+      },
+      getFieldMetaAtPath(path) {
+        return resolveFieldMetaAtPath(rootSchema, path);
+      },
+      getUnionDiscriminatorAtPath(path) {
+        const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
+        let matchedUnion;
+        for (const candidate of candidates) {
+          const du = unwrapToDiscriminatedUnion(candidate);
+          if (du === void 0) continue;
+          if (matchedUnion !== void 0 && matchedUnion !== du) return void 0;
+          matchedUnion = du;
+        }
+        if (matchedUnion === void 0) return void 0;
+        const discKey = getDiscriminator(matchedUnion);
+        if (discKey === void 0) return void 0;
+        const options = getDiscriminatedOptions(matchedUnion);
+        return {
+          discriminatorKey: discKey,
+          getVariantDefault(value) {
+            for (const opt of options) {
+              const shape = getObjectShape(opt);
+              const litSchema = shape[discKey];
+              if (litSchema === void 0) continue;
+              if (kindOf(litSchema) !== "literal") continue;
+              const literalValues = getLiteralValues(litSchema);
+              if (literalValues.includes(value)) return deriveDefault(opt, true);
+            }
+            return void 0;
+          }
+        };
+      },
+      validateAtPath(data, path, options) {
+        const trySync = options?.sync === true;
+        if (trySync) {
+          try {
+            return runSync();
+          } catch {
+          }
+        }
+        return runAsync();
+        function runSync() {
+          if (path === void 0) {
+            const result = rootSchema.safeParse(data);
+            return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
+              data: void 0,
+              errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+              success: false,
+              formKey
+            };
+          }
+          const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+          if (resolved.length === 0) return pathNotFound(path);
+          const aggregated = [];
+          for (const candidate of resolved) {
+            const result = candidate.safeParse(data);
+            if (result.success) {
+              return { data: result.data, errors: void 0, success: true, formKey };
+            }
+            aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
+          }
+          return { data: void 0, errors: aggregated, success: false, formKey };
+        }
+        async function runAsync() {
+          if (path === void 0) {
+            const result = await rootSchema.safeParseAsync(data);
+            return result.success ? { data: result.data, errors: void 0, success: true, formKey } : {
+              data: void 0,
+              errors: zodIssuesToValidationErrors(result.error.issues, formKey),
+              success: false,
+              formKey
+            };
+          }
+          const resolved = getNestedZodSchemasAtPath(rootSchema, path);
+          if (resolved.length === 0) return pathNotFound(path);
+          const aggregated = [];
+          for (const candidate of resolved) {
+            const result = await candidate.safeParseAsync(data);
+            if (result.success) {
+              return { data: result.data, errors: void 0, success: true, formKey };
+            }
+            aggregated.push(...zodIssuesToValidationErrors(result.error.issues, formKey));
+          }
+          return { data: void 0, errors: aggregated, success: false, formKey };
+        }
+        function pathNotFound(p) {
+          return {
+            data: void 0,
+            errors: [
+              {
+                message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,
+                path: [...p],
+                formKey,
+                code: useFormContext.AttaformErrorCode.PathNotFound
+              }
+            ],
+            success: false,
+            formKey
+          };
+        }
+      }
+    };
+  };
+}
+const pathMetaCache = /* @__PURE__ */ new WeakMap();
+function getPathMetaMap(rootSchema) {
+  const cached = pathMetaCache.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();
+  walkForMeta(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 });
+  }
+  pathMetaCache.set(rootSchema, map);
+  return map;
+}
+function walkForMeta(schema, path, map, counters, lastPathPerSchema, inProgress) {
+  if (inProgress.has(schema)) return;
+  inProgress.add(schema);
+  try {
+    const pathKey = paths.canonicalizePath(path).key;
+    if (!map.has(pathKey)) {
+      const payload = consumePayload(schema, counters);
+      if (payload !== void 0) {
+        map.set(pathKey, payload);
+        lastPathPerSchema.set(schema, pathKey);
+      }
+    }
+    const peeled = peelAllWrappers(schema);
+    if (peeled !== schema && !map.has(pathKey)) {
+      const payload = consumePayload(peeled, counters);
+      if (payload !== void 0) {
+        map.set(pathKey, payload);
+        lastPathPerSchema.set(peeled, pathKey);
+      }
+    }
+    const kind = kindOf(schema);
+    switch (kind) {
+      case "object": {
+        const shape = getObjectShape(schema);
+        for (const [key, child] of Object.entries(shape)) {
+          walkForMeta(child, [...path, key], map, counters, lastPathPerSchema, inProgress);
+        }
+        return;
+      }
+      case "array": {
+        walkForMeta(
+          getArrayElement(schema),
+          [...path, 0],
+          map,
+          counters,
+          lastPathPerSchema,
+          inProgress
+        );
+        return;
+      }
+      case "tuple": {
+        const items = getTupleItems(schema);
+        for (let i = 0; i < items.length; i++) {
+          const item = items[i];
+          if (item !== void 0)
+            walkForMeta(item, [...path, i], map, counters, lastPathPerSchema, inProgress);
+        }
+        return;
+      }
+      case "set":
+        walkForMeta(
+          getSetValueType(schema),
+          [...path, 0],
+          map,
+          counters,
+          lastPathPerSchema,
+          inProgress
+        );
+        return;
+      case "record":
+        walkForMeta(
+          getRecordValueType(schema),
+          [...path, "*"],
+          map,
+          counters,
+          lastPathPerSchema,
+          inProgress
+        );
+        return;
+      case "union": {
+        for (const opt of getUnionOptions(schema)) {
+          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress);
+        }
+        return;
+      }
+      case "discriminated-union": {
+        for (const opt of getDiscriminatedOptions(schema)) {
+          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress);
+        }
+        return;
+      }
+      case "optional":
+      case "nullable":
+      case "default":
+      case "readonly":
+      case "catch": {
+        const inner = unwrapInner(schema);
+        if (inner !== void 0)
+          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
+        return;
+      }
+      case "pipe": {
+        const inner = unwrapPipe(schema);
+        if (inner !== void 0)
+          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
+        return;
+      }
+      case "lazy": {
+        const inner = unwrapLazy(schema);
+        if (inner !== void 0)
+          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress);
+        return;
+      }
+      case "intersection": {
+        const left = getIntersectionLeft(schema);
+        const right = getIntersectionRight(schema);
+        if (left !== void 0)
+          walkForMeta(left, path, map, counters, lastPathPerSchema, inProgress);
+        if (right !== void 0)
+          walkForMeta(right, path, map, counters, lastPathPerSchema, inProgress);
+        return;
+      }
+      // Leaf kinds — no children to descend into; metadata for the
+      // path itself was captured above. Listed explicitly so the
+      // exhaustiveness check catches any new kind landing in Zod
+      // without a corresponding decision here.
+      case "string":
+      case "number":
+      case "bigint":
+      case "boolean":
+      case "date":
+      case "enum":
+      case "literal":
+      case "null":
+      case "undefined":
+      case "any":
+      case "unknown":
+      case "nan":
+      case "void":
+      case "never":
+      case "promise":
+      case "custom":
+      case "template-literal":
+        return;
+    }
+  } finally {
+    inProgress.delete(schema);
+  }
+}
+function consumePayload(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 resolveFieldMetaAtPath(rootSchema, path) {
+  const lastSegment = path.length === 0 ? "" : path[path.length - 1];
+  const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path);
+  const target = candidates[0];
+  if (target === void 0) {
+    return {
+      label: useFormContext.humanize(lastSegment),
+      description: void 0,
+      placeholder: void 0,
+      meta: Object.freeze({})
+    };
+  }
+  const pathMap = getPathMetaMap(rootSchema);
+  const pathKey = paths.canonicalizePath(path).key;
+  const peeled = peelAllWrappers(target);
+  const payload = pathMap.get(pathKey) ?? getFieldMeta(target) ?? (peeled !== target ? getFieldMeta(peeled) : void 0);
+  const targetDescription = readDescription(target);
+  const peeledDescription = peeled !== target ? readDescription(peeled) : void 0;
+  const schemaDescription = targetDescription ?? peeledDescription;
+  return {
+    label: payload?.label ?? useFormContext.humanize(lastSegment),
+    description: payload?.description ?? schemaDescription ?? void 0,
+    placeholder: payload?.placeholder ?? void 0,
+    meta: Object.freeze({ ...payload ?? {} })
+  };
+}
+function readDescription(schema) {
+  const candidate = schema.description;
+  return typeof candidate === "string" ? candidate : void 0;
+}
+
+function useForm(configuration) {
+  const candidate = configuration;
+  if (candidate === void 0 || candidate === null || candidate.schema === void 0) {
+    throw new plugin.InvalidUseFormConfigError();
+  }
+  const adapter = zodV4Adapter(
+    configuration.schema
+  );
+  return useFormContext.useAbstractForm({
+    ...configuration,
+    schema: adapter
+  });
+}
+
+exports.UnsupportedSchemaError = UnsupportedSchemaError;
+exports.assertZodVersion = assertZodVersion;
+exports.fieldMeta = fieldMeta;
+exports.kindOf = kindOf;
+exports.useForm = useForm;
+exports.withMeta = withMeta;
+exports.zodV4Adapter = zodV4Adapter;
+//# sourceMappingURL=attaform.DfrYByDj.cjs.map