attaform 0.27.6 → 0.29.0

package/dist/shared/attaform.DMxM2kol.mjs

@@ -1,1275 +0,0 @@
-import { r as getAtPath, p as slimKindOf, t as setAtPath, q as humanize, h as useAbstractForm } from './attaform.CKH2lGdL.mjs';
-import { A as AttaformError, _ as __DEV__, f as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.nMaz2C5P.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema, b as getFieldMetaPathMap } from './attaform.CoR4mWfv.mjs';
-import { z } from 'zod';
-
-const fieldMeta = fieldMetaStore;
-function getFieldMetaList(schema) {
-  return getFieldMetaListForSchema(schema);
-}
-function withMeta(schema, payload) {
-  const existing = getFieldMetaForSchema(schema) ?? {};
-  const cloned = schema.clone();
-  fieldMetaStore.add(cloned, { ...existing, ...payload });
-  return cloned;
-}
-function getFieldMeta(schema) {
-  return getFieldMetaForSchema(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 (__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,
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
-      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
-      formKey,
-      code
-    };
-  });
-}
-class UnsupportedSchemaError extends 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 "transform":
-      return "transform";
-    case "promise":
-      return "promise";
-    case "custom":
-      return "custom";
-    case "template_literal":
-    case "templateLiteral":
-      return "template-literal";
-    case "file":
-      return "file";
-    case "map":
-      return "map";
-    case "symbol":
-      return "symbol";
-    case "function":
-      return "function";
-    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 unwrapPipeIn(schema) {
-  const def = readDef(schema);
-  return def?.in;
-}
-function isCoercePrimitive(schema) {
-  return readDef(schema)?.coerce === true;
-}
-function isPreprocessNode(schema) {
-  if (kindOf(schema) !== "pipe") return false;
-  const pipeIn = unwrapPipeIn(schema);
-  return pipeIn !== void 0 && kindOf(pipeIn) === "transform";
-}
-function unwrapPipeOut(schema) {
-  const def = readDef(schema);
-  return def?.out;
-}
-function unwrapLazy(schema) {
-  const def = readDef(schema);
-  const getter = def?.getter;
-  if (typeof getter !== "function") return void 0;
-  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 hasCatchValue(schema) {
-  const def = readDef(schema);
-  return typeof def?.catchValue === "function";
-}
-function getDefaultValue(schema) {
-  const def = readDef(schema);
-  return def?.defaultValue;
-}
-function getNativeEnumValues(_schema) {
-  return void 0;
-}
-function unwrapEffectsSource(_schema) {
-  return void 0;
-}
-function unwrapBranded(_schema) {
-  return void 0;
-}
-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 walkSchemaTree(schema, visit, seen) {
-  const visited = seen ?? /* @__PURE__ */ new WeakSet();
-  const candidate = schema;
-  if (typeof candidate !== "object" || candidate === null) return false;
-  if (visited.has(candidate)) return false;
-  visited.add(candidate);
-  if (visit(schema)) return true;
-  const def = readDef(schema);
-  if (def === void 0) return false;
-  if (def.innerType !== void 0 && walkSchemaTree(def.innerType, visit, visited)) {
-    return true;
-  }
-  if (def.element !== void 0 && walkSchemaTree(def.element, visit, visited)) {
-    return true;
-  }
-  if (def.in !== void 0 && walkSchemaTree(def.in, visit, visited)) return true;
-  if (def.out !== void 0 && walkSchemaTree(def.out, visit, visited)) return true;
-  if (def.left !== void 0 && walkSchemaTree(def.left, visit, visited)) return true;
-  if (def.right !== void 0 && walkSchemaTree(def.right, visit, visited)) return true;
-  if (def.keyType !== void 0 && walkSchemaTree(def.keyType, visit, visited)) {
-    return true;
-  }
-  if (def.valueType !== void 0 && walkSchemaTree(def.valueType, visit, visited)) {
-    return true;
-  }
-  if (def.shape !== void 0) {
-    for (const sub of Object.values(def.shape)) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (def.entries !== void 0) {
-    for (const sub of Object.values(def.entries)) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (def.options !== void 0) {
-    for (const sub of def.options) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (def.items !== void 0) {
-    for (const sub of def.items) {
-      if (walkSchemaTree(sub, visit, visited)) return true;
-    }
-  }
-  if (typeof def.getter === "function") {
-    try {
-      const inner = def.getter();
-      if (walkSchemaTree(inner, visit, visited)) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function containsAsyncRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      for (const check of getChecks(node)) {
-        if (isAsyncCheck(check)) return true;
-      }
-      return false;
-    },
-    seen
-  );
-}
-function hasContainerOrRootRefine(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const isContainer = def.shape !== void 0 || def.entries !== void 0 || def.element !== void 0 || def.options !== void 0 || def.items !== void 0 || def.keyType !== void 0 || def.valueType !== void 0 || def.left !== void 0 || def.right !== void 0;
-      if (!isContainer) return false;
-      return getChecks(node).length > 0;
-    },
-    seen
-  );
-}
-function containsAsyncTransform(schema, seen) {
-  return walkSchemaTree(
-    schema,
-    (node) => {
-      const def = readDef(node);
-      if (def === void 0) return false;
-      const fn = def.transform;
-      if (typeof fn !== "function") return false;
-      return fn.constructor.name === "AsyncFunction";
-    },
-    seen
-  );
-}
-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",
-  "map",
-  "symbol",
-  "function"
-];
-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)) return;
-      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":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      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" || kind === "catch") {
-      next = unwrapInner(current);
-    } else if (kind === "pipe") {
-      next = unwrapPipe(current);
-    } else if (kind === "intersection") {
-      const left = getIntersectionLeft(current);
-      const right = getIntersectionRight(current);
-      const leftDU = left !== void 0 ? unwrapToDiscriminatedUnion(left) : void 0;
-      const rightDU = right !== void 0 ? unwrapToDiscriminatedUnion(right) : void 0;
-      if (leftDU !== void 0 && rightDU !== void 0) {
-        return void 0;
-      }
-      return leftDU ?? rightDU;
-    }
-    if (next === void 0) return void 0;
-    current = next;
-  }
-  return void 0;
-}
-function getDiscriminatedUnionFirstOption(schema) {
-  const options = getDiscriminatedOptions(schema);
-  return options[0];
-}
-
-const V4_INTROSPECTOR = {
-  kindOf: (schema) => kindOf(schema),
-  getObjectShape: (schema) => getObjectShape(schema),
-  getTupleItems,
-  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
-  getDiscriminator,
-  getLiteralValues,
-  isPreprocessNode,
-  isCoercePrimitive,
-  containsAsyncRefine,
-  containsAsyncTransform,
-  hasContainerOrRootRefine,
-  // Walker accessors (D2 / D3 / D5).
-  getArrayElement: (schema) => {
-    if (kindOf(schema) !== "array") return void 0;
-    return getArrayElement(schema);
-  },
-  getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
-  getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
-  getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
-  getUnionOptions,
-  getIntersectionLeft,
-  getIntersectionRight,
-  getEnumValues,
-  getNativeEnumValues,
-  unwrapInner,
-  unwrapBranded,
-  unwrapEffectsSource,
-  unwrapPipeIn,
-  unwrapPipeOut,
-  unwrapLazy,
-  getLazyGetter,
-  getDefaultValue,
-  getCatchDefault,
-  hasCatchValue
-};
-
-function slimPrimitivesOf(schema, maxRecursionDepth) {
-  return new Set(slimPrimitivesWalk(schema, V4_INTROSPECTOR, maxRecursionDepth));
-}
-
-const PATH_SEPARATOR = ".";
-function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
-  if (Array.isArray(path)) {
-    return walkPathSegments(schema, path.map(String), V4_INTROSPECTOR, maxRecursionDepth, 0);
-  }
-  const pathString = path;
-  if (pathString.length === 0) return [schema];
-  return walkPathSegments(
-    schema,
-    pathString.split(PATH_SEPARATOR),
-    V4_INTROSPECTOR,
-    maxRecursionDepth,
-    0
-  );
-}
-
-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 unhandledZodKind(fnName, kind) {
-  throw new Error(`${fnName}: unhandled ZodKind '${kind}'`);
-}
-function stripRefinements(schema) {
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "string":
-      return hasChecks(schema) ? z.string() : schema;
-    case "number":
-      return hasChecks(schema) ? z.number() : schema;
-    case "bigint":
-      return hasChecks(schema) ? z.bigint() : schema;
-    case "array": {
-      const element = getArrayElement(schema);
-      return z.array(stripRefinements(element));
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return z.set(stripRefinements(valueType));
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(stripRefinements);
-      return z.tuple(items);
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      const next = {};
-      for (const [k, v] of Object.entries(shape)) {
-        next[k] = stripRefinements(v);
-      }
-      return z.object(next);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(
-        schema
-      );
-      const valueType = stripRefinements(getRecordValueType(schema));
-      return z.record(keyType, valueType);
-    }
-    case "union": {
-      const options = getUnionOptions(schema).map(stripRefinements);
-      return 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 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 z.lazy(() => slimmedInner);
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left === void 0 || right === void 0) return schema;
-      return 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":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return schema;
-    default:
-      return unhandledZodKind("stripRefinements", kind);
-  }
-}
-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(z.string(), s, config) : s;
-      case "number":
-        return hasChecks(s) ? carryChecks(z.number(), s, config) : s;
-      case "bigint":
-        return hasChecks(s) ? carryChecks(z.bigint(), s, config) : s;
-      case "array": {
-        const element = getArrayElement(s);
-        return carryChecks(z.array(recurse(element)), s, config);
-      }
-      case "set": {
-        const valueType = getSetValueType(s);
-        return carryChecks(z.set(recurse(valueType)), s, config);
-      }
-      case "tuple": {
-        const items = getTupleItems(s).map(recurse);
-        const rebuilt = 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(z.object(next), s, config);
-      }
-      case "record": {
-        const keyType = getRecordKeyType(s);
-        const valueType = recurse(getRecordValueType(s));
-        const rebuilt = z.record(keyType, valueType);
-        return carryChecks(rebuilt, s, config);
-      }
-      case "union": {
-        const options = getUnionOptions(s).map(recurse);
-        const rebuilt = 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 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 z.lazy(() => stripped);
-      }
-      case "intersection": {
-        const left = getIntersectionLeft(s);
-        const right = getIntersectionRight(s);
-        if (left === void 0 || right === void 0) return s;
-        return 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":
-      case "transform":
-      case "file":
-      case "map":
-      case "symbol":
-      case "function":
-        return s;
-      default:
-        return unhandledZodKind("stripAsyncChecks", kind);
-    }
-  }
-  return recurse(schema);
-}
-function getSlimSchema(schema, stripConfig, maxRecursionDepth) {
-  return walkSlim(schema, stripConfig, maxRecursionDepth, 0);
-}
-function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
-  const kind = kindOf(schema);
-  switch (kind) {
-    case "optional": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return stripConfig.stripOptional === true ? slimmedInner : slimmedInner.optional();
-    }
-    case "nullable": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return stripConfig.stripNullable === true ? slimmedInner : slimmedInner.nullable();
-    }
-    case "default": {
-      const inner = unwrapInner(schema) ?? schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      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 : walkSlim(inner, stripConfig, maxDepth, lazyDepth).readonly();
-    }
-    case "pipe": {
-      if (stripConfig.stripPipe === true) {
-        const pipeIn = unwrapPipeIn(schema);
-        const pipeOut = unwrapPipeOut(schema);
-        const real = pipeIn !== void 0 && kindOf(pipeIn) !== "transform" ? pipeIn : pipeOut !== void 0 && kindOf(pipeOut) !== "transform" ? pipeOut : pipeIn ?? pipeOut ?? schema;
-        return walkSlim(real, stripConfig, maxDepth, lazyDepth);
-      }
-      return schema;
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      const next = {};
-      for (const [k, v] of Object.entries(shape)) {
-        next[k] = walkSlim(v, stripConfig, maxDepth, lazyDepth);
-      }
-      return carryChecks(z.object(next), schema, stripConfig);
-    }
-    case "array": {
-      const element = getArrayElement(schema);
-      return carryChecks(
-        z.array(walkSlim(element, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "set": {
-      const valueType = getSetValueType(schema);
-      return carryChecks(
-        z.set(walkSlim(valueType, stripConfig, maxDepth, lazyDepth)),
-        schema,
-        stripConfig
-      );
-    }
-    case "tuple": {
-      const items = getTupleItems(schema).map(
-        (it) => walkSlim(it, stripConfig, maxDepth, lazyDepth)
-      );
-      const rebuilt = z.tuple(
-        items
-      );
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "record": {
-      const keyType = getRecordKeyType(schema);
-      const valueType = walkSlim(getRecordValueType(schema), stripConfig, maxDepth, lazyDepth);
-      const rebuilt = z.record(keyType, valueType);
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "union": {
-      const options = getUnionOptions(schema).map(
-        (opt) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
-      );
-      const rebuilt = z.union(options);
-      return carryChecks(rebuilt, schema, stripConfig);
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema).map(
-        (opt) => walkSlim(opt, stripConfig, maxDepth, lazyDepth)
-      );
-      const discriminator = getDiscriminator(schema);
-      if (discriminator === void 0) return schema;
-      return 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":
-    case "map":
-    case "symbol":
-    case "function":
-      return schema;
-    case "lazy": {
-      if (lazyDepth >= maxDepth) return schema;
-      const inner = unwrapLazy(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth + 1);
-      return z.lazy(() => slimmedInner);
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left === void 0 || right === void 0) return schema;
-      return z.intersection(
-        walkSlim(left, stripConfig, maxDepth, lazyDepth),
-        walkSlim(right, stripConfig, maxDepth, lazyDepth)
-      );
-    }
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner === void 0) return schema;
-      const slimmedInner = walkSlim(inner, stripConfig, maxDepth, lazyDepth);
-      return slimmedInner.catch(getCatchDefault(schema));
-    }
-    case "transform":
-    case "file":
-      return schema;
-    default:
-      return unhandledZodKind("getSlimSchema", kind);
-  }
-}
-
-function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
-    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
-    // unknown kinds genuinely shouldn't appear, so return undefined.
-    unsupportedKindFallback: () => void 0,
-    // v4 historically recurses into the inner on `useDefault=false`
-    // so a `.catch(v)` slot returns the leaf empty rather than the
-    // fallback. Pinned by `test/adapters/zod-v4/unsupported-kinds.test.ts`
-    // (`z.catch falls through to inner leaf default when useDefault=false`).
-    catchOnUseDefaultFalse: "recurseInner"
-  });
-}
-function getDefaultValuesFromZodSchema(opts) {
-  const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
-  const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
-  const merged = mergeDeep(initial, constraints);
-  const slimSchema = getSlimSchema(
-    schema,
-    {
-      stripDefaultValues: true,
-      stripPipe: true,
-      stripRefinements: true
-    },
-    maxRecursionDepth
-  );
-  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 originalCandidate = getNestedZodSchemasAtPath(schema, pathSegments, maxRecursionDepth)[0];
-    if (originalCandidate !== void 0) {
-      if (isCoercePrimitive(originalCandidate)) continue;
-      if (kindOf(originalCandidate) === "pipe") {
-        const pipeIn = unwrapPipeIn(originalCandidate);
-        if (pipeIn !== void 0 && kindOf(pipeIn) === "transform") continue;
-      }
-    }
-    const candidates = getNestedZodSchemasAtPath(slimSchema, pathSegments, maxRecursionDepth);
-    if (candidates.length === 0) continue;
-    const candidate = candidates[0];
-    if (candidate === void 0) continue;
-    const valueAtPath = getAtPath(merged, pathSegments);
-    const slimKinds = slimPrimitivesOf(candidate, maxRecursionDepth);
-    if (slimKinds.size > 0 && slimKinds.has(slimKindOf(valueAtPath))) {
-      continue;
-    }
-    const fixValue = defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth);
-    if (fixValue === SKIP) continue;
-    fixedData = pathSegments.length === 0 ? fixValue : 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 = /* @__PURE__ */ Symbol("atta:skip-fix");
-function defaultFromIssue(issue, candidate, useDefaultSchemaValues, maxRecursionDepth) {
-  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, maxRecursionDepth);
-    }
-    return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-  }
-  if (issue.code === "invalid_value") {
-    const values = issue.values;
-    if (values !== void 0 && values.length > 0) return values[0];
-    return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-  }
-  return deriveDefault(candidate, useDefaultSchemaValues, maxRecursionDepth);
-}
-
-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, options) => createAbstractSchema(
-    rootSchema,
-    V4_INTROSPECTOR,
-    buildV4Services(),
-    formKey,
-    options
-  );
-}
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.mjs');
-  return fingerprintZodSchema(schema);
-}
-function buildV4Services() {
-  return {
-    fingerprint: (schema) => lazyFingerprint(schema),
-    getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
-    // v4 doesn't pre-strip for the slim-mode walk — its path walker
-    // already peels every transparent wrapper inline, so the slim and
-    // unstripped walks coincide.
-    getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
-    slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
-    deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
-    runStrictGetDefaults: (schema, config, fk, maxRecursionDepth) => runStrictGetDefaultsV4(schema, config, fk, maxRecursionDepth),
-    unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
-    unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
-    peelAllWrappers: (schema) => peelAllWrappers(schema),
-    isLeafRequired: (schema) => isLeafRequired(schema),
-    resolveFieldMetaAtPath: (schema, path, maxRecursionDepth) => resolveFieldMetaAtPath(schema, path, maxRecursionDepth),
-    issuesToValidationErrors: (issues, fk) => zodIssuesToValidationErrors(issues, fk),
-    safeParseSync: (schema, data) => {
-      const result = schema.safeParse(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
-    },
-    safeParseAsync: async (schema, data) => {
-      const result = await schema.safeParseAsync(data);
-      return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
-    },
-    makeSubSchema: (schema, fk, maxRecursionDepth) => buildSubSchemaStubV4(schema, fk, maxRecursionDepth)
-  };
-}
-function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth) {
-  const { data } = getDefaultValuesFromZodSchema({
-    schema: rootSchema,
-    useDefaultSchemaValues: config.useDefaultSchemaValues,
-    constraints: config.constraints,
-    maxRecursionDepth
-  });
-  if (config.strict === false) {
-    return { data, errors: void 0, success: true, formKey };
-  }
-  if (containsAsyncTransform(rootSchema)) {
-    return { data, errors: void 0, success: true, formKey };
-  }
-  const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
-  try {
-    const strictResult = parseTarget.safeParse(data);
-    if (strictResult.success) {
-      return { data, errors: void 0, success: true, formKey };
-    }
-    return {
-      data,
-      errors: zodIssuesToValidationErrors(strictResult.error.issues, formKey),
-      success: false,
-      formKey
-    };
-  } catch {
-    return { data, errors: void 0, success: true, formKey };
-  }
-}
-function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
-  return {
-    fingerprint: () => lazyFingerprint(schema),
-    needsAsyncValidation: () => containsAsyncRefine(schema),
-    getDefaultValues: () => ({
-      data: deriveDefault(schema, true, maxRecursionDepth),
-      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
-      };
-    }
-  };
-}
-function resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth) {
-  const lastSegment = path.length === 0 ? "" : path[path.length - 1];
-  const candidates = path.length === 0 ? [rootSchema] : getNestedZodSchemasAtPath(rootSchema, path, maxRecursionDepth);
-  const target = candidates[0];
-  if (target === void 0) {
-    return {
-      label: humanize(lastSegment),
-      description: void 0,
-      placeholder: void 0,
-      meta: Object.freeze({})
-    };
-  }
-  const pathMap = getFieldMetaPathMap(rootSchema, {
-    intro: V4_INTROSPECTOR,
-    peelAllWrappers,
-    getFieldMetaList
-  });
-  const pathKey = 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 ?? 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 InvalidUseFormConfigError();
-  }
-  const adapter = zodV4Adapter(configuration.schema);
-  return useAbstractForm({
-    ...configuration,
-    schema: adapter
-  });
-}
-
-export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, fieldMeta as f, getIntersectionLeft as g, getDiscriminator as h, getDiscriminatedOptions as i, getUnionOptions as j, kindOf as k, getRecordKeyType as l, getRecordValueType as m, getTupleItems as n, getSetValueType as o, getArrayElement as p, getObjectShape as q, getEnumValues as r, getLiteralValues as s, getChecks as t, useForm as u, getCatchDefault as v, withMeta as w, getDefaultValue as x, zodV4Adapter as z };
-//# sourceMappingURL=attaform.DMxM2kol.mjs.map