attaform 0.15.1 → 0.16.1

package/dist/zod.cjs

@@ -1,1915 +1,34 @@
 'use strict';
 
-const useFormContext = require('./shared/attaform.CDJVeoJU.cjs');
-const zod = require('zod');
-const paths = require('./shared/attaform.BOi138GE.cjs');
-const sensitiveNames = require('./shared/attaform.RypIkgVy.cjs');
+const plugin = require('./shared/attaform.rIRYSUI1.cjs');
+const useForm$1 = require('./shared/attaform.Bp1c-uGF.cjs');
+const index = require('./shared/attaform.DfrYByDj.cjs');
+const useFormContext = require('./shared/attaform.C9Ph2SMx.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 (sensitiveNames.__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 sensitiveNames.AttaformError {
+function isZodV4SchemaShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const def = value.def;
+  if (typeof def !== "object" || def === null) return false;
+  return typeof def.type === "string";
 }
 
-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] schema is not zod v4. Install zod@^4 or use /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 useForm(configuration) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new plugin.InvalidUseFormConfigError();
   }
-}
-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 { schema } = configuration;
+  if (isZodV4SchemaShape(schema)) {
+    return index.useForm(configuration);
   }
-  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 adapter = zodV4Adapter(
-    configuration.schema
-  );
-  return useFormContext.useAbstractForm({
-    ...configuration,
-    schema: adapter
-  });
+  return useForm$1.useForm(configuration);
 }
 
+exports.useRegister = plugin.useRegister;
+exports.fieldMeta = index.fieldMeta;
+exports.withMeta = index.withMeta;
 exports.AttaformErrorCode = useFormContext.AttaformErrorCode;
 exports.injectForm = useFormContext.injectForm;
 exports.isUnset = useFormContext.isUnset;
 exports.unset = useFormContext.unset;
-exports.useRegister = sensitiveNames.useRegister;
-exports.UnsupportedSchemaError = UnsupportedSchemaError;
-exports.assertZodVersion = assertZodVersion;
-exports.fieldMeta = fieldMeta;
-exports.kindOf = kindOf;
 exports.useForm = useForm;
-exports.withMeta = withMeta;
-exports.zodAdapter = zodV4Adapter;
 //# sourceMappingURL=zod.cjs.map