zod 3.26.0-canary.20250703T013930 → 3.26.0-canary.20250703T025502

package/src/v4/classic/tests/primitive.test.ts

@@ -0,0 +1,175 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const literalStringSchema = z.literal("asdf");
+const literalNumberSchema = z.literal(12);
+const literalBooleanSchema = z.literal(true);
+const literalBigIntSchema = z.literal(BigInt(42));
+
+const stringSchema = z.string();
+const numberSchema = z.number();
+const bigintSchema = z.bigint();
+const booleanSchema = z.boolean();
+const dateSchema = z.date();
+const symbolSchema = z.symbol();
+const nullSchema = z.null();
+const undefinedSchema = z.undefined();
+const stringSchemaOptional = z.string().optional();
+const stringSchemaNullable = z.string().nullable();
+const numberSchemaOptional = z.number().optional();
+const numberSchemaNullable = z.number().nullable();
+const bigintSchemaOptional = z.bigint().optional();
+const bigintSchemaNullable = z.bigint().nullable();
+const booleanSchemaOptional = z.boolean().optional();
+const booleanSchemaNullable = z.boolean().nullable();
+const dateSchemaOptional = z.date().optional();
+const dateSchemaNullable = z.date().nullable();
+const symbolSchemaOptional = z.symbol().optional();
+const symbolSchemaNullable = z.symbol().nullable();
+
+test("literal string schema", () => {
+  expect(literalStringSchema.parse("asdf")).toBe("asdf");
+  expect(() => literalStringSchema.parse("not_asdf")).toThrow();
+  expect(() => literalStringSchema.parse(123)).toThrow();
+  expect(() => literalStringSchema.parse(true)).toThrow();
+  expect(() => literalStringSchema.parse({})).toThrow();
+});
+
+test("literal number schema", () => {
+  expect(literalNumberSchema.parse(12)).toBe(12);
+  expect(() => literalNumberSchema.parse(13)).toThrow();
+  expect(() => literalNumberSchema.parse("foo")).toThrow();
+  expect(() => literalNumberSchema.parse(true)).toThrow();
+  expect(() => literalNumberSchema.parse({})).toThrow();
+});
+
+test("literal boolean schema", () => {
+  expect(literalBooleanSchema.parse(true)).toBe(true);
+  expect(() => literalBooleanSchema.parse(false)).toThrow();
+  expect(() => literalBooleanSchema.parse("asdf")).toThrow();
+  expect(() => literalBooleanSchema.parse(123)).toThrow();
+  expect(() => literalBooleanSchema.parse({})).toThrow();
+});
+
+test("literal bigint schema", () => {
+  expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
+  expect(() => literalBigIntSchema.parse(BigInt(43))).toThrow();
+  expect(() => literalBigIntSchema.parse("asdf")).toThrow();
+  expect(() => literalBigIntSchema.parse(123)).toThrow();
+  expect(() => literalBigIntSchema.parse({})).toThrow();
+});
+
+test("string schema", () => {
+  stringSchema.parse("foo");
+  expect(() => stringSchema.parse(Math.random())).toThrow();
+  expect(() => stringSchema.parse(true)).toThrow();
+  expect(() => stringSchema.parse(undefined)).toThrow();
+  expect(() => stringSchema.parse(null)).toThrow();
+});
+
+test("number schema", () => {
+  numberSchema.parse(Math.random());
+  expect(() => numberSchema.parse("foo")).toThrow();
+  expect(() => numberSchema.parse(BigInt(17))).toThrow();
+  expect(() => numberSchema.parse(true)).toThrow();
+  expect(() => numberSchema.parse(undefined)).toThrow();
+  expect(() => numberSchema.parse(null)).toThrow();
+});
+
+test("bigint schema", () => {
+  bigintSchema.parse(BigInt(17));
+  expect(() => bigintSchema.parse("foo")).toThrow();
+  expect(() => bigintSchema.parse(Math.random())).toThrow();
+  expect(() => bigintSchema.parse(true)).toThrow();
+  expect(() => bigintSchema.parse(undefined)).toThrow();
+  expect(() => bigintSchema.parse(null)).toThrow();
+});
+
+test("boolean schema", () => {
+  booleanSchema.parse(true);
+  expect(() => booleanSchema.parse("foo")).toThrow();
+  expect(() => booleanSchema.parse(Math.random())).toThrow();
+  expect(() => booleanSchema.parse(undefined)).toThrow();
+  expect(() => booleanSchema.parse(null)).toThrow();
+});
+
+test("date schema", async () => {
+  dateSchema.parse(new Date());
+  expect(() => dateSchema.parse("foo")).toThrow();
+  expect(() => dateSchema.parse(Math.random())).toThrow();
+  expect(() => dateSchema.parse(true)).toThrow();
+  expect(() => dateSchema.parse(undefined)).toThrow();
+  expect(() => dateSchema.parse(null)).toThrow();
+  expect(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "date",
+        "code": "invalid_type",
+        "received": "Invalid Date",
+        "path": [],
+        "message": "Invalid input: expected date, received Date"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("symbol schema", () => {
+  symbolSchema.parse(Symbol("foo"));
+  expect(() => symbolSchema.parse("foo")).toThrow();
+  expect(() => symbolSchema.parse(Math.random())).toThrow();
+  expect(() => symbolSchema.parse(true)).toThrow();
+  expect(() => symbolSchema.parse(new Date())).toThrow();
+  expect(() => symbolSchema.parse(undefined)).toThrow();
+  expect(() => symbolSchema.parse(null)).toThrow();
+});
+
+test("undefined schema", () => {
+  undefinedSchema.parse(undefined);
+  expect(() => undefinedSchema.parse("foo")).toThrow();
+  expect(() => undefinedSchema.parse(Math.random())).toThrow();
+  expect(() => undefinedSchema.parse(true)).toThrow();
+  expect(() => undefinedSchema.parse(null)).toThrow();
+});
+
+test("null schema", () => {
+  nullSchema.parse(null);
+  expect(() => nullSchema.parse("foo")).toThrow();
+  expect(() => nullSchema.parse(Math.random())).toThrow();
+  expect(() => nullSchema.parse(true)).toThrow();
+  expect(() => nullSchema.parse(undefined)).toThrow();
+});
+
+test("primitive inference", () => {
+  expectTypeOf<z.TypeOf<typeof literalStringSchema>>().toEqualTypeOf<"asdf">();
+  expectTypeOf<z.TypeOf<typeof literalNumberSchema>>().toEqualTypeOf<12>();
+  expectTypeOf<z.TypeOf<typeof literalBooleanSchema>>().toEqualTypeOf<true>();
+  expectTypeOf<z.TypeOf<typeof literalBigIntSchema>>().toEqualTypeOf<bigint>();
+  expectTypeOf<z.TypeOf<typeof stringSchema>>().toEqualTypeOf<string>();
+  expectTypeOf<z.TypeOf<typeof numberSchema>>().toEqualTypeOf<number>();
+  expectTypeOf<z.TypeOf<typeof bigintSchema>>().toEqualTypeOf<bigint>();
+  expectTypeOf<z.TypeOf<typeof booleanSchema>>().toEqualTypeOf<boolean>();
+  expectTypeOf<z.TypeOf<typeof dateSchema>>().toEqualTypeOf<Date>();
+  expectTypeOf<z.TypeOf<typeof symbolSchema>>().toEqualTypeOf<symbol>();
+  expectTypeOf<z.TypeOf<typeof nullSchema>>().toEqualTypeOf<null>();
+  expectTypeOf<z.TypeOf<typeof undefinedSchema>>().toEqualTypeOf<undefined>();
+  expectTypeOf<z.TypeOf<typeof stringSchemaOptional>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.TypeOf<typeof stringSchemaNullable>>().toEqualTypeOf<string | null>();
+  expectTypeOf<z.TypeOf<typeof numberSchemaOptional>>().toEqualTypeOf<number | undefined>();
+  expectTypeOf<z.TypeOf<typeof numberSchemaNullable>>().toEqualTypeOf<number | null>();
+  expectTypeOf<z.TypeOf<typeof bigintSchemaOptional>>().toEqualTypeOf<bigint | undefined>();
+  expectTypeOf<z.TypeOf<typeof bigintSchemaNullable>>().toEqualTypeOf<bigint | null>();
+  expectTypeOf<z.TypeOf<typeof booleanSchemaOptional>>().toEqualTypeOf<boolean | undefined>();
+  expectTypeOf<z.TypeOf<typeof booleanSchemaNullable>>().toEqualTypeOf<boolean | null>();
+  expectTypeOf<z.TypeOf<typeof dateSchemaOptional>>().toEqualTypeOf<Date | undefined>();
+  expectTypeOf<z.TypeOf<typeof dateSchemaNullable>>().toEqualTypeOf<Date | null>();
+  expectTypeOf<z.TypeOf<typeof symbolSchemaOptional>>().toEqualTypeOf<symbol | undefined>();
+  expectTypeOf<z.TypeOf<typeof symbolSchemaNullable>>().toEqualTypeOf<symbol | null>();
+});
+
+test("get literal values", () => {
+  expect(literalStringSchema.values).toEqual(new Set(["asdf"]));
+  expect(literalStringSchema._zod.def.values).toEqual(["asdf"]);
+});

package/src/v4/classic/tests/promise.test.ts

@@ -0,0 +1,81 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const promSchema = z.promise(
+  z.object({
+    name: z.string(),
+    age: z.number(),
+  })
+);
+
+test("promise inference", () => {
+  type promSchemaType = z.infer<typeof promSchema>;
+  expectTypeOf<promSchemaType>().toEqualTypeOf<{ name: string; age: number }>();
+});
+
+test("promise parsing success", async () => {
+  // expect(() => promSchema.parse(Promise.resolve({ name: "Bobby", age: 10 }))).toThrow();
+  const pr = promSchema.parseAsync(Promise.resolve({ name: "Bobby", age: 10 }));
+  expect(pr).toBeInstanceOf(Promise);
+  const result = await pr;
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "age": 10,
+      "name": "Bobby",
+    }
+  `);
+});
+
+test("promise parsing fail", async () => {
+  const bad = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
+  expect(bad.success).toBe(false);
+  expect(bad.error).toBeInstanceOf(z.ZodError);
+});
+
+test("promise parsing fail 2", async () => {
+  const result = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
+  expect(result.success).toBe(false);
+  expect(result.error).toBeInstanceOf(z.ZodError);
+});
+
+test("promise parsing fail", () => {
+  const bad = () => promSchema.parse({ then: () => {}, catch: {} });
+  expect(bad).toThrow();
+});
+
+test("sync promise parsing", () => {
+  expect(() => z.promise(z.string()).parse(Promise.resolve("asfd"))).toThrow();
+});
+
+const asyncFunction = z.function({
+  input: z.tuple([]),
+  output: promSchema,
+});
+
+test("async function pass", async () => {
+  const validatedFunction = asyncFunction.implementAsync(async () => {
+    return { name: "jimmy", age: 14 };
+  });
+  await expect(validatedFunction()).resolves.toEqual({
+    name: "jimmy",
+    age: 14,
+  });
+});
+
+test("async function fail", async () => {
+  const validatedFunction = asyncFunction.implementAsync(() => {
+    return Promise.resolve("asdf" as any);
+  });
+  await expect(validatedFunction()).rejects.toBeInstanceOf(z.core.$ZodError);
+});
+
+test("async promise parsing", () => {
+  const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
+  expect(res).toBeInstanceOf(Promise);
+});
+
+test("resolves", () => {
+  const foo = z.literal("foo");
+  const res = z.promise(foo);
+  expect(res.unwrap()).toEqual(foo);
+});

package/src/v4/classic/tests/prototypes.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+declare module "zod/v4" {
+  interface ZodType {
+    /** @deprecated */
+    _classic(): string;
+  }
+}
+
+test("prototype extension", () => {
+  z.ZodType.prototype._classic = function () {
+    return "_classic";
+  };
+
+  // should pass
+  const result = z.string()._classic();
+  expect(result).toBe("_classic");
+  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
+
+  // clean up
+  z.ZodType.prototype._classic = undefined;
+});

package/src/v4/classic/tests/readonly.test.ts

@@ -0,0 +1,252 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+enum testEnum {
+  A = 0,
+  B = 1,
+}
+
+test("flat inference", () => {
+  const readonlyString = z.string().readonly();
+  const readonlyNumber = z.number().readonly();
+  const readonlyNaN = z.nan().readonly();
+  const readonlyBigInt = z.bigint().readonly();
+  const readonlyBoolean = z.boolean().readonly();
+  const readonlyDate = z.date().readonly();
+  const readonlyUndefined = z.undefined().readonly();
+  const readonlyNull = z.null().readonly();
+  const readonlyAny = z.any().readonly();
+  const readonlyUnknown = z.unknown().readonly();
+  const readonlyVoid = z.void().readonly();
+  const readonlyStringArray = z.array(z.string()).readonly();
+  const readonlyTuple = z.tuple([z.string(), z.number()]).readonly();
+  const readonlyMap = z.map(z.string(), z.date()).readonly();
+  const readonlySet = z.set(z.string()).readonly();
+  const readonlyStringRecord = z.record(z.string(), z.string()).readonly();
+  const readonlyNumberRecord = z.record(z.string(), z.number()).readonly();
+  const readonlyObject = z.object({ a: z.string(), 1: z.number() }).readonly();
+  const readonlyEnum = z.nativeEnum(testEnum).readonly();
+  const readonlyPromise = z.promise(z.string()).readonly();
+
+  expectTypeOf<typeof readonlyString._output>().toEqualTypeOf<string>();
+  expectTypeOf<typeof readonlyNumber._output>().toEqualTypeOf<number>();
+  expectTypeOf<typeof readonlyNaN._output>().toEqualTypeOf<number>();
+  expectTypeOf<typeof readonlyBigInt._output>().toEqualTypeOf<bigint>();
+  expectTypeOf<typeof readonlyBoolean._output>().toEqualTypeOf<boolean>();
+  expectTypeOf<typeof readonlyDate._output>().toEqualTypeOf<Date>();
+  expectTypeOf<typeof readonlyUndefined._output>().toEqualTypeOf<undefined>();
+  expectTypeOf<typeof readonlyNull._output>().toEqualTypeOf<null>();
+  expectTypeOf<typeof readonlyAny._output>().toEqualTypeOf<any>();
+  expectTypeOf<typeof readonlyUnknown._output>().toEqualTypeOf<Readonly<unknown>>();
+  expectTypeOf<typeof readonlyVoid._output>().toEqualTypeOf<void>();
+  expectTypeOf<typeof readonlyStringArray._output>().toEqualTypeOf<readonly string[]>();
+  expectTypeOf<typeof readonlyTuple._output>().toEqualTypeOf<readonly [string, number]>();
+  expectTypeOf<typeof readonlyMap._output>().toEqualTypeOf<ReadonlyMap<string, Date>>();
+  expectTypeOf<typeof readonlySet._output>().toEqualTypeOf<ReadonlySet<string>>();
+  expectTypeOf<typeof readonlyStringRecord._output>().toEqualTypeOf<Readonly<Record<string, string>>>();
+  expectTypeOf<typeof readonlyNumberRecord._output>().toEqualTypeOf<Readonly<Record<string, number>>>();
+  expectTypeOf<typeof readonlyObject._output>().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
+  expectTypeOf<typeof readonlyEnum._output>().toEqualTypeOf<Readonly<testEnum>>();
+  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<string>();
+});
+
+// test("deep inference", () => {
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[0]>>().toEqualTypeOf<string>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[1]>>().toEqualTypeOf<number>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[2]>>().toEqualTypeOf<number>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[3]>>().toEqualTypeOf<bigint>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[4]>>().toEqualTypeOf<boolean>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[5]>>().toEqualTypeOf<Date>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[6]>>().toEqualTypeOf<undefined>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[7]>>().toEqualTypeOf<null>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[8]>>().toEqualTypeOf<any>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[9]>
+//   >().toEqualTypeOf<Readonly<unknown>>();
+//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[10]>>().toEqualTypeOf<void>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[11]>
+//   >().toEqualTypeOf<(args_0: string, args_1: number, ...args_2: unknown[]) => unknown>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[12]>
+//   >().toEqualTypeOf<readonly string[]>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[13]>
+//   >().toEqualTypeOf<readonly [string, number]>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[14]>
+//   >().toEqualTypeOf<ReadonlyMap<string, Date>>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[15]>
+//   >().toEqualTypeOf<ReadonlySet<Promise<string>>>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[16]>
+//   >().toEqualTypeOf<Readonly<Record<string, string>>>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[17]>
+//   >().toEqualTypeOf<Readonly<Record<string, number>>>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[18]>
+//   >().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[19]>
+//   >().toEqualTypeOf<Readonly<testEnum>>();
+//   expectTypeOf<
+//     z.infer<(typeof deepReadonlySchemas_0)[20]>
+//   >().toEqualTypeOf<Promise<string>>();
+
+//   expectTypeOf<
+//     z.infer<typeof crazyDeepReadonlySchema>
+//   >().toEqualTypeOf<ReadonlyMap<
+//     ReadonlySet<readonly [string, number]>,
+//     {
+//       readonly a: {
+//         readonly [x: string]: readonly any[];
+//       };
+//       readonly b: {
+//         readonly c: {
+//           readonly d: {
+//             readonly e: {
+//               readonly f: {
+//                 readonly g?: {};
+//               };
+//             };
+//           };
+//         };
+//       };
+//     }
+//   >>();
+// });
+
+test("object freezing", async () => {
+  expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
+  expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
+  expect(
+    Object.isFrozen(
+      z
+        .map(z.string(), z.date())
+        .readonly()
+        .parse(new Map([["a", new Date()]]))
+    )
+  ).toBe(true);
+
+  expect(Object.isFrozen(z.record(z.string(), z.string()).readonly().parse({ a: "b" }))).toBe(true);
+  expect(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
+  expect(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
+  expect(
+    Object.isFrozen(
+      await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")]))
+    )
+  ).toBe(true);
+  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});
+
+test("async object freezing", async () => {
+  expect(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
+  expect(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
+  expect(
+    Object.isFrozen(
+      await z
+        .map(z.string(), z.date())
+        .readonly()
+        .parseAsync(new Map([["a", new Date()]]))
+    )
+  ).toBe(true);
+  expect(
+    Object.isFrozen(
+      await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")]))
+    )
+  ).toBe(true);
+  expect(Object.isFrozen(await z.record(z.string(), z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
+  expect(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
+  expect(
+    Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))
+  ).toBe(true);
+  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});
+
+test("readonly inference", () => {
+  const readonlyStringArray = z.string().array().readonly();
+  const readonlyStringTuple = z.tuple([z.string()]).readonly();
+  const deepReadonly = z.object({ a: z.string() }).readonly();
+
+  type readonlyStringArray = z.infer<typeof readonlyStringArray>;
+  type readonlyStringTuple = z.infer<typeof readonlyStringTuple>;
+  type deepReadonly = z.infer<typeof deepReadonly>;
+
+  expectTypeOf<readonlyStringArray>().toEqualTypeOf<readonly string[]>();
+  expectTypeOf<readonlyStringTuple>().toEqualTypeOf<readonly [string]>();
+  expectTypeOf<deepReadonly>().toEqualTypeOf<{ readonly a: string }>();
+});
+
+test("readonly parse", () => {
+  const schema = z.array(z.string()).readonly();
+  const readonlyArray = ["a", "b", "c"] as const;
+  const mutableArray = ["a", "b", "c"];
+  const result1 = schema.parse(readonlyArray);
+  const result2 = schema.parse(mutableArray);
+  expect(result1).toEqual(readonlyArray);
+  expect(result2).toEqual(mutableArray);
+});
+
+test("readonly parse with tuples", () => {
+  const schema = z.tuple([z.string(), z.number()]).readonly();
+  schema.parse(["a", 1]);
+});
+
+test("readonly and the get method", () => {
+  const readonlyString = z.string().readonly();
+  const readonlyNumber1 = z.number().readonly();
+  const readonlyNumber2 = z.number().readonly();
+  const readonlyBigInt = z.bigint().readonly();
+  const readonlyBoolean = z.boolean().readonly();
+  const readonlyDate = z.date().readonly();
+  const readonlyUndefined = z.undefined().readonly();
+  const readonlyNull = z.null().readonly();
+  const readonlyAny = z.any().readonly();
+  const readonlyUnknown = z.unknown().readonly();
+  const readonlyVoid = z.void().readonly();
+  // const readonlyFunction = z.function(z.tuple([z.string(), z.number()]), z.unknown()).readonly();
+  const readonlyStringArray = z.string().array().readonly();
+  const readonlyTuple = z.tuple([z.string(), z.number()]).readonly();
+
+  expectTypeOf<z.infer<typeof readonlyString>>().toEqualTypeOf<string>();
+  expectTypeOf<z.infer<typeof readonlyNumber1>>().toEqualTypeOf<number>();
+  expectTypeOf<z.infer<typeof readonlyNumber2>>().toEqualTypeOf<number>();
+  expectTypeOf<z.infer<typeof readonlyBigInt>>().toEqualTypeOf<bigint>();
+  expectTypeOf<z.infer<typeof readonlyBoolean>>().toEqualTypeOf<boolean>();
+  expectTypeOf<z.infer<typeof readonlyDate>>().toEqualTypeOf<Date>();
+  expectTypeOf<z.infer<typeof readonlyUndefined>>().toEqualTypeOf<undefined>();
+  expectTypeOf<z.infer<typeof readonlyNull>>().toEqualTypeOf<null>();
+  expectTypeOf<z.infer<typeof readonlyAny>>().toEqualTypeOf<any>();
+  expectTypeOf<z.infer<typeof readonlyUnknown>>().toEqualTypeOf<Readonly<unknown>>();
+  expectTypeOf<z.infer<typeof readonlyVoid>>().toEqualTypeOf<void>();
+  // expectTypeOf<z.infer<typeof readonlyFunction>>().toEqualTypeOf<
+  //   (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
+  // >();
+  expectTypeOf<z.infer<typeof readonlyStringArray>>().toEqualTypeOf<readonly string[]>();
+  expectTypeOf<z.infer<typeof readonlyTuple>>().toEqualTypeOf<readonly [string, number]>();
+
+  expect(readonlyString.parse("asdf")).toEqual("asdf");
+  expect(readonlyNumber1.parse(1234)).toEqual(1234);
+  expect(readonlyNumber2.parse(1234)).toEqual(1234);
+  const bigIntVal = BigInt(1);
+  expect(readonlyBigInt.parse(bigIntVal)).toEqual(bigIntVal);
+  expect(readonlyBoolean.parse(true)).toEqual(true);
+  const dateVal = new Date();
+  expect(readonlyDate.parse(dateVal)).toEqual(dateVal);
+  expect(readonlyUndefined.parse(undefined)).toEqual(undefined);
+  expect(readonlyNull.parse(null)).toEqual(null);
+  expect(readonlyAny.parse("whatever")).toEqual("whatever");
+  expect(readonlyUnknown.parse("whatever")).toEqual("whatever");
+  expect(readonlyVoid.parse(undefined)).toEqual(undefined);
+  // expect(readonlyFunction.parse(() => void 0)).toEqual(() => void 0);
+  expect(readonlyStringArray.parse(["asdf"])).toEqual(["asdf"]);
+  expect(readonlyTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
+});