zod 4.2.0-canary.20251118T192410 → 4.2.0-canary.20251202T062120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.2.0-canary.20251118T192410",
+  "version": "4.2.0-canary.20251202T062120",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v3/tests/complex.test.ts

@@ -1,4 +1,4 @@
-import { test } from "vitest";
+import { expect, test } from "vitest";
 import * as z from "zod/v3";
 
 const crazySchema = z.object({
@@ -40,7 +40,7 @@ const crazySchema = z.object({
 // });
 
 test("parse", () => {
-  crazySchema.parse({
+  const input = {
     tuple: ["asdf", 1234, true, null, undefined, "1234"],
     merged: { k1: "asdf", k2: 12 },
     union: ["asdf", 12, "asdf", 12, "asdf", 12],
@@ -52,5 +52,19 @@ test("parse", () => {
     nonstrict: { points: 1234 },
     numProm: Promise.resolve(12),
     lenfun: (x: string) => x.length,
-  });
+  };
+
+  const result = crazySchema.parse(input);
+
+  // Verify the parsed result structure
+  expect(result.tuple).toEqual(input.tuple);
+  expect(result.merged).toEqual(input.merged);
+  expect(result.union).toEqual(input.union);
+  expect(result.array).toEqual(input.array);
+  expect(result.sumMinLength).toEqual(input.sumMinLength);
+  expect(result.intersection).toEqual(input.intersection);
+  expect(result.enum).toEqual(input.enum);
+  expect(result.nonstrict).toEqual(input.nonstrict);
+  expect(result.numProm).toBeInstanceOf(Promise);
+  expect(typeof result.lenfun).toBe("function");
 });

package/src/v3/tests/function.test.ts

@@ -10,7 +10,8 @@ const func1 = z.function(args1, returns1);
 
 test("function parsing", () => {
   const parsed = func1.parse((arg: any) => arg.length);
-  parsed("asdf");
+  const result = parsed("asdf");
+  expect(result).toBe(4);
 });
 
 test("parsed function fail 1", () => {
@@ -226,8 +227,11 @@ test("allow extra parameters", () => {
 test("params and returnType getters", () => {
   const func = z.function().args(z.string()).returns(z.string());
 
-  func.parameters().items[0].parse("asdf");
-  func.returnType().parse("asdf");
+  const paramResult = func.parameters().items[0].parse("asdf");
+  expect(paramResult).toBe("asdf");
+
+  const returnResult = func.returnType().parse("asdf");
+  expect(returnResult).toBe("asdf");
 });
 
 test("inference with transforms", () => {

package/src/v3/tests/nan.test.ts

@@ -6,8 +6,11 @@ import * as z from "zod/v3";
 const schema = z.nan();
 
 test("passing validations", () => {
-  schema.parse(Number.NaN);
-  schema.parse(Number("Not a number"));
+  const result1 = schema.parse(Number.NaN);
+  expect(Number.isNaN(result1)).toBe(true);
+
+  const result2 = schema.parse(Number("Not a number"));
+  expect(Number.isNaN(result2)).toBe(true);
 });
 
 test("failing validations", () => {

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

@@ -607,25 +607,3 @@ test("safeExtend() on object with refinements should not throw", () => {
 
   expect(() => schema.safeExtend({ b: z.string() })).not.toThrow();
 });
-
-test("pick() on object with refinements should throw", () => {
-  const schema = z
-    .object({
-      a: z.string(),
-      b: z.number(),
-    })
-    .refine(() => true);
-
-  expect(() => schema.pick({ a: true })).toThrow("Invalid .pick() on object schemas containing refinements");
-});
-
-test("omit() on object with refinements should throw", () => {
-  const schema = z
-    .object({
-      a: z.string(),
-      b: z.number(),
-    })
-    .refine(() => true);
-
-  expect(() => schema.omit({ b: true })).toThrow("Invalid .omit() on object schemas containing refinements");
-});

package/src/v4/core/util.ts

@@ -199,7 +199,7 @@ export function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<
 export function assertIs<T>(_arg: T): void {}
 
 export function assertNever(_x: never): never {
-  throw new Error();
+  throw new Error("Unexpected value in exhaustive check");
 }
 export function assert<T>(_: any): asserts _ is T {}
 
@@ -592,10 +592,8 @@ export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, big
 
 export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
   const currDef = schema._zod.def;
-  if ((currDef.checks ?? []).length > 0) {
-    throw new Error("Invalid .pick() on object schemas containing refinements");
-  }
-  const def = mergeDefs(currDef, {
+
+  const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape: Writeable<schemas.$ZodShape> = {};
       for (const key in mask) {
@@ -617,13 +615,10 @@ export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>):
 
 export function omit(schema: schemas.$ZodObject, mask: object): any {
   const currDef = schema._zod.def;
-  if ((currDef.checks ?? []).length > 0) {
-    throw new Error("Invalid .omit() on object schemas containing refinements");
-  }
 
-  const def = mergeDefs(currDef, {
+  const def = mergeDefs(schema._zod.def, {
     get shape() {
-      const newShape: Writeable<schemas.$ZodShape> = { ...currDef.shape };
+      const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -649,7 +644,7 @@ export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): an
   const checks = schema._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    throw new Error("Invalid .extend() on object schemas containing refinements. Use .safeExtend() instead.");
+    throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
   }
 
   const def = mergeDefs(schema._zod.def, {

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 1,
-  patch: 12 as number,
+  patch: 13 as number,
 } as const;

package/v4/core/util.cjs

@@ -63,7 +63,7 @@ function assertNotEqual(val) {
 }
 function assertIs(_arg) { }
 function assertNever(_x) {
-    throw new Error();
+    throw new Error("Unexpected value in exhaustive check");
 }
 function assert(_) { }
 function getEnumValues(entries) {
@@ -384,10 +384,7 @@ exports.BIGINT_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
     const currDef = schema._zod.def;
-    if ((currDef.checks ?? []).length > 0) {
-        throw new Error("Invalid .pick() on object schemas containing refinements");
-    }
-    const def = mergeDefs(currDef, {
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
             for (const key in mask) {
@@ -407,12 +404,9 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
     const currDef = schema._zod.def;
-    if ((currDef.checks ?? []).length > 0) {
-        throw new Error("Invalid .omit() on object schemas containing refinements");
-    }
-    const def = mergeDefs(currDef, {
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
-            const newShape = { ...currDef.shape };
+            const newShape = { ...schema._zod.def.shape };
             for (const key in mask) {
                 if (!(key in currDef.shape)) {
                     throw new Error(`Unrecognized key: "${key}"`);
@@ -435,7 +429,7 @@ function extend(schema, shape) {
     const checks = schema._zod.def.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-        throw new Error("Invalid .extend() on object schemas containing refinements. Use .safeExtend() instead.");
+        throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
     }
     const def = mergeDefs(schema._zod.def, {
         get shape() {

package/v4/core/util.js

@@ -7,7 +7,7 @@ export function assertNotEqual(val) {
 }
 export function assertIs(_arg) { }
 export function assertNever(_x) {
-    throw new Error();
+    throw new Error("Unexpected value in exhaustive check");
 }
 export function assert(_) { }
 export function getEnumValues(entries) {
@@ -327,10 +327,7 @@ export const BIGINT_FORMAT_RANGES = {
 };
 export function pick(schema, mask) {
     const currDef = schema._zod.def;
-    if ((currDef.checks ?? []).length > 0) {
-        throw new Error("Invalid .pick() on object schemas containing refinements");
-    }
-    const def = mergeDefs(currDef, {
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
             for (const key in mask) {
@@ -350,12 +347,9 @@ export function pick(schema, mask) {
 }
 export function omit(schema, mask) {
     const currDef = schema._zod.def;
-    if ((currDef.checks ?? []).length > 0) {
-        throw new Error("Invalid .omit() on object schemas containing refinements");
-    }
-    const def = mergeDefs(currDef, {
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
-            const newShape = { ...currDef.shape };
+            const newShape = { ...schema._zod.def.shape };
             for (const key in mask) {
                 if (!(key in currDef.shape)) {
                     throw new Error(`Unrecognized key: "${key}"`);
@@ -378,7 +372,7 @@ export function extend(schema, shape) {
     const checks = schema._zod.def.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-        throw new Error("Invalid .extend() on object schemas containing refinements. Use .safeExtend() instead.");
+        throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
     }
     const def = mergeDefs(schema._zod.def, {
         get shape() {

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 1,
-    patch: 12,
+    patch: 13,
 };

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 1,
-    patch: 12,
+    patch: 13,
 };