zod 3.25.13 → 3.25.15

package/dist/v3/tests/optional.test.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+function checkErrors(a, bad) {
+    let expected;
+    try {
+        a.parse(bad);
+    }
+    catch (error) {
+        expected = error.formErrors;
+    }
+    try {
+        a.optional().parse(bad);
+    }
+    catch (error) {
+        (0, vitest_1.expect)(error.formErrors).toEqual(expected);
+    }
+}
+(0, vitest_1.test)("Should have error messages appropriate for the underlying type", () => {
+    checkErrors(z.string().min(2), 1);
+    z.string().min(2).optional().parse(undefined);
+    checkErrors(z.number().gte(2), 1);
+    z.number().gte(2).optional().parse(undefined);
+    checkErrors(z.boolean(), "");
+    z.boolean().optional().parse(undefined);
+    checkErrors(z.undefined(), null);
+    z.undefined().optional().parse(undefined);
+    checkErrors(z.null(), {});
+    z.null().optional().parse(undefined);
+    checkErrors(z.object({}), 1);
+    z.object({}).optional().parse(undefined);
+    checkErrors(z.tuple([]), 1);
+    z.tuple([]).optional().parse(undefined);
+    checkErrors(z.unknown(), 1);
+    z.unknown().optional().parse(undefined);
+});
+(0, vitest_1.test)("unwrap", () => {
+    const unwrapped = z.string().optional().unwrap();
+    (0, vitest_1.expect)(unwrapped).toBeInstanceOf(z.ZodString);
+});

package/dist/v3/tests/parseUtil.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/parseUtil.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const parseUtil_js_1 = require("../helpers/parseUtil.js");
+(0, vitest_1.test)("parseUtil isInvalid should use structural typing", () => {
+    // Test for issue #556: https://github.com/colinhacks/zod/issues/556
+    const aborted = { status: "aborted" };
+    const dirty = { status: "dirty", value: "whatever" };
+    const valid = { status: "valid", value: "whatever" };
+    (0, vitest_1.expect)((0, parseUtil_js_1.isAborted)(aborted)).toBe(true);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isAborted)(dirty)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isAborted)(valid)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isDirty)(aborted)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isDirty)(dirty)).toBe(true);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isDirty)(valid)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isValid)(aborted)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isValid)(dirty)).toBe(false);
+    (0, vitest_1.expect)((0, parseUtil_js_1.isValid)(valid)).toBe(true);
+});

package/dist/v3/tests/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/parser.test.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+(0, vitest_1.test)("parse strict object with unknown keys", () => {
+    (0, vitest_1.expect)(() => z
+        .object({ name: z.string() })
+        .strict()
+        .parse({ name: "bill", unknownKey: 12 })).toThrow();
+});
+(0, vitest_1.test)("parse nonstrict object with unknown keys", () => {
+    z.object({ name: z.string() }).nonstrict().parse({ name: "bill", unknownKey: 12 });
+});
+(0, vitest_1.test)("invalid left side of intersection", () => {
+    (0, vitest_1.expect)(() => z.intersection(z.string(), z.number()).parse(12)).toThrow();
+});
+(0, vitest_1.test)("invalid right side of intersection", () => {
+    (0, vitest_1.expect)(() => z.intersection(z.string(), z.number()).parse("12")).toThrow();
+});
+(0, vitest_1.test)("parsing non-array in tuple schema", () => {
+    (0, vitest_1.expect)(() => z.tuple([]).parse("12")).toThrow();
+});
+(0, vitest_1.test)("incorrect num elements in tuple", () => {
+    (0, vitest_1.expect)(() => z.tuple([]).parse(["asdf"])).toThrow();
+});
+(0, vitest_1.test)("invalid enum value", () => {
+    (0, vitest_1.expect)(() => z.enum(["Blue"]).parse("Red")).toThrow();
+});
+(0, vitest_1.test)("parsing unknown", () => {
+    z.string().parse("Red");
+});

package/dist/v3/tests/partials.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/partials.test.js

