zod 4.1.0-canary.20250723T222937 → 4.1.0-canary.20250724T211341

package/package.json

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

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

@@ -1068,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.
@@ -1130,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 });
@@ -1350,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;
@@ -1584,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));
         }
       };
@@ -1838,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/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/file.test.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
 import { File as WebFile } from "@web-std/file";
 
 import { afterEach, beforeEach, expect, test } from "vitest";

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({

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

@@ -318,6 +318,83 @@ test("url validations", () => {
   expect(() => url.parse("https://")).toThrow();
 });
 
+test("url preserves original input", () => {
+  const url = z.string().url();
+
+  // Test the specific case from the user report
+  const input = "https://example.com?key=NUXOmHqWNVTapJkJJHw8BfD155AuqhH_qju_5fNmQ4ZHV7u8";
+  const output = url.parse(input);
+  expect(output).toBe(input); // Should preserve the original input exactly
+
+  // Test other cases where URL constructor would normalize
+  expect(url.parse("https://example.com?foo=bar")).toBe("https://example.com?foo=bar");
+  expect(url.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
+  expect(url.parse("https://sub.example.com?param=value&other=data")).toBe(
+    "https://sub.example.com?param=value&other=data"
+  );
+
+  // Test cases with trailing slashes are preserved
+  expect(url.parse("https://example.com/")).toBe("https://example.com/");
+  expect(url.parse("https://example.com/path/")).toBe("https://example.com/path/");
+
+  // Test cases with paths and query parameters
+  expect(url.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
+});
+
+test("url trims whitespace", () => {
+  const url = z.string().url();
+
+  // Test trimming whitespace from URLs
+  expect(url.parse("  https://example.com  ")).toBe("https://example.com");
+  expect(url.parse("  https://example.com/path?query=param  ")).toBe("https://example.com/path?query=param");
+  expect(url.parse("\t\nhttps://example.com\t\n")).toBe("https://example.com");
+  expect(url.parse("   https://example.com?key=value   ")).toBe("https://example.com?key=value");
+
+  // Test that URLs without extra whitespace are unchanged
+  expect(url.parse("https://example.com")).toBe("https://example.com");
+  expect(url.parse("https://example.com/path")).toBe("https://example.com/path");
+});
+
+test("url normalize flag", () => {
+  const normalizeUrl = z.url({ normalize: true });
+  const preserveUrl = z.url(); // normalize: false/undefined by default
+
+  // Test that normalize flag causes URL normalization
+  expect(normalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
+  expect(normalizeUrl.parse("http://example.com?test=123")).toBe("http://example.com/?test=123");
+
+  // Test with already normalized URLs
+  expect(normalizeUrl.parse("https://example.com/")).toBe("https://example.com/");
+  expect(normalizeUrl.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
+
+  // Test complex URLs with normalization
+  expect(normalizeUrl.parse("https://example.com/../?key=value")).toBe("https://example.com/?key=value");
+  expect(normalizeUrl.parse("https://example.com/./path?key=value")).toBe("https://example.com/path?key=value");
+
+  // Compare with non-normalize behavior
+  expect(preserveUrl.parse("https://example.com?key=value")).toBe("https://example.com?key=value");
+  expect(preserveUrl.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
+
+  // Test trimming with normalize
+  expect(normalizeUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com/?key=value");
+  expect(preserveUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com?key=value");
+});
+
+test("url normalize with hostname and protocol constraints", () => {
+  const constrainedNormalizeUrl = z.url({
+    normalize: true,
+    protocol: /^https$/,
+    hostname: /^example\.com$/,
+  });
+
+  // Test that normalization works with constraints
+  expect(constrainedNormalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
+
+  // Test that constraints are still enforced
+  expect(() => constrainedNormalizeUrl.parse("http://example.com?key=value")).toThrow();
+  expect(() => constrainedNormalizeUrl.parse("https://other.com?key=value")).toThrow();
+});
+
 test("httpurl", () => {
   const httpUrl = z.url({
     protocol: /^https?$/,

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -1952,6 +1952,7 @@ test("input type", () => {
       "required": [
         "a",
         "d",
+        "f",
         "g",
       ],
       "type": "object",