zod 3.25.4 → 3.25.5

package/dist/commonjs/v4/classic/errors.d.ts

@@ -2,7 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 /** @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;
-/** An Error-like class that doesn't extend `Error`. Used inside safeParse.  */
+/** An Error-like class used to store Zod validation issues.  */
 export interface ZodError<T = unknown> extends $ZodError<T> {
     /** @deprecated Use the `z.treeifyError(err)` function instead. */
     format(): core.$ZodFormattedError<T>;

package/dist/commonjs/v4/classic/errors.js

@@ -38,6 +38,7 @@ const core = __importStar(require("zod/v4/core"));
 const core_1 = require("zod/v4/core");
 const initializer = (inst, issues) => {
     core_1.$ZodError.init(inst, issues);
+    inst.name = "ZodError";
     Object.defineProperties(inst, {
         format: {
             value: (mapper) => core.formatError(inst, mapper),

package/dist/commonjs/v4/classic/parse.d.ts

@@ -1,5 +1,5 @@
 import * as core from "zod/v4/core";
-import { ZodError } from "./errors.js";
+import { type ZodError } from "./errors.js";
 export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 export type ZodSafeParseSuccess<T> = {
     success: true;

package/dist/commonjs/v4/classic/parse.js

@@ -38,5 +38,5 @@ const core = __importStar(require("zod/v4/core"));
 const errors_js_1 = require("./errors.js");
 exports.parse = core._parse(errors_js_1.ZodRealError);
 exports.parseAsync = core._parseAsync(errors_js_1.ZodRealError);
-exports.safeParse = core._safeParse(errors_js_1.ZodError);
-exports.safeParseAsync = core._safeParseAsync(errors_js_1.ZodError);
+exports.safeParse = core._safeParse(errors_js_1.ZodRealError);
+exports.safeParseAsync = core._safeParseAsync(errors_js_1.ZodRealError);

package/dist/commonjs/v4/core/errors.d.ts

@@ -1,7 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type * as util from "./util.js";
+import * as util from "./util.js";
 export interface $ZodIssueBase {
     readonly code?: string;
     readonly input?: unknown;

package/dist/commonjs/v4/core/errors.js

@@ -1,4 +1,37 @@
 "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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$ZodRealError = exports.$ZodError = void 0;
 exports.flattenError = flattenError;
@@ -7,15 +40,26 @@ exports.treeifyError = treeifyError;
 exports.toDotPath = toDotPath;
 exports.prettifyError = prettifyError;
 const core_js_1 = require("./core.js");
+const util = __importStar(require("./util.js"));
 const initializer = (inst, def) => {
+    inst.name = "$ZodError";
     Object.defineProperty(inst, "_zod", {
         value: inst._zod,
         enumerable: false,
     });
     Object.defineProperty(inst, "issues", {
         value: def,
+        enumerable: false,
+    });
+    // inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
+    Object.defineProperty(inst, "message", {
+        get() {
+            return JSON.stringify(def, util.jsonStringifyReplacer, 2);
+        },
         enumerable: true,
+        // configurable: false,
     });
+    // inst.toString = () => inst.message;
     // inst.message = `Invalid input`;
     // Object.defineProperty(inst, "message", {
     //   get() {

package/dist/commonjs/v4/core/parse.js

@@ -80,7 +80,7 @@ const _safeParse = (_Err) => (schema, value, _ctx) => {
         : { success: true, data: result.value };
 };
 exports._safeParse = _safeParse;
-exports.safeParse = (0, exports._safeParse)(errors.$ZodError);
+exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
 const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -94,4 +94,4 @@ const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
         : { success: true, data: result.value };
 };
 exports._safeParseAsync = _safeParseAsync;
-exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodError);
+exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);

package/dist/esm/v4/classic/errors.d.ts

@@ -2,7 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 /** @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;
-/** An Error-like class that doesn't extend `Error`. Used inside safeParse.  */
+/** An Error-like class used to store Zod validation issues.  */
 export interface ZodError<T = unknown> extends $ZodError<T> {
     /** @deprecated Use the `z.treeifyError(err)` function instead. */
     format(): core.$ZodFormattedError<T>;

package/dist/esm/v4/classic/errors.js

@@ -2,6 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 const initializer = (inst, issues) => {
     $ZodError.init(inst, issues);
+    inst.name = "ZodError";
     Object.defineProperties(inst, {
         format: {
             value: (mapper) => core.formatError(inst, mapper),

package/dist/esm/v4/classic/parse.d.ts

@@ -1,5 +1,5 @@
 import * as core from "zod/v4/core";
-import { ZodError } from "./errors.js";
+import { type ZodError } from "./errors.js";
 export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 export type ZodSafeParseSuccess<T> = {
     success: true;

package/dist/esm/v4/classic/parse.js

@@ -1,6 +1,6 @@
 import * as core from "zod/v4/core";
-import { ZodError, ZodRealError } from "./errors.js";
+import { ZodRealError } from "./errors.js";
 export const parse = /* @__PURE__ */ core._parse(ZodRealError);
 export const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);
-export const safeParse = /* @__PURE__ */ core._safeParse(ZodError);
-export const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodError);
+export const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);
+export const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);

package/dist/esm/v4/core/errors.d.ts

@@ -1,7 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type * as util from "./util.js";
+import * as util from "./util.js";
 export interface $ZodIssueBase {
     readonly code?: string;
     readonly input?: unknown;

package/dist/esm/v4/core/errors.js

@@ -1,13 +1,24 @@
 import { $constructor } from "./core.js";
+import * as util from "./util.js";
 const initializer = (inst, def) => {
+    inst.name = "$ZodError";
     Object.defineProperty(inst, "_zod", {
         value: inst._zod,
         enumerable: false,
     });
     Object.defineProperty(inst, "issues", {
         value: def,
+        enumerable: false,
+    });
+    // inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
+    Object.defineProperty(inst, "message", {
+        get() {
+            return JSON.stringify(def, util.jsonStringifyReplacer, 2);
+        },
         enumerable: true,
+        // configurable: false,
     });
+    // inst.toString = () => inst.message;
     // inst.message = `Invalid input`;
     // Object.defineProperty(inst, "message", {
     //   get() {

package/dist/esm/v4/core/parse.js

@@ -41,7 +41,7 @@ export const _safeParse = (_Err) => (schema, value, _ctx) => {
         }
         : { success: true, data: result.value };
 };
-export const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodError);
+export const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
 export const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -54,4 +54,4 @@ export const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
         }
         : { success: true, data: result.value };
 };
-export const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodError);
+export const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);

package/package.json

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

package/src/v4/classic/errors.ts

@@ -4,7 +4,7 @@ import { $ZodError } from "zod/v4/core";
 /** @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;
 
-/** An Error-like class that doesn't extend `Error`. Used inside safeParse.  */
+/** An Error-like class used to store Zod validation issues.  */
 export interface ZodError<T = unknown> extends $ZodError<T> {
   /** @deprecated Use the `z.treeifyError(err)` function instead. */
   format(): core.$ZodFormattedError<T>;
@@ -23,6 +23,7 @@ export interface ZodError<T = unknown> extends $ZodError<T> {
 
 const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
   $ZodError.init(inst, issues);
+  inst.name = "ZodError";
   Object.defineProperties(inst, {
     format: {
       value: (mapper: any) => core.formatError(inst, mapper),

package/src/v4/classic/parse.ts

@@ -1,5 +1,5 @@
 import * as core from "zod/v4/core";
-import { ZodError, ZodRealError } from "./errors.js";
+import { type ZodError, ZodRealError } from "./errors.js";
 
 export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 export type ZodSafeParseSuccess<T> = { success: true; data: T; error?: never };
@@ -24,10 +24,10 @@ export const safeParse: <T extends core.$ZodType>(
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>
   // _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
-) => ZodSafeParseResult<core.output<T>> = /* @__PURE__ */ core._safeParse(ZodError) as any;
+) => ZodSafeParseResult<core.output<T>> = /* @__PURE__ */ core._safeParse(ZodRealError) as any;
 
 export const safeParseAsync: <T extends core.$ZodType>(
   schema: T,
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>
-) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeParseAsync(ZodError) as any;
+) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeParseAsync(ZodRealError) as any;

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

@@ -108,28 +108,26 @@ test("continue parsing despite array size error", () => {
   });
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received number",
-            "path": [
-              "people",
-              0,
-            ],
-          },
-          {
-            "code": "too_small",
-            "message": "Too small: expected array to have >2 items",
-            "minimum": 2,
-            "origin": "array",
-            "path": [
-              "people",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "people",
+          0
         ],
+        "message": "Invalid input: expected string, received number"
       },
+      {
+        "origin": "array",
+        "code": "too_small",
+        "minimum": 2,
+        "path": [
+          "people"
+        ],
+        "message": "Too small: expected array to have >2 items"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -141,34 +139,32 @@ test("parse should fail given sparse array", () => {
   expect(result.success).toEqual(false);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              0,
-            ],
-          },
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              1,
-            ],
-          },
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              2,
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          0
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          1
         ],
+        "message": "Invalid input: expected string, received undefined"
       },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          2
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);

package/src/v4/classic/tests/async-refinements.test.ts

@@ -18,15 +18,13 @@ test("async refine", async () => {
   expect(r2.success).toBe(false);
   expect(r2).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "Invalid input",
-            "path": [],
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -55,15 +53,13 @@ test("async refine that uses value", async () => {
   const r1 = await schema1.safeParseAsync("asdf");
   expect(r1.success).toBe(false);
   expect(r1.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
   `);
 
   const r2 = await schema1.safeParseAsync("asdf123");

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

@@ -230,18 +230,16 @@ test("catch error", () => {
 
   expect(result.success).toEqual(false);
   expect(result.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "number",
-          "message": "Invalid input: expected number, received null",
-          "path": [
-            "age",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          "age"
+        ],
+        "message": "Invalid input: expected number, received null"
+      }
+    ]]
   `);
 });
 

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

@@ -149,19 +149,17 @@ test("invalid discriminator value", () => {
 
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_union",
-            "errors": [],
-            "message": "Invalid input",
-            "note": "No matching discriminator",
-            "path": [
-              "type",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "code": "invalid_union",
+        "errors": [],
+        "note": "No matching discriminator",
+        "path": [
+          "type"
         ],
-      },
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -177,49 +175,47 @@ test("invalid discriminator value - unionFallback", () => {
     .safeParse({ type: "x", a: "abc" });
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_union",
-            "errors": [
-              [
-                {
-                  "code": "invalid_value",
-                  "message": "Invalid input: expected "a"",
-                  "path": [
-                    "type",
-                  ],
-                  "values": [
-                    "a",
-                  ],
-                },
+      "error": [ZodError: [
+      {
+        "code": "invalid_union",
+        "errors": [
+          [
+            {
+              "code": "invalid_value",
+              "values": [
+                "a"
               ],
-              [
-                {
-                  "code": "invalid_value",
-                  "message": "Invalid input: expected "b"",
-                  "path": [
-                    "type",
-                  ],
-                  "values": [
-                    "b",
-                  ],
-                },
-                {
-                  "code": "invalid_type",
-                  "expected": "string",
-                  "message": "Invalid input: expected string, received undefined",
-                  "path": [
-                    "b",
-                  ],
-                },
+              "path": [
+                "type"
               ],
-            ],
-            "message": "Invalid input",
-            "path": [],
-          },
+              "message": "Invalid input: expected \\"a\\""
+            }
+          ],
+          [
+            {
+              "code": "invalid_value",
+              "values": [
+                "b"
+              ],
+              "path": [
+                "type"
+              ],
+              "message": "Invalid input: expected \\"b\\""
+            },
+            {
+              "expected": "string",
+              "code": "invalid_type",
+              "path": [
+                "b"
+              ],
+              "message": "Invalid input: expected string, received undefined"
+            }
+          ]
         ],
-      },
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -244,18 +240,16 @@ test("valid discriminator value, invalid data", () => {
   // ];
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "a",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "a"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -333,18 +327,16 @@ test("async - invalid", async () => {
   //   },
   // ]);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            "a",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "a"
+        ],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]]
   `);
 });
 
@@ -509,19 +501,17 @@ test("single element union", () => {
   expect(result).toMatchObject({ success: false });
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "c",
-              "id",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "c",
+          "id"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);