zod 3.25.4 → 3.25.6

package/dist/commonjs/v3/types.d.ts

@@ -654,7 +654,7 @@ export type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAn
 export declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
     static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {

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/v3/types.d.ts

@@ -654,7 +654,7 @@ export type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAn
 export declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
     static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {

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.6",
   "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

@@ -3450,7 +3450,7 @@ export class ZodTuple<
     return this._def.items;
   }
 
-  rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest> {
+  rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema> {
     return new ZodTuple({
       ...this._def,
       rest,

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"
+      }
+    ]]
   `);
 });