zod 4.0.5 → 4.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.5",
+  "version": "4.0.6",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",

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

@@ -342,8 +342,8 @@ test("uuid", () => {
   uuid.parse("9491d710-3185-4e06-bea0-6a2f275345e0");
   uuid.parse("d89e7b01-7598-ed11-9d7a-0022489382fd"); // new sequential id
   uuid.parse("00000000-0000-0000-0000-000000000000");
-  uuid.parse("b3ce60f8-e8b9-40f5-1150-172ede56ff74"); // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
-  uuid.parse("92e76bf9-28b3-4730-cd7f-cb6bc51f8c09"); // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
+  uuid.parse("b3ce60f8-e8b9-40f5-1150-172ede56ff74"); // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
+  uuid.parse("92e76bf9-28b3-4730-cd7f-cb6bc51f8c09"); // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
   const result = uuid.safeParse("9491d710-3185-4e06-bea0-6a2f275345e0X");
   expect(result.success).toEqual(false);
   if (!result.success) {

package/src/v3/types.ts

@@ -705,6 +705,7 @@ function isValidJWT(jwt: string, alg?: string): boolean {
       .replace(/-/g, "+")
       .replace(/_/g, "/")
       .padEnd(header.length + ((4 - (header.length % 4)) % 4), "=");
+    // @ts-ignore
     const decoded = JSON.parse(atob(base64));
     if (typeof decoded !== "object" || decoded === null) return false;
     if ("typ" in decoded && decoded?.typ !== "JWT") return false;
@@ -875,6 +876,7 @@ export class ZodString extends ZodType<string, ZodStringDef, string> {
         }
       } else if (check.kind === "url") {
         try {
+          // @ts-ignore
           new URL(input.data);
         } catch {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -2454,7 +2456,7 @@ export class ZodObject<
   Output = objectOutputType<T, Catchall, UnknownKeys>,
   Input = objectInputType<T, Catchall, UnknownKeys>,
 > extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-  private _cached: { shape: T; keys: string[] } | null = null;
+  _cached: { shape: T; keys: string[] } | null = null;
 
   _getCached(): { shape: T; keys: string[] } {
     if (this._cached !== null) return this._cached;

package/src/v4/classic/errors.ts

@@ -1,5 +1,6 @@
 import * as core from "../core/index.js";
 import { $ZodError } from "../core/index.js";
+import * as util from "../core/util.js";
 
 /** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
 export type ZodIssue = core.$ZodIssue;
@@ -34,11 +35,17 @@ const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
       // enumerable: false,
     },
     addIssue: {
-      value: (issue: any) => inst.issues.push(issue),
+      value: (issue: any) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+      },
       // enumerable: false,
     },
     addIssues: {
-      value: (issues: any) => inst.issues.push(...issues),
+      value: (issues: any) => {
+        inst.issues.push(...issues);
+        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+      },
       // enumerable: false,
     },
     isEmpty: {

package/src/v4/classic/schemas.ts

@@ -61,8 +61,6 @@ export interface ZodType<
 
   // refinements
   refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
-  /** @deprecated Use [`.check()`](https://zod.dev/api?id=check) instead.
-   */
   superRefine(
     refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>
   ): this;
@@ -1070,9 +1068,7 @@ export interface ZodObject<
   /** This is the default behavior. This method call is likely unnecessary. */
   strip(): ZodObject<Shape, core.$strip>;
 
-  extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(
-    shape: U
-  ): ZodObject<util.Extend<Shape, U>, Config>;
+  extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
 
   /**
    * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
@@ -1132,7 +1128,6 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
   inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)) as any;
   inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall as any as core.$ZodType }) as any;
   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() });
   inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
   inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
@@ -1224,6 +1219,7 @@ export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[]
   extends ZodUnion<Options>,
     core.$ZodDiscriminatedUnion<Options> {
   _zod: core.$ZodDiscriminatedUnionInternals<Options>;
+  def: core.$ZodDiscriminatedUnionDef<Options>;
 }
 export const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(
   "ZodDiscriminatedUnion",
@@ -1351,9 +1347,11 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends core
   valueType: Value,
   params?: string | core.$ZodRecordParams
 ): ZodRecord<Key & core.$partial, Value> {
+  const k = core.clone(keyType);
+  k._zod.values = undefined;
   return new ZodRecord({
     type: "record",
-    keyType: union([keyType, never()]),
+    keyType: k,
     valueType: valueType as any,
     ...util.normalizeParams(params),
   }) as any;
@@ -1585,7 +1583,7 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
           _issue.code ??= "custom";
           _issue.input ??= payload.value;
           _issue.inst ??= inst;
-          _issue.continue ??= true;
+          // _issue.continue ??= true;
           payload.issues.push(util.issue(_issue));
         }
       };
@@ -1839,12 +1837,16 @@ export function pipe(in_: core.SomeType, out: core.SomeType) {
 // ZodReadonly
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType>
   extends _ZodType<core.$ZodReadonlyInternals<T>>,
-    core.$ZodReadonly<T> {}
+    core.$ZodReadonly<T> {
+  unwrap(): T;
+}
 export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$constructor(
   "ZodReadonly",
   (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
+
+    inst.unwrap = () => inst._zod.def.innerType;
   }
 );
 

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

@@ -1,6 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
-import type { util } from "zod/v4/core";
 
 test("basic catch", () => {
   expect(z.string().catch("default").parse(undefined)).toBe("default");
@@ -45,7 +44,7 @@ test("catch with transform", () => {
   expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
+  expectTypeOf<inp>().toEqualTypeOf<string>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string>();
 });
@@ -59,7 +58,7 @@ test("catch on existing optional", () => {
   expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined | util.Whatever>();
+  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string | undefined>();
 });
@@ -68,7 +67,7 @@ test("optional on catch", () => {
   const stringWithDefault = z.string().catch("asdf").optional();
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
+  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string | undefined>();
 });
@@ -102,7 +101,7 @@ test("nested", () => {
     inner: "asdf",
   });
   type input = z.input<typeof outer>;
-  expectTypeOf<input>().toEqualTypeOf<{ inner: string | util.Whatever } | util.Whatever>();
+  expectTypeOf<input>().toEqualTypeOf<{ inner: string }>();
   type out = z.output<typeof outer>;
 
   expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -646,3 +646,15 @@ test("pipes", () => {
     v: 2,
   });
 });
+
+test("def", () => {
+  const schema = z.discriminatedUnion(
+    "type",
+    [z.object({ type: z.literal("play") }), z.object({ type: z.literal("pause") })],
+    { unionFallback: true }
+  );
+
+  expect(schema.def).toBeDefined();
+  expect(schema.def.discriminator).toEqual("type");
+  expect(schema.def.unionFallback).toEqual(true);
+});

package/src/v4/classic/tests/error-utils.test.ts

@@ -550,3 +550,46 @@ test("disc union treeify/format", () => {
     }
   `);
 });
+
+test("update message after adding issues", () => {
+  const e = new z.ZodError([]);
+  e.addIssue({
+    code: "custom",
+    message: "message",
+    input: "asdf",
+    path: [],
+  });
+  expect(e.message).toMatchInlineSnapshot(`
+    "[
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      }
+    ]"
+  `);
+
+  e.addIssue({
+    code: "custom",
+    message: "message",
+    input: "asdf",
+    path: [],
+  });
+  expect(e.message).toMatchInlineSnapshot(`
+    "[
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      },
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      }
+    ]"
+  `);
+});

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

@@ -90,3 +90,28 @@ test("readonly", () => {
   const a = ["asdf"] as const;
   z.literal(a);
 });
+
+test("literal pattern", () => {
+  expect(z.literal(1.1)._zod.pattern).toMatchInlineSnapshot(`/\\^\\(1\\\\\\.1\\)\\$/`);
+
+  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1.1")).toMatchInlineSnapshot(`
+    {
+      "data": "1.1",
+      "success": true,
+    }
+  `);
+  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1n1")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^(1\\\\.1)$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});

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

@@ -145,3 +145,196 @@ test("partial with mask -- ignore falsy values", async () => {
   masked.parse({ country: "US" });
   await masked.parseAsync({ country: "US" });
 });
+
+test("catch/prefault/default", () => {
+  const mySchema = z.object({
+    a: z.string().catch("catch value").optional(),
+    b: z.string().default("default value").optional(),
+    c: z.string().prefault("prefault value").optional(),
+    d: z.string().catch("catch value"),
+    e: z.string().default("default value"),
+    f: z.string().prefault("prefault value"),
+  });
+
+  expect(mySchema.parse({})).toMatchInlineSnapshot(`
+    {
+      "b": "default value",
+      "c": "prefault value",
+      "d": "catch value",
+      "e": "default value",
+      "f": "prefault value",
+    }
+  `);
+
+  expect(mySchema.parse({}, { jitless: true })).toMatchInlineSnapshot(`
+    {
+      "b": "default value",
+      "c": "prefault value",
+      "d": "catch value",
+      "e": "default value",
+      "f": "prefault value",
+    }
+  `);
+});
+
+test("handleOptionalObjectResult branches", () => {
+  const mySchema = z.object({
+    // Branch: input[key] === undefined, key not in input, caught error
+    caughtMissing: z.string().catch("caught").optional(),
+    // Branch: input[key] === undefined, key in input, caught error
+    caughtUndefined: z.string().catch("caught").optional(),
+    // Branch: input[key] === undefined, key not in input, validation issues
+    issueMissing: z.string().min(5).optional(),
+    // Branch: input[key] === undefined, key in input, validation issues
+    issueUndefined: z.string().min(5).optional(),
+    // Branch: input[key] === undefined, validation returns undefined
+    validUndefined: z.string().optional(),
+    // Branch: input[key] === undefined, non-undefined result (default/transform)
+    defaultValue: z.string().default("default").optional(),
+    // Branch: input[key] defined, caught error
+    caughtDefined: z.string().catch("caught").optional(),
+    // Branch: input[key] defined, validation issues
+    issueDefined: z.string().min(5).optional(),
+    // Branch: input[key] defined, validation returns undefined
+    validDefinedUndefined: z
+      .string()
+      .transform(() => undefined)
+      .optional(),
+    // Branch: input[key] defined, non-undefined value
+    validDefined: z.string().optional(),
+  });
+
+  // Test input[key] === undefined cases
+  const result1 = mySchema.parse(
+    {
+      // caughtMissing: not present (key not in input)
+      caughtUndefined: undefined, // key in input
+      // issueMissing: not present (key not in input)
+      issueUndefined: undefined, // key in input
+      validUndefined: undefined,
+      // defaultValue: not present, will get default
+    },
+    { jitless: true }
+  );
+
+  expect(result1).toEqual({
+    caughtUndefined: undefined,
+    issueUndefined: undefined,
+    validUndefined: undefined,
+    defaultValue: "default",
+  });
+
+  // Test input[key] defined cases (successful)
+  const result2 = mySchema.parse(
+    {
+      caughtDefined: 123, // invalid type, should catch
+      validDefinedUndefined: "test", // transforms to undefined
+      validDefined: "valid", // valid value
+    },
+    { jitless: true }
+  );
+
+  expect(result2).toEqual({
+    caughtDefined: "caught",
+    validDefinedUndefined: undefined,
+    validDefined: "valid",
+    defaultValue: "default",
+  });
+
+  // Test validation issues are properly reported (input[key] defined, validation fails)
+  expect(() =>
+    mySchema.parse(
+      {
+        issueDefined: "abc", // too short
+      },
+      { jitless: true }
+    )
+  ).toThrow();
+});
+
+test("fastpass vs non-fastpass consistency", () => {
+  const mySchema = z.object({
+    caughtMissing: z.string().catch("caught").optional(),
+    caughtUndefined: z.string().catch("caught").optional(),
+    issueMissing: z.string().min(5).optional(),
+    issueUndefined: z.string().min(5).optional(),
+    validUndefined: z.string().optional(),
+    defaultValue: z.string().default("default").optional(),
+    caughtDefined: z.string().catch("caught").optional(),
+    validDefinedUndefined: z
+      .string()
+      .transform(() => undefined)
+      .optional(),
+    validDefined: z.string().optional(),
+  });
+
+  const input = {
+    caughtUndefined: undefined,
+    issueUndefined: undefined,
+    validUndefined: undefined,
+    caughtDefined: 123,
+    validDefinedUndefined: "test",
+    validDefined: "valid",
+  };
+
+  // Test both paths produce identical results
+  const jitlessResult = mySchema.parse(input, { jitless: true });
+  const fastpassResult = mySchema.parse(input);
+
+  expect(jitlessResult).toEqual(fastpassResult);
+  expect(jitlessResult).toEqual({
+    caughtUndefined: undefined,
+    issueUndefined: undefined,
+    validUndefined: undefined,
+    defaultValue: "default",
+    caughtDefined: "caught",
+    validDefinedUndefined: undefined,
+    validDefined: "valid",
+  });
+});
+
+test("optional with check", () => {
+  const baseSchema = z
+    .string()
+    .optional()
+    .check(({ value, ...ctx }) => {
+      ctx.issues.push({
+        code: "custom",
+        input: value,
+        message: "message",
+      });
+    });
+
+  // this correctly fails
+  expect(baseSchema.safeParse(undefined)).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "message",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  const schemaObject = z.object({
+    date: baseSchema,
+  });
+
+  expect(schemaObject.safeParse({ date: undefined })).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "message",
+        "path": [
+          "date"
+        ]
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});

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

@@ -114,14 +114,14 @@ test("pick/omit/required/partial - do not allow unknown keys", () => {
     age: z.number(),
   });
 
-  expect(() => schema.pick({ name: true, asdf: true })).toThrow();
+  expect(() => schema.pick({ name: true, asdf: true }).safeParse({})).toThrow();
 
   // @ts-expect-error
-  expect(() => schema.pick({ $unknown: true })).toThrow();
+  expect(() => schema.pick({ $unknown: true }).safeParse({})).toThrow();
   // @ts-expect-error
-  expect(() => schema.omit({ $unknown: true })).toThrow();
+  expect(() => schema.omit({ $unknown: true }).safeParse({})).toThrow();
   // @ts-expect-error
-  expect(() => schema.required({ $unknown: true })).toThrow();
+  expect(() => schema.required({ $unknown: true }).safeParse({})).toThrow();
   // @ts-expect-error
-  expect(() => schema.partial({ $unknown: true })).toThrow();
+  expect(() => schema.partial({ $unknown: true }).safeParse({})).toThrow();
 });

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

@@ -73,17 +73,18 @@ test("preprocess ctx.addIssue with parse", () => {
   `);
 });
 
-test("preprocess ctx.addIssue non-fatal by default", () => {
+test("preprocess ctx.addIssue fatal by default", () => {
   const schema = z.preprocess((data, ctx) => {
     ctx.addIssue({
       code: "custom",
       message: `custom error`,
     });
+
     return data;
   }, z.string());
   const result = schema.safeParse(1234);
 
-  expect(result.error!.issues).toHaveLength(2);
+  expect(result.error!.issues).toHaveLength(1);
   expect(result).toMatchInlineSnapshot(`
     {
       "error": [ZodError: [
@@ -91,12 +92,6 @@ test("preprocess ctx.addIssue non-fatal by default", () => {
         "code": "custom",
         "message": "custom error",
         "path": []
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received number"
       }
     ]],
       "success": false,
@@ -175,7 +170,7 @@ test("z.NEVER in preprocess", () => {
   expectTypeOf<foo>().toEqualTypeOf<number>();
   const result = foo.safeParse(undefined);
 
-  expect(result.error!.issues).toHaveLength(2);
+  expect(result.error!.issues).toHaveLength(1);
   expect(result).toMatchInlineSnapshot(`
     {
       "error": [ZodError: [
@@ -183,12 +178,6 @@ test("z.NEVER in preprocess", () => {
         "code": "custom",
         "message": "bad",
         "path": []
-      },
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected number, received object"
       }
     ]],
       "success": false,

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

@@ -336,7 +336,21 @@ test("partial record", () => {
   type schema = z.infer<typeof schema>;
   expectTypeOf<schema>().toEqualTypeOf<Partial<Record<string, string>>>();
 
-  const Keys = z.enum(["id", "name", "email"]).or(z.never());
+  const Keys = z.enum(["id", "name", "email"]); //.or(z.never());
   const Person = z.partialRecord(Keys, z.string());
   expectTypeOf<z.infer<typeof Person>>().toEqualTypeOf<Partial<Record<"id" | "name" | "email", string>>>();
+
+  Person.parse({
+    id: "123",
+    // name: "John",
+    // email: "john@example.com",
+  });
+
+  Person.parse({
+    // id: "123",
+    // name: "John",
+    email: "john@example.com",
+  });
+
+  expect(Person.def.keyType._zod.def.type).toEqual("enum");
 });

package/src/v4/classic/tests/recursive-types.test.ts

@@ -260,6 +260,73 @@ test("mutual recursion with meta", () => {
   expectTypeOf<B>().toEqualTypeOf<_B>();
 });
 
+test("object utilities with recursive types", () => {
+  const NodeBase = z.object({
+    id: z.string(),
+    name: z.string(),
+    get children() {
+      return z.array(Node).optional();
+    },
+  });
+
+  // Test extend
+  const NodeOne = NodeBase.extend({
+    name: z.literal("nodeOne"),
+    get children() {
+      return z.array(Node);
+    },
+  });
+
+  const NodeTwo = NodeBase.extend({
+    name: z.literal("nodeTwo"),
+    get children() {
+      return z.array(Node);
+    },
+  });
+
+  // Test pick
+  const PickedNode = NodeBase.pick({ id: true, name: true });
+
+  // Test omit
+  const OmittedNode = NodeBase.omit({ children: true });
+
+  // Test merge
+  const ExtraProps = {
+    metadata: z.string(),
+    get parent() {
+      return Node.optional();
+    },
+  };
+  const MergedNode = NodeBase.extend(ExtraProps);
+
+  // Test partial
+  const PartialNode = NodeBase.partial();
+  const PartialMaskedNode = NodeBase.partial({ name: true });
+
+  // Test required (assuming NodeBase has optional fields)
+  const OptionalNodeBase = z.object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    get children() {
+      return z.array(Node).optional();
+    },
+  });
+  const RequiredNode = OptionalNodeBase.required();
+  const RequiredMaskedNode = OptionalNodeBase.required({ id: true });
+
+  const Node = z.union([
+    NodeOne,
+    NodeTwo,
+    PickedNode,
+    OmittedNode,
+    MergedNode,
+    PartialNode,
+    PartialMaskedNode,
+    RequiredNode,
+    RequiredMaskedNode,
+  ]);
+});
+
 test("recursion compatibility", () => {
   // array
   const A = z.object({