@@ -0,0 +1,201 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const v3_1 = require("zod/v3");
+const util_js_1 = require("../helpers/util.js");
+const nested = z.object({
+    name: z.string(),
+    age: z.number(),
+    outer: z.object({
+        inner: z.string(),
+    }),
+    array: z.array(z.object({ asdf: z.string() })),
+});
+(0, vitest_1.test)("shallow inference", () => {
+    const shallow = nested.partial();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("shallow partial parse", () => {
+    const shallow = nested.partial();
+    shallow.parse({});
+    shallow.parse({
+        name: "asdf",
+        age: 23143,
+    });
+});
+(0, vitest_1.test)("deep partial inference", () => {
+    const deep = nested.deepPartial();
+    const asdf = deep.shape.array.unwrap().element.shape.asdf.unwrap();
+    asdf.parse("asdf");
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("deep partial parse", () => {
+    const deep = nested.deepPartial();
+    (0, vitest_1.expect)(deep.shape.name instanceof z.ZodOptional).toBe(true);
+    (0, vitest_1.expect)(deep.shape.outer instanceof z.ZodOptional).toBe(true);
+    (0, vitest_1.expect)(deep.shape.outer._def.innerType instanceof z.ZodObject).toBe(true);
+    (0, vitest_1.expect)(deep.shape.outer._def.innerType.shape.inner instanceof z.ZodOptional).toBe(true);
+    (0, vitest_1.expect)(deep.shape.outer._def.innerType.shape.inner._def.innerType instanceof z.ZodString).toBe(true);
+});
+(0, vitest_1.test)("deep partial runtime tests", () => {
+    const deep = nested.deepPartial();
+    deep.parse({});
+    deep.parse({
+        outer: {},
+    });
+    deep.parse({
+        name: "asdf",
+        age: 23143,
+        outer: {
+            inner: "adsf",
+        },
+    });
+});
+(0, vitest_1.test)("deep partial optional/nullable", () => {
+    const schema = z
+        .object({
+        name: z.string().optional(),
+        age: z.number().nullable(),
+    })
+        .deepPartial();
+    (0, vitest_1.expect)(schema.shape.name.unwrap()).toBeInstanceOf(v3_1.ZodOptional);
+    (0, vitest_1.expect)(schema.shape.age.unwrap()).toBeInstanceOf(v3_1.ZodNullable);
+});
+(0, vitest_1.test)("deep partial tuple", () => {
+    const schema = z
+        .object({
+        tuple: z.tuple([
+            z.object({
+                name: z.string().optional(),
+                age: z.number().nullable(),
+            }),
+        ]),
+    })
+        .deepPartial();
+    (0, vitest_1.expect)(schema.shape.tuple.unwrap().items[0].shape.name).toBeInstanceOf(v3_1.ZodOptional);
+});
+(0, vitest_1.test)("deep partial inference", () => {
+    const mySchema = z.object({
+        name: z.string(),
+        array: z.array(z.object({ asdf: z.string() })),
+        tuple: z.tuple([z.object({ value: z.string() })]),
+    });
+    const partialed = mySchema.deepPartial();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("required", () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        nullableField: z.number().nullable(),
+        nullishField: z.string().nullish(),
+    });
+    const requiredObject = object.required();
+    (0, vitest_1.expect)(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+    (0, vitest_1.expect)(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+    (0, vitest_1.expect)(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+    (0, vitest_1.expect)(requiredObject.shape.nullableField).toBeInstanceOf(z.ZodNullable);
+    (0, vitest_1.expect)(requiredObject.shape.nullishField).toBeInstanceOf(z.ZodNullable);
+});
+(0, vitest_1.test)("required inference", () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        nullableField: z.number().nullable(),
+        nullishField: z.string().nullish(),
+    });
+    const requiredObject = object.required();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("required with mask", () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        country: z.string().optional(),
+    });
+    const requiredObject = object.required({ age: true });
+    (0, vitest_1.expect)(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+    (0, vitest_1.expect)(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+    (0, vitest_1.expect)(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+    (0, vitest_1.expect)(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
+});
+(0, vitest_1.test)("required with mask -- ignore falsy values", () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        country: z.string().optional(),
+    });
+    // @ts-expect-error
+    const requiredObject = object.required({ age: true, country: false });
+    (0, vitest_1.expect)(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+    (0, vitest_1.expect)(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+    (0, vitest_1.expect)(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+    (0, vitest_1.expect)(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
+});
+(0, vitest_1.test)("partial with mask", async () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        country: z.string(),
+    });
+    const masked = object.partial({ age: true, field: true, name: true }).strict();
+    (0, vitest_1.expect)(masked.shape.name).toBeInstanceOf(z.ZodOptional);
+    (0, vitest_1.expect)(masked.shape.age).toBeInstanceOf(z.ZodOptional);
+    (0, vitest_1.expect)(masked.shape.field).toBeInstanceOf(z.ZodOptional);
+    (0, vitest_1.expect)(masked.shape.country).toBeInstanceOf(z.ZodString);
+    masked.parse({ country: "US" });
+    await masked.parseAsync({ country: "US" });
+});
+(0, vitest_1.test)("partial with mask -- ignore falsy values", async () => {
+    const object = z.object({
+        name: z.string(),
+        age: z.number().optional(),
+        field: z.string().optional().default("asdf"),
+        country: z.string(),
+    });
+    // @ts-expect-error
+    const masked = object.partial({ name: true, country: false }).strict();
+    (0, vitest_1.expect)(masked.shape.name).toBeInstanceOf(z.ZodOptional);
+    (0, vitest_1.expect)(masked.shape.age).toBeInstanceOf(z.ZodOptional);
+    (0, vitest_1.expect)(masked.shape.field).toBeInstanceOf(z.ZodDefault);
+    (0, vitest_1.expect)(masked.shape.country).toBeInstanceOf(z.ZodString);
+    masked.parse({ country: "US" });
+    await masked.parseAsync({ country: "US" });
+});
+(0, vitest_1.test)("deeppartial array", () => {
+    const schema = z.object({ array: z.string().array().min(42) }).deepPartial();
+    // works as expected
+    schema.parse({});
+    // should be false, but is true
+    (0, vitest_1.expect)(schema.safeParse({ array: [] }).success).toBe(false);
+});

package/dist/v3/tests/pickomit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/pickomit.test.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const util_js_1 = require("../helpers/util.js");
+const fish = z.object({
+    name: z.string(),
+    age: z.number(),
+    nested: z.object({}),
+});
+(0, vitest_1.test)("pick type inference", () => {
+    const nameonlyFish = fish.pick({ name: true });
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("pick parse - success", () => {
+    const nameonlyFish = fish.pick({ name: true });
+    nameonlyFish.parse({ name: "bob" });
+    // @ts-expect-error checking runtime picks `name` only.
+    const anotherNameonlyFish = fish.pick({ name: true, age: false });
+    anotherNameonlyFish.parse({ name: "bob" });
+});
+(0, vitest_1.test)("pick parse - fail", () => {
+    fish.pick({ name: true }).parse({ name: "12" });
+    fish.pick({ name: true }).parse({ name: "bob", age: 12 });
+    fish.pick({ age: true }).parse({ age: 12 });
+    const nameonlyFish = fish.pick({ name: true }).strict();
+    const bad1 = () => nameonlyFish.parse({ name: 12 });
+    const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 });
+    const bad3 = () => nameonlyFish.parse({ age: 12 });
+    // @ts-expect-error checking runtime picks `name` only.
+    const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
+    const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 });
+    (0, vitest_1.expect)(bad1).toThrow();
+    (0, vitest_1.expect)(bad2).toThrow();
+    (0, vitest_1.expect)(bad3).toThrow();
+    (0, vitest_1.expect)(bad4).toThrow();
+});
+(0, vitest_1.test)("omit type inference", () => {
+    const nonameFish = fish.omit({ name: true });
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("omit parse - success", () => {
+    const nonameFish = fish.omit({ name: true });
+    nonameFish.parse({ age: 12, nested: {} });
+    // @ts-expect-error checking runtime omits `name` only.
+    const anotherNonameFish = fish.omit({ name: true, age: false });
+    anotherNonameFish.parse({ age: 12, nested: {} });
+});
+(0, vitest_1.test)("omit parse - fail", () => {
+    const nonameFish = fish.omit({ name: true });
+    const bad1 = () => nonameFish.parse({ name: 12 });
+    const bad2 = () => nonameFish.parse({ age: 12 });
+    const bad3 = () => nonameFish.parse({});
+    // @ts-expect-error checking runtime omits `name` only.
+    const anotherNonameFish = fish.omit({ name: true, age: false });
+    const bad4 = () => anotherNonameFish.parse({ nested: {} });
+    (0, vitest_1.expect)(bad1).toThrow();
+    (0, vitest_1.expect)(bad2).toThrow();
+    (0, vitest_1.expect)(bad3).toThrow();
+    (0, vitest_1.expect)(bad4).toThrow();
+});
+(0, vitest_1.test)("nonstrict inference", () => {
+    const laxfish = fish.pick({ name: true }).catchall(z.any());
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("nonstrict parsing - pass", () => {
+    const laxfish = fish.passthrough().pick({ name: true });
+    laxfish.parse({ name: "asdf", whatever: "asdf" });
+    laxfish.parse({ name: "asdf", age: 12, nested: {} });
+});
+(0, vitest_1.test)("nonstrict parsing - fail", () => {
+    const laxfish = fish.passthrough().pick({ name: true });
+    const bad = () => laxfish.parse({ whatever: "asdf" });
+    (0, vitest_1.expect)(bad).toThrow();
+});
+(0, vitest_1.test)("pick/omit/required/partial - do not allow unknown keys", () => {
+    const schema = z.object({
+        name: z.string(),
+        age: z.number(),
+    });
+    // @ts-expect-error
+    schema.pick({ $unknown: true });
+    // @ts-expect-error
+    schema.omit({ $unknown: true });
+    // @ts-expect-error
+    schema.required({ $unknown: true });
+    // @ts-expect-error
+    schema.partial({ $unknown: true });
+});

package/dist/v3/tests/pipeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/pipeline.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+(0, vitest_1.test)("string to number pipeline", () => {
+    const schema = z.string().transform(Number).pipe(z.number());
+    (0, vitest_1.expect)(schema.parse("1234")).toEqual(1234);
+});
+(0, vitest_1.test)("string to number pipeline async", async () => {
+    const schema = z
+        .string()
+        .transform(async (val) => Number(val))
+        .pipe(z.number());
+    (0, vitest_1.expect)(await schema.parseAsync("1234")).toEqual(1234);
+});
+(0, vitest_1.test)("break if dirty", () => {
+    const schema = z
+        .string()
+        .refine((c) => c === "1234")
+        .transform(async (val) => Number(val))
+        .pipe(z.number().refine((v) => v < 100));
+    const r1 = schema.safeParse("12345");
+    (0, vitest_1.expect)(r1.error.issues.length).toBe(1);
+    const r2 = schema.safeParse("3");
+    (0, vitest_1.expect)(r2.error.issues.length).toBe(1);
+});

package/dist/v3/tests/preprocess.test.d.ts

@@ -0,0 +1 @@
+export {};