attaform 0.27.6 → 0.29.0

package/dist/shared/attaform.C2MVyuxC.mjs

@@ -0,0 +1,811 @@
+import { q as humanize, h as useAbstractForm } from './attaform.CZMAYwSK.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform.B0dKL8ST.mjs';
+import { c as callConsumerSchemaFn } from './attaform.Cvao8bW5.mjs';
+import { z } from 'zod';
+
+function readDef(schema) {
+  if (schema === null || typeof schema !== "object") return void 0;
+  return schema.def;
+}
+const KIND_ALIAS = /* @__PURE__ */ new Map([
+  ["discriminated_union", "discriminated-union"],
+  ["discriminatedUnion", "discriminated-union"],
+  ["prefault", "default"],
+  ["template_literal", "template-literal"],
+  ["templateLiteral", "template-literal"]
+]);
+const IDENTITY_KINDS = /* @__PURE__ */ new Set([
+  "object",
+  "array",
+  "set",
+  "record",
+  "tuple",
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "date",
+  "enum",
+  "literal",
+  "null",
+  "undefined",
+  "any",
+  "unknown",
+  "optional",
+  "nullable",
+  "default",
+  "pipe",
+  "readonly",
+  "nan",
+  "void",
+  "never",
+  "lazy",
+  "intersection",
+  "catch",
+  "promise",
+  "custom",
+  "transform",
+  "file",
+  "map",
+  "symbol",
+  "function"
+]);
+function kindOf(schema) {
+  const def = readDef(schema);
+  const rawType = def?.type;
+  if (rawType === void 0) return "unknown";
+  if (rawType === "union") {
+    return def?.discriminator !== void 0 ? "discriminated-union" : "union";
+  }
+  const alias = KIND_ALIAS.get(rawType);
+  if (alias !== void 0) return alias;
+  return IDENTITY_KINDS.has(rawType) ? rawType : "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;
+}
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
+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 callConsumerSchemaFn(() => getter(), void 0);
+}
+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;
+  return callConsumerSchemaFn(
+    () => cv({ error: new Error("atta:default-values"), input: void 0 }),
+    void 0);
+}
+function hasCatchValue(schema) {
+  const def = readDef(schema);
+  return typeof def?.catchValue === "function";
+}
+function getDefaultValue(schema) {
+  const def = readDef(schema);
+  return callConsumerSchemaFn(() => def?.defaultValue, void 0);
+}
+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] AF01 attaform.dev/e/af01"
+    );
+  }
+}
+const DESCEND_SINGLE = [
+  "innerType",
+  "element",
+  "in",
+  "out",
+  "left",
+  "right",
+  "keyType",
+  "valueType"
+];
+const DESCEND_RECORD = ["shape", "entries"];
+const DESCEND_LIST = ["options", "items"];
+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;
+  const slots = def;
+  for (const key of DESCEND_SINGLE) {
+    const child = slots[key];
+    if (child !== void 0 && walkSchemaTree(child, visit, visited)) return true;
+  }
+  for (const key of DESCEND_RECORD) {
+    const record = slots[key];
+    if (record !== void 0) {
+      for (const sub of Object.values(record)) {
+        if (walkSchemaTree(sub, visit, visited)) return true;
+      }
+    }
+  }
+  for (const key of DESCEND_LIST) {
+    const list = slots[key];
+    if (list !== void 0) {
+      for (const sub of list) {
+        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 containsDiscriminatedUnion(schema, seen) {
+  return walkSchemaTree(schema, (node) => kindOf(node) === "discriminated-union", seen);
+}
+function containsAsyncRefine(schema, seen) {
+  return walkSchemaTree(
+    schema,
+    (node) => {
+      for (const check of getChecks(node)) {
+        if (isAsyncCheck(check)) return true;
+      }
+      return false;
+    },
+    seen
+  );
+}
+const CONTAINER_SLOTS = [
+  "shape",
+  "entries",
+  "element",
+  "options",
+  "items",
+  "keyType",
+  "valueType",
+  "left",
+  "right"
+];
+function hasContainerOrRootRefine(schema, seen) {
+  return walkSchemaTree(
+    schema,
+    (node) => {
+      const def = readDef(node);
+      if (def === void 0) return false;
+      const slots = def;
+      if (!CONTAINER_SLOTS.some((key) => slots[key] !== void 0)) 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";
+}
+
+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 zodIssuesToValidationErrors(issues) {
+  return issues.map((issue) => {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+    }
+    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)),
+      code
+    };
+  });
+}
+
+const V4_INTROSPECTOR = {
+  kindOf: (schema) => kindOf(schema),
+  getObjectShape: (schema) => getObjectShape(schema),
+  getTupleItems,
+  getDiscriminatedOptions: (schema) => getDiscriminatedOptions(schema),
+  getDiscriminator,
+  getLiteralValues,
+  isPreprocessNode,
+  isCoercePrimitive,
+  containsAsyncRefine,
+  containsAsyncTransform,
+  containsDiscriminatedUnion,
+  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,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(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));
+}
+
+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
+  });
+}
+function getDefaultValuesFromZodSchema(opts) {
+  const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
+  const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
+  const merged = mergeDeep(initial, constraints);
+  return fixStructuralDefaults(
+    schema,
+    merged,
+    useDefaultSchemaValues,
+    maxRecursionDepth,
+    {
+      intro: V4_INTROSPECTOR,
+      slimPrimitivesOf: (s) => slimPrimitivesOf(s, maxRecursionDepth),
+      deriveDefault: (s, useDefault) => deriveDefault(s, useDefault, maxRecursionDepth),
+      unwrapToDiscriminatedUnion
+    }
+  );
+}
+
+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 carrySyncChecks(rebuilt, original) {
+  if (!hasChecks(original)) return rebuilt;
+  const checks = getChecks(original).filter((c) => !isAsyncCheck(c));
+  if (checks.length === 0) return rebuilt;
+  return rebuilt.check(
+    ...checks
+  );
+}
+function stripAsyncChecks(schema) {
+  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) ? carrySyncChecks(z.string(), s) : s;
+      case "number":
+        return hasChecks(s) ? carrySyncChecks(z.number(), s) : s;
+      case "bigint":
+        return hasChecks(s) ? carrySyncChecks(z.bigint(), s) : s;
+      case "array": {
+        const element = getArrayElement(s);
+        return carrySyncChecks(z.array(recurse(element)), s);
+      }
+      case "set": {
+        return carrySyncChecks(z.set(recurse(getSetValueType(s))), s);
+      }
+      case "tuple": {
+        const items = getTupleItems(s).map(recurse);
+        const rebuilt = z.tuple(
+          items
+        );
+        return carrySyncChecks(rebuilt, s);
+      }
+      case "object": {
+        const shape = getObjectShape(s);
+        const next = {};
+        for (const [k, v] of Object.entries(shape)) {
+          next[k] = recurse(v);
+        }
+        return carrySyncChecks(z.object(next), s);
+      }
+      case "record": {
+        const keyType = getRecordKeyType(s);
+        const valueType = recurse(getRecordValueType(s));
+        return carrySyncChecks(
+          z.record(keyType, valueType),
+          s
+        );
+      }
+      case "union": {
+        const options = getUnionOptions(s).map(recurse);
+        return carrySyncChecks(
+          z.union(options),
+          s
+        );
+      }
+      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);
+        return inner === void 0 ? s : recurse(inner).optional();
+      }
+      case "nullable": {
+        const inner = unwrapInner(s);
+        return inner === void 0 ? s : 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);
+        return inner === void 0 ? s : recurse(inner).readonly();
+      }
+      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));
+      }
+      // Pipes pass through (see the docblock); the rest are leaves
+      // whose checks the strip walker deliberately leaves in place —
+      // an async check on one of these still poisons the sync parse
+      // and the callers' defensive catch owns that case.
+      case "pipe":
+      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;
+    }
+  }
+  return recurse(schema);
+}
+
+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 assertKeyedRoot(rootSchema) {
+  const kind = kindOf(peelAllWrappers(rootSchema));
+  if (kind === "object" || kind === "record" || kind === "discriminated-union") return;
+  throw new AttaformError(
+    `[attaform] AF15 attaform.dev/e/af15 '${kind}'`
+  );
+}
+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);
+  assertKeyedRoot(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) => zodIssuesToValidationErrors(issues),
+    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),
+      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),
+        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 = buildFieldMetaPathMap(rootSchema, {
+    intro: V4_INTROSPECTOR,
+    peelAllWrappers,
+    getFieldMetaList: getFieldMetaListForSchema
+  });
+  const pathKey = canonicalizePath(path).key;
+  const peeled = peelAllWrappers(target);
+  const payload = pathMap?.get(pathKey) ?? getFieldMetaForSchema(target) ?? (peeled !== target ? getFieldMetaForSchema(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 { assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };