zod 4.0.0-beta.20250505T195954 → 4.0.0

package/{dist/esm → v4/classic}/schemas.js

@@ -1,14 +1,12 @@
-import * as core from "@zod/core";
-import { util } from "@zod/core";
+import * as core from "../core/index.js";
+import { util } from "../core/index.js";
 import * as checks from "./checks.js";
 import * as iso from "./iso.js";
 import * as parse from "./parse.js";
-export * as iso from "./iso.js";
-export * as coerce from "./coerce.js";
 export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
     core.$ZodType.init(inst, def);
     inst.def = def;
-    inst._def = def;
+    Object.defineProperty(inst, "_def", { value: def });
     // base methods
     inst.check = (...checks) => {
         return inst.clone({
@@ -17,18 +15,20 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
                 ...(def.checks ?? []),
                 ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
-        });
+        }
+        // { parent: true }
+        );
     };
-    inst.clone = (_def) => core.clone(inst, _def);
+    inst.clone = (def, params) => core.clone(inst, def, params);
     inst.brand = () => inst;
     inst.register = ((reg, meta) => {
         reg.add(inst, meta);
         return inst;
     });
     // parsing
-    inst.parse = (data, params) => parse.parse(inst, data, params);
+    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params);
+    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
     inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
     inst.spa = inst.safeParseAsync;
     // refinements
@@ -36,15 +36,16 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
     inst.overwrite = (fn) => inst.check(checks.overwrite(fn));
     // wrappers
-    inst.optional = (params) => optional(inst, params);
-    inst.nullable = (params) => nullable(inst, params);
+    inst.optional = () => optional(inst);
+    inst.nullable = () => nullable(inst);
     inst.nullish = () => optional(nullable(inst));
     inst.nonoptional = (params) => nonoptional(inst, params);
     inst.array = () => array(inst);
     inst.or = (arg) => union([inst, arg]);
     inst.and = (arg) => intersection(inst, arg);
     inst.transform = (tx) => pipe(inst, transform(tx));
-    inst.default = (def, params) => _default(inst, def, params);
+    inst.default = (def) => _default(inst, def);
+    inst.prefault = (def) => prefault(inst, def);
     // inst.coalesce = (def, params) => coalesce(inst, def, params);
     inst.catch = (params) => _catch(inst, params);
     inst.pipe = (target) => pipe(inst, target);
@@ -52,9 +53,7 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     // meta
     inst.describe = (description) => {
         const cl = inst.clone();
-        const meta = { ...(core.globalRegistry.get(inst) ?? {}), description };
-        delete meta.id; // do not inherit
-        core.globalRegistry.add(cl, meta);
+        core.globalRegistry.add(cl, { description });
         return cl;
     };
     Object.defineProperty(inst, "description", {
@@ -64,8 +63,9 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
         configurable: true,
     });
     inst.meta = (...args) => {
-        if (args.length === 0)
+        if (args.length === 0) {
             return core.globalRegistry.get(inst);
+        }
         const cl = inst.clone();
         core.globalRegistry.add(cl, args[0]);
         return cl;
@@ -75,17 +75,19 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     inst.isNullable = () => inst.safeParse(null).success;
     return inst;
 });
