zod 4.5.0 → 4.5.2

package/README.md

@@ -115,8 +115,6 @@ await schema.parseAsync("hello");
 
 ### AOT compilation
 
-**Canary only** — compilation has not shipped in a stable release yet. Install with `npm install zod@canary`.
-
 For hot validation paths, `z.compile(schema)` returns a schema clone with an ahead-of-time compiled fast path. Valid inputs take the compiled path; invalid inputs fall back to the regular parser so error reporting stays identical.
 
 Across a 55-schema benchmark the median speedup is **2.4x**, and it scales with how much work the schema does per parse: a large array of objects is ~9x, a 20-key object ~9x, a nested object ~4.5x, while a bare `z.string()` gains nothing — compilation removes per-node dispatch and allocation, and a single `typeof` has none to remove.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -305,7 +305,7 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
     },
     // `spa` is an alias: same function object as `safeParseAsync`, as before.
     get spa(): ZodType["safeParseAsync"] {
-      return this.safeParseAsync;
+      return this?.safeParseAsync;
     },
     set spa(value: ZodType["safeParseAsync"]) {
       util.own(this, "spa", value);
@@ -334,11 +334,8 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
     async safeDecodeAsync(data, params) {
       return parse.safeDecodeAsync(this, data, params);
     },
-    get toJSONSchema(): ZodType["toJSONSchema"] {
-      return util.own(this, "toJSONSchema", createToJSONSchemaMethod(this, {}));
-    },
-    set toJSONSchema(value: ZodType["toJSONSchema"]) {
-      util.own(this, "toJSONSchema", value);
+    toJSONSchema(params) {
+      return createToJSONSchemaMethod(this, {})(params);
     },
     // Reads through to the registry on every access, so it must not cache.
     get description(): string | undefined {

package/src/v4/classic/tests/detached-methods.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, test, vi } from "vitest";
 import * as z from "zod/v4";
 
 /**
@@ -195,3 +195,27 @@ test("broad sweep: detaching builder methods does not throw or produce a corrupt
 
   expect(broken).toEqual([]);
 });
+
+test("vi.spyOn wraps a prototype method that was never read", () => {
+  const schema = z.object({ a: z.string() });
+  const spy = vi.spyOn(schema, "safeParse").mockReturnValue({ success: true, data: { a: "mocked" } });
+
+  expect(schema.safeParse({})).toEqual({ success: true, data: { a: "mocked" } });
+  expect(spy).toHaveBeenCalledOnce();
+
+  spy.mockRestore();
+  expect(schema.safeParse({ a: "x" })).toEqual({ success: true, data: { a: "x" } });
+  expect(schema.safeParse({}).success).toBe(false);
+
+  const json = vi.spyOn(schema, "toJSONSchema").mockReturnValue({ type: "null" } as any);
+  expect(schema.toJSONSchema()).toEqual({ type: "null" });
+  json.mockRestore();
+  expect(schema.toJSONSchema().type).toBe("object");
+});
+
+test("a getter member answers a bare read without a receiver", () => {
+  const schema = z.string();
+  const get = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(schema), "spa")!.get!;
+  expect(get.call(undefined)).toBeUndefined();
+  expect(schema.spa).toBe(schema.safeParseAsync);
+});

package/src/v4/core/util.ts

@@ -1093,7 +1093,8 @@ function defineBound(proto: object, key: string, fn: AnyFunc): void {
   Object.defineProperty(proto, key, {
     configurable: true,
     get(this: any) {
-      return own(this, key, fn.bind(this));
+      // vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
+      return this == null ? fn : own(this, key, fn.bind(this));
     },
     set(this: any, value: unknown) {
       own(this, key, value);

package/src/v4/core/versions.ts

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

package/v4/classic/schemas.cjs

@@ -270,7 +270,7 @@ exports.ZodType = core.$constructor("ZodType", (inst, def) => {
     },
     // `spa` is an alias: same function object as `safeParseAsync`, as before.
     get spa() {
-        return this.safeParseAsync;
+        return this?.safeParseAsync;
     },
     set spa(value) {
         index_js_1.util.own(this, "spa", value);
@@ -299,11 +299,8 @@ exports.ZodType = core.$constructor("ZodType", (inst, def) => {
     async safeDecodeAsync(data, params) {
         return parse.safeDecodeAsync(this, data, params);
     },
-    get toJSONSchema() {
-        return index_js_1.util.own(this, "toJSONSchema", (0, to_json_schema_js_1.createToJSONSchemaMethod)(this, {}));
-    },
-    set toJSONSchema(value) {
-        index_js_1.util.own(this, "toJSONSchema", value);
+    toJSONSchema(params) {
+        return (0, to_json_schema_js_1.createToJSONSchemaMethod)(this, {})(params);
     },
     // Reads through to the registry on every access, so it must not cache.
     get description() {

package/v4/classic/schemas.js

@@ -144,7 +144,7 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     },
     // `spa` is an alias: same function object as `safeParseAsync`, as before.
     get spa() {
-        return this.safeParseAsync;
+        return this?.safeParseAsync;
     },
     set spa(value) {
         util.own(this, "spa", value);
@@ -173,11 +173,8 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     async safeDecodeAsync(data, params) {
         return parse.safeDecodeAsync(this, data, params);
     },
-    get toJSONSchema() {
-        return util.own(this, "toJSONSchema", createToJSONSchemaMethod(this, {}));
-    },
-    set toJSONSchema(value) {
-        util.own(this, "toJSONSchema", value);
+    toJSONSchema(params) {
+        return createToJSONSchemaMethod(this, {})(params);
     },
     // Reads through to the registry on every access, so it must not cache.
     get description() {

package/v4/core/util.cjs

@@ -813,7 +813,8 @@ function defineBound(proto, key, fn) {
     Object.defineProperty(proto, key, {
         configurable: true,
         get() {
-            return own(this, key, fn.bind(this));
+            // vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
+            return this == null ? fn : own(this, key, fn.bind(this));
         },
         set(value) {
             own(this, key, value);

package/v4/core/util.js

@@ -744,7 +744,8 @@ function defineBound(proto, key, fn) {
     Object.defineProperty(proto, key, {
         configurable: true,
         get() {
-            return own(this, key, fn.bind(this));
+            // vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
+            return this == null ? fn : own(this, key, fn.bind(this));
         },
         set(value) {
             own(this, key, value);

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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