+/** @internal */
 export const _ZodString = /*@__PURE__*/ core.$constructor("_ZodString", (inst, def) => {
     core.$ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst.format = inst._zod.computed.format ?? null;
-    inst.minLength = inst._zod.computed.minimum ?? null;
-    inst.maxLength = inst._zod.computed.maximum ?? null;
+    const bag = inst._zod.bag;
+    inst.format = bag.format ?? null;
+    inst.minLength = bag.minimum ?? null;
+    inst.maxLength = bag.maximum ?? null;
     // validations
     inst.regex = (...args) => inst.check(checks.regex(...args));
     inst.includes = (...args) => inst.check(checks.includes(...args));
-    inst.startsWith = (params) => inst.check(checks.startsWith(params));
-    inst.endsWith = (params) => inst.check(checks.endsWith(params));
+    inst.startsWith = (...args) => inst.check(checks.startsWith(...args));
+    inst.endsWith = (...args) => inst.check(checks.endsWith(...args));
     inst.min = (...args) => inst.check(checks.minLength(...args));
     inst.max = (...args) => inst.check(checks.maxLength(...args));
     inst.length = (...args) => inst.check(checks.length(...args));
@@ -298,6 +300,14 @@ export const ZodJWT = /*@__PURE__*/ core.$constructor("ZodJWT", (inst, def) => {
 export function jwt(params) {
     return core._jwt(ZodJWT, params);
 }
+export const ZodCustomStringFormat = /*@__PURE__*/ core.$constructor("ZodCustomStringFormat", (inst, def) => {
+    // ZodStringFormat.init(inst, def);
+    core.$ZodCustomStringFormat.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+export function stringFormat(format, fnOrRegex, _params = {}) {
+    return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+}
 export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => {
     core.$ZodNumber.init(inst, def);
     ZodType.init(inst, def);
@@ -317,12 +327,14 @@ export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def
     inst.step = (value, params) => inst.check(checks.multipleOf(value, params));
     // inst.finite = (params) => inst.check(core.finite(params));
     inst.finite = () => inst;
-    inst.minValue = inst._zod.computed.minimum ?? null;
-    inst.maxValue = inst._zod.computed.maximum ?? null;
-    inst.isInt =
-        (inst._zod.computed.format ?? "").includes("int") || Number.isSafeInteger(inst._zod.computed.multipleOf ?? 0.5);
+    const bag = inst._zod.bag;
+    inst.minValue =
+        Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+    inst.maxValue =
+        Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
     inst.isFinite = true;
-    inst.format = inst._zod.computed.format ?? null;
+    inst.format = bag.format ?? null;
 });
 export function number(params) {
     return core._number(ZodNumber, params);
@@ -369,9 +381,10 @@ export const ZodBigInt = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def
     inst.nonpositive = (params) => inst.check(checks.lte(BigInt(0), params));
     inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params));
     inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));
-    inst.minValue = inst._zod.computed.minimum ?? null;
-    inst.maxValue = inst._zod.computed.maximum ?? null;
-    inst.format = inst._zod.computed.format ?? null;
+    const bag = inst._zod.bag;
+    inst.minValue = bag.minimum ?? null;
+    inst.maxValue = bag.maximum ?? null;
+    inst.format = bag.format ?? null;
 });
 export function bigint(params) {
     return core._bigint(ZodBigInt, params);
@@ -415,15 +428,15 @@ export const ZodAny = /*@__PURE__*/ core.$constructor("ZodAny", (inst, def) => {
     core.$ZodAny.init(inst, def);
     ZodType.init(inst, def);
 });
-export function any(params) {
-    return core._any(ZodAny, params);
+export function any() {
+    return core._any(ZodAny);
 }
 export const ZodUnknown = /*@__PURE__*/ core.$constructor("ZodUnknown", (inst, def) => {
     core.$ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
 });
-export function unknown(params) {
-    return core._unknown(ZodUnknown, params);
+export function unknown() {
+    return core._unknown(ZodUnknown);
 }
 export const ZodNever = /*@__PURE__*/ core.$constructor("ZodNever", (inst, def) => {
     core.$ZodNever.init(inst, def);
@@ -445,7 +458,7 @@ export const ZodDate = /*@__PURE__*/ core.$constructor("ZodDate", (inst, def) =>
     ZodType.init(inst, def);
     inst.min = (value, params) => inst.check(checks.gte(value, params));
     inst.max = (value, params) => inst.check(checks.lte(value, params));
-    const c = inst._zod.computed;
+    const c = inst._zod.bag;
     inst.minDate = c.minimum ? new Date(c.minimum) : null;
     inst.maxDate = c.maximum ? new Date(c.maximum) : null;
 });
@@ -460,6 +473,7 @@ export const ZodArray = /*@__PURE__*/ core.$constructor("ZodArray", (inst, def)
     inst.nonempty = (params) => inst.check(checks.minLength(1, params));
     inst.max = (maxLength, params) => inst.check(checks.maxLength(maxLength, params));
     inst.length = (len, params) => inst.check(checks.length(len, params));
+    inst.unwrap = () => inst.element;
 });
 export function array(element, params) {
     return core._array(ZodArray, element, params);
@@ -472,11 +486,9 @@ export function keyof(schema) {
 export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodType.init(inst, def);
-    util.defineLazy(inst, "shape", () => {
-        return Object.fromEntries(Object.entries(inst._zod.def.shape));
-    });
+    util.defineLazy(inst, "shape", () => def.shape);
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
+    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
     // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() });
     inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -534,21 +546,20 @@ export const ZodUnion = /*@__PURE__*/ core.$constructor("ZodUnion", (inst, def)
 export function union(options, params) {
     return new ZodUnion({
         type: "union",
-        options,
+        options: options,
         ...util.normalizeParams(params),
     });
 }
 export const ZodDiscriminatedUnion = /*@__PURE__*/ core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
+    ZodUnion.init(inst, def);
     core.$ZodDiscriminatedUnion.init(inst, def);
-    ZodType.init(inst, def);
 });
-export function discriminatedUnion(...args) {
-    if (typeof args[0] === "string")
-        args = args.slice(1);
-    const [options, params] = args;
+export function discriminatedUnion(discriminator, options, params) {
+    // const [options, params] = args;
     return new ZodDiscriminatedUnion({
         type: "union",
         options,
+        discriminator,
         ...util.normalizeParams(params),
     });
 }
@@ -556,12 +567,11 @@ export const ZodIntersection = /*@__PURE__*/ core.$constructor("ZodIntersection"
     core.$ZodIntersection.init(inst, def);
     ZodType.init(inst, def);
 });
-export function intersection(left, right, params) {
+export function intersection(left, right) {
     return new ZodIntersection({
         type: "intersection",
-        left,
-        right,
-        ...util.normalizeParams(params),
+        left: left,
+        right: right,
     });
 }
 export const ZodTuple = /*@__PURE__*/ core.$constructor("ZodTuple", (inst, def) => {
@@ -569,7 +579,7 @@ export const ZodTuple = /*@__PURE__*/ core.$constructor("ZodTuple", (inst, def)
     ZodType.init(inst, def);
     inst.rest = (rest) => inst.clone({
         ...inst._zod.def,
-        rest,
+        rest: rest,
     });
 });
 export function tuple(items, _paramsOrRest, _params) {
@@ -578,7 +588,7 @@ export function tuple(items, _paramsOrRest, _params) {
     const rest = hasRest ? _paramsOrRest : null;
     return new ZodTuple({
         type: "tuple",
-        items,
+        items: items,
         rest,
         ...util.normalizeParams(params),
     });
@@ -593,15 +603,16 @@ export function record(keyType, valueType, params) {
     return new ZodRecord({
         type: "record",
         keyType,
-        valueType,
+        valueType: valueType,
         ...util.normalizeParams(params),
     });
 }
+// type alksjf = core.output<core.$ZodRecordKey>;
 export function partialRecord(keyType, valueType, params) {
     return new ZodRecord({
         type: "record",
         keyType: union([keyType, never()]),
-        valueType,
+        valueType: valueType,
         ...util.normalizeParams(params),
     });
 }
@@ -614,8 +625,8 @@ export const ZodMap = /*@__PURE__*/ core.$constructor("ZodMap", (inst, def) => {
 export function map(keyType, valueType, params) {
     return new ZodMap({
         type: "map",
-        keyType,
-        valueType,
+        keyType: keyType,
+        valueType: valueType,
         ...util.normalizeParams(params),
     });
 }
@@ -630,7 +641,7 @@ export const ZodSet = /*@__PURE__*/ core.$constructor("ZodSet", (inst, def) => {
 export function set(valueType, params) {
     return new ZodSet({
         type: "set",
-        valueType,
+        valueType: valueType,
         ...util.normalizeParams(params),
     });
 }
@@ -700,6 +711,14 @@ export const ZodLiteral = /*@__PURE__*/ core.$constructor("ZodLiteral", (inst, d
     core.$ZodLiteral.init(inst, def);
     ZodType.init(inst, def);
     inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+        get() {
+            if (def.values.length > 1) {
+                throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+            }
+            return def.values[0];
+        },
+    });
 });
 export function literal(value, params) {
     return new ZodLiteral({
@@ -713,7 +732,7 @@ export const ZodFile = /*@__PURE__*/ core.$constructor("ZodFile", (inst, def) =>
     ZodType.init(inst, def);
     inst.min = (size, params) => inst.check(core._minSize(size, params));
     inst.max = (size, params) => inst.check(core._maxSize(size, params));
-    inst.mime = (types, params) => inst.check(core._mime(types, params));
+    inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
 });
 export function file(params) {
     return core._file(ZodFile, params);
@@ -734,7 +753,7 @@ export const ZodTransform = /*@__PURE__*/ core.$constructor("ZodTransform", (ins
                 _issue.code ?? (_issue.code = "custom");
                 _issue.input ?? (_issue.input = payload.value);
                 _issue.inst ?? (_issue.inst = inst);
-                _issue.continue ?? (_issue.continue = !def.abort);
+                _issue.continue ?? (_issue.continue = true);
                 payload.issues.push(util.issue(_issue));
             }
         };
@@ -749,11 +768,10 @@ export const ZodTransform = /*@__PURE__*/ core.$constructor("ZodTransform", (ins
         return payload;
     };
 });
-export function transform(fn, params) {
+export function transform(fn) {
     return new ZodTransform({
         type: "transform",
         transform: fn,
-        ...util.normalizeParams(params),
     });
 }
 export const ZodOptional = /*@__PURE__*/ core.$constructor("ZodOptional", (inst, def) => {
@@ -761,11 +779,10 @@ export const ZodOptional = /*@__PURE__*/ core.$constructor("ZodOptional", (inst,
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
 });
-export function optional(innerType, params) {
+export function optional(innerType) {
     return new ZodOptional({
         type: "optional",
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
     });
 }
 export const ZodNullable = /*@__PURE__*/ core.$constructor("ZodNullable", (inst, def) => {
@@ -773,11 +790,10 @@ export const ZodNullable = /*@__PURE__*/ core.$constructor("ZodNullable", (inst,
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
 });
-export function nullable(innerType, params) {
+export function nullable(innerType) {
     return new ZodNullable({
         type: "nullable",
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
     });
 }
 // nullish
@@ -790,12 +806,27 @@ export const ZodDefault = /*@__PURE__*/ core.$constructor("ZodDefault", (inst, d
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeDefault = inst.unwrap;
 });
-export function _default(innerType, defaultValue, params) {
+export function _default(innerType, defaultValue) {
     return new ZodDefault({
         type: "default",
-        defaultValue: (typeof defaultValue === "function" ? defaultValue : () => defaultValue),
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
+        get defaultValue() {
+            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+        },
+    });
+}
+export const ZodPrefault = /*@__PURE__*/ core.$constructor("ZodPrefault", (inst, def) => {
+    core.$ZodPrefault.init(inst, def);
+    ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+});
+export function prefault(innerType, defaultValue) {
+    return new ZodPrefault({
+        type: "prefault",
+        innerType: innerType,
+        get defaultValue() {
+            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+        },
     });
 }
 export const ZodNonOptional = /*@__PURE__*/ core.$constructor("ZodNonOptional", (inst, def) => {
@@ -806,7 +837,7 @@ export const ZodNonOptional = /*@__PURE__*/ core.$constructor("ZodNonOptional",
 export function nonoptional(innerType, params) {
     return new ZodNonOptional({
         type: "nonoptional",
-        innerType,
+        innerType: innerType,
         ...util.normalizeParams(params),
     });
 }
@@ -815,11 +846,10 @@ export const ZodSuccess = /*@__PURE__*/ core.$constructor("ZodSuccess", (inst, d
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
 });
-export function success(innerType, params) {
+export function success(innerType) {
     return new ZodSuccess({
         type: "success",
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
     });
 }
 export const ZodCatch = /*@__PURE__*/ core.$constructor("ZodCatch", (inst, def) => {
@@ -828,12 +858,11 @@ export const ZodCatch = /*@__PURE__*/ core.$constructor("ZodCatch", (inst, def)
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeCatch = inst.unwrap;
 });
-function _catch(innerType, catchValue, params) {
+function _catch(innerType, catchValue) {
     return new ZodCatch({
         type: "catch",
-        innerType,
+        innerType: innerType,
         catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue),
-        ...util.normalizeParams(params),
     });
 }
 export { _catch as catch };
@@ -850,23 +879,22 @@ export const ZodPipe = /*@__PURE__*/ core.$constructor("ZodPipe", (inst, def) =>
     inst.in = def.in;
     inst.out = def.out;
 });
-export function pipe(in_, out, params) {
+export function pipe(in_, out) {
     return new ZodPipe({
         type: "pipe",
         in: in_,
-        out,
-        ...util.normalizeParams(params),
+        out: out,
+        // ...util.normalizeParams(params),
     });
 }
 export const ZodReadonly = /*@__PURE__*/ core.$constructor("ZodReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
 });
-export function readonly(innerType, params) {
+export function readonly(innerType) {
     return new ZodReadonly({
         type: "readonly",
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
     });
 }
 export const ZodTemplateLiteral = /*@__PURE__*/ core.$constructor("ZodTemplateLiteral", (inst, def) => {
@@ -888,7 +916,7 @@ export const ZodLazy = /*@__PURE__*/ core.$constructor("ZodLazy", (inst, def) =>
 export function lazy(getter) {
     return new ZodLazy({
         type: "lazy",
-        getter,
+        getter: getter,
     });
 }
 export const ZodPromise = /*@__PURE__*/ core.$constructor("ZodPromise", (inst, def) => {
@@ -896,11 +924,10 @@ export const ZodPromise = /*@__PURE__*/ core.$constructor("ZodPromise", (inst, d
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
 });
-export function promise(innerType, params) {
+export function promise(innerType) {
     return new ZodPromise({
         type: "promise",
-        innerType,
-        ...util.normalizeParams(params),
+        innerType: innerType,
     });
 }
 export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def) => {
@@ -908,10 +935,10 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
 });
 // custom checks
-export function check(fn, params) {
+export function check(fn) {
     const ch = new core.$ZodCheck({
         check: "custom",
-        ...util.normalizeParams(params),
+        // ...util.normalizeParams(params),
     });
     ch._zod.check = fn;
     return ch;
@@ -920,10 +947,10 @@ export function custom(fn, _params) {
     return core._custom(ZodCustom, fn ?? (() => true), _params);
 }
 export function refine(fn, _params = {}) {
-    return core._custom(ZodCustom, fn, _params);
+    return core._refine(ZodCustom, fn, _params);
 }
 // superRefine
-export function superRefine(fn, params) {
+export function superRefine(fn) {
     const ch = check((payload) => {
         payload.addIssue = (issue) => {
             if (typeof issue === "string") {
@@ -942,39 +969,38 @@ export function superRefine(fn, params) {
             }
         };
         return fn(payload.value, payload);
-    }, params);
+    });
     return ch;
 }
-// instanceof
-class Class {
-    constructor(..._args) { }
-}
 function _instanceof(cls, params = {
     error: `Input not instance of ${cls.name}`,
 }) {
-    return new ZodCustom({
+    const inst = new ZodCustom({
         type: "custom",
         check: "custom",
         fn: (data) => data instanceof cls,
         abort: true,
         ...util.normalizeParams(params),
     });
+    inst._zod.bag.Class = cls;
+    return inst;
 }
 export { _instanceof as instanceof };
 // stringbool
-export const stringbool = 
-/*@__PURE__*/ core._stringbool.bind(null, {
+export const stringbool = (...args) => core._stringbool({
     Pipe: ZodPipe,
     Boolean: ZodBoolean,
-    Unknown: ZodUnknown,
-});
+    String: ZodString,
+    Transform: ZodTransform,
+}, ...args);
 export function json(params) {
     const jsonSchema = lazy(() => {
         return union([string(params), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);
     });
     return jsonSchema;
 }
+// preprocess
 // /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
-export function preprocess(fn, schema, params) {
-    return pipe(transform(fn, params), schema, params);
+export function preprocess(fn, schema) {
+    return pipe(transform(fn), schema);
 }