zod 4.0.6 → 4.0.8

package/package.json

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

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

@@ -346,12 +346,6 @@ test("do not continue by default", () => {
         "code": "custom",
         "message": "custom error",
         "path": []
-      },
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected number, received string"
       }
     ]],
       "success": false,

package/src/v4/core/schemas.ts

@@ -3445,7 +3445,7 @@ export const $ZodPipe: core.$constructor<$ZodPipe> = /*@__PURE__*/ core.$constru
 });
 
 function handlePipeResult(left: ParsePayload, def: $ZodPipeDef, ctx: ParseContext) {
-  if (util.aborted(left)) {
+  if (left.issues.length) {
     return left;
   }
   return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);

package/src/v4/core/tests/extend.test.ts

@@ -0,0 +1,18 @@
+import { test } from "vitest";
+import * as z from "zod/v4";
+
+test("extend chaining preserves and overrides properties", () => {
+  const schema1 = z.object({
+    email: z.string(),
+  });
+
+  const schema2 = schema1.extend({
+    email: schema1.shape.email.check(z.email()),
+  });
+
+  const schema3 = schema2.extend({
+    email: schema2.shape.email.or(z.literal("")),
+  });
+
+  schema3.parse({ email: "test@example.com" });
+});

package/src/v4/core/util.ts

@@ -283,10 +283,19 @@ export function assignProp<T extends object, K extends PropertyKey>(
   });
 }
 
+export function mergeDefs(...defs: Record<string, any>[]): any {
+  const mergedDescriptors: Record<string, PropertyDescriptor> = {};
+
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+
+  return Object.defineProperties({}, mergedDescriptors);
+}
+
 export function cloneDef(schema: schemas.$ZodType): any {
-  const def: any = {};
-  Object.defineProperties(def, Object.getOwnPropertyDescriptors(schema._zod.def));
-  return def;
+  return mergeDefs(schema._zod.def);
 }
 
 export function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any {
@@ -545,26 +554,21 @@ export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, big
 export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
   const currDef = schema._zod.def;
 
-  const def = cloneDef(schema);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const newShape: Writeable<schemas.$ZodShape> = {};
-        for (const key in mask) {
-          if (!(key in currDef.shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
-          }
-          if (!mask[key]) continue;
-          newShape[key] = currDef.shape[key]!;
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape: Writeable<schemas.$ZodShape> = {};
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
         }
+        if (!mask[key]) continue;
+        newShape[key] = currDef.shape[key]!;
+      }
 
-        assignProp(this, "shape", newShape); // self-caching
-        return newShape;
-      },
-    },
-    checks: {
-      value: [],
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
     },
+    checks: [],
   });
 
   return clone(schema, def) as any;
@@ -573,26 +577,21 @@ export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>):
 export function omit(schema: schemas.$ZodObject, mask: object): any {
   const currDef = schema._zod.def;
 
-  const def = cloneDef(schema);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
-        for (const key in mask) {
-          if (!(key in currDef.shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
-          }
-          if (!(mask as any)[key]) continue;
-
-          delete newShape[key];
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
         }
-        assignProp(this, "shape", newShape); // self-caching
-        return newShape;
-      },
-    },
-    checks: {
-      value: [],
+        if (!(mask as any)[key]) continue;
+
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
     },
+    checks: [],
   });
 
   return clone(schema, def);
@@ -603,40 +602,28 @@ export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): an
     throw new Error("Invalid input to extend: expected a plain object");
   }
 
-  const def = cloneDef(schema);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const _shape = { ...schema._zod.def.shape, ...shape };
-        assignProp(this, "shape", _shape); // self-caching
-        return _shape;
-      },
-    },
-    checks: {
-      value: [],
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
     },
+    checks: [],
   });
   return clone(schema, def) as any;
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
-  const def = cloneDef(a);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-        assignProp(this, "shape", _shape); // self-caching
-        return _shape;
-      },
+  const def = mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
     },
-    catchall: {
-      get() {
-        return b._zod.def.catchall;
-      },
-    },
-    checks: {
-      value: [], // delete existing checks
+    get catchall() {
+      return b._zod.def.catchall;
     },
+    checks: [], // delete existing checks
   });
 
   return clone(a, def) as any;
@@ -647,46 +634,41 @@ export function partial(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const def = cloneDef(schema);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const oldShape = schema._zod.def.shape;
-        const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-        if (mask) {
-          for (const key in mask) {
-            if (!(key in oldShape)) {
-              throw new Error(`Unrecognized key: "${key}"`);
-            }
-            if (!(mask as any)[key]) continue;
-            // if (oldShape[key]!._zod.optin === "optional") continue;
-            shape[key] = Class
-              ? new Class({
-                  type: "optional",
-                  innerType: oldShape[key]!,
-                })
-              : oldShape[key]!;
-          }
-        } else {
-          for (const key in oldShape) {
-            // if (oldShape[key]!._zod.optin === "optional") continue;
-            shape[key] = Class
-              ? new Class({
-                  type: "optional",
-                  innerType: oldShape[key]!,
-                })
-              : oldShape[key]!;
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in oldShape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
           }
+          if (!(mask as any)[key]) continue;
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class
+            ? new Class({
+                type: "optional",
+                innerType: oldShape[key]!,
+              })
+            : oldShape[key]!;
+        }
+      } else {
+        for (const key in oldShape) {
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class
+            ? new Class({
+                type: "optional",
+                innerType: oldShape[key]!,
+              })
+            : oldShape[key]!;
         }
+      }
 
-        assignProp(this, "shape", shape); // self-caching
-        return shape;
-      },
-    },
-    checks: {
-      value: [],
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
     },
+    checks: [],
   });
 
   return clone(schema, def) as any;
@@ -697,42 +679,37 @@ export function required(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const def = cloneDef(schema);
-  Object.defineProperties(def, {
-    shape: {
-      get() {
-        const oldShape = schema._zod.def.shape;
-        const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-        if (mask) {
-          for (const key in mask) {
-            if (!(key in shape)) {
-              throw new Error(`Unrecognized key: "${key}"`);
-            }
-            if (!(mask as any)[key]) continue;
-            // overwrite with non-optional
-            shape[key] = new Class({
-              type: "nonoptional",
-              innerType: oldShape[key]!,
-            });
-          }
-        } else {
-          for (const key in oldShape) {
-            // overwrite with non-optional
-            shape[key] = new Class({
-              type: "nonoptional",
-              innerType: oldShape[key]!,
-            });
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
           }
+          if (!(mask as any)[key]) continue;
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]!,
+          });
+        }
+      } else {
+        for (const key in oldShape) {
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]!,
+          });
         }
+      }
 
-        assignProp(this, "shape", shape); // self-caching
-        return shape;
-      },
-    },
-    checks: {
-      value: [],
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
     },
+    checks: [],
   });
 
   return clone(schema, def) as any;

package/src/v4/core/versions.ts

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

package/v4/core/schemas.cjs

@@ -1587,7 +1587,7 @@ exports.$ZodPipe = core.$constructor("$ZodPipe", (inst, def) => {
     };
 });
 function handlePipeResult(left, def, ctx) {
-    if (util.aborted(left)) {
+    if (left.issues.length) {
         return left;
     }
     return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);

package/v4/core/schemas.js

@@ -1556,7 +1556,7 @@ export const $ZodPipe = /*@__PURE__*/ core.$constructor("$ZodPipe", (inst, def)
     };
 });
 function handlePipeResult(left, def, ctx) {
-    if (util.aborted(left)) {
+    if (left.issues.length) {
         return left;
     }
     return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);

package/v4/core/util.cjs

@@ -15,6 +15,7 @@ exports.cleanRegex = cleanRegex;
 exports.floatSafeRemainder = floatSafeRemainder;
 exports.defineLazy = defineLazy;
 exports.assignProp = assignProp;
+exports.mergeDefs = mergeDefs;
 exports.cloneDef = cloneDef;
 exports.getElementAtPath = getElementAtPath;
 exports.promiseAllObject = promiseAllObject;
@@ -128,10 +129,16 @@ function assignProp(target, prop, value) {
         configurable: true,
     });
 }
+function mergeDefs(...defs) {
+    const mergedDescriptors = {};
+    for (const def of defs) {
+        const descriptors = Object.getOwnPropertyDescriptors(def);
+        Object.assign(mergedDescriptors, descriptors);
+    }
+    return Object.defineProperties({}, mergedDescriptors);
+}
 function cloneDef(schema) {
-    const def = {};
-    Object.defineProperties(def, Object.getOwnPropertyDescriptors(schema._zod.def));
-    return def;
+    return mergeDefs(schema._zod.def);
 }
 function getElementAtPath(obj, path) {
     if (!path)
@@ -336,51 +343,41 @@ exports.BIGINT_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
     const currDef = schema._zod.def;
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const newShape = {};
-                for (const key in mask) {
-                    if (!(key in currDef.shape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
-                    }
-                    if (!mask[key])
-                        continue;
-                    newShape[key] = currDef.shape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const newShape = {};
+            for (const key in mask) {
+                if (!(key in currDef.shape)) {
+                    throw new Error(`Unrecognized key: "${key}"`);
                 }
-                assignProp(this, "shape", newShape); // self-caching
-                return newShape;
-            },
-        },
-        checks: {
-            value: [],
+                if (!mask[key])
+                    continue;
+                newShape[key] = currDef.shape[key];
+            }
+            assignProp(this, "shape", newShape); // self-caching
+            return newShape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 function omit(schema, mask) {
     const currDef = schema._zod.def;
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const newShape = { ...schema._zod.def.shape };
-                for (const key in mask) {
-                    if (!(key in currDef.shape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
-                    }
-                    if (!mask[key])
-                        continue;
-                    delete newShape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const newShape = { ...schema._zod.def.shape };
+            for (const key in mask) {
+                if (!(key in currDef.shape)) {
+                    throw new Error(`Unrecognized key: "${key}"`);
                 }
-                assignProp(this, "shape", newShape); // self-caching
-                return newShape;
-            },
-        },
-        checks: {
-            value: [],
+                if (!mask[key])
+                    continue;
+                delete newShape[key];
+            }
+            assignProp(this, "shape", newShape); // self-caching
+            return newShape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
@@ -388,123 +385,101 @@ function extend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to extend: expected a plain object");
     }
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const _shape = { ...schema._zod.def.shape, ...shape };
-                assignProp(this, "shape", _shape); // self-caching
-                return _shape;
-            },
-        },
-        checks: {
-            value: [],
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const _shape = { ...schema._zod.def.shape, ...shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 function merge(a, b) {
-    const def = cloneDef(a);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-                assignProp(this, "shape", _shape); // self-caching
-                return _shape;
-            },
+    const def = mergeDefs(a._zod.def, {
+        get shape() {
+            const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
         },
-        catchall: {
-            get() {
-                return b._zod.def.catchall;
-            },
-        },
-        checks: {
-            value: [], // delete existing checks
+        get catchall() {
+            return b._zod.def.catchall;
         },
+        checks: [], // delete existing checks
     });
     return clone(a, def);
 }
 function partial(Class, schema, mask) {
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const oldShape = schema._zod.def.shape;
-                const shape = { ...oldShape };
-                if (mask) {
-                    for (const key in mask) {
-                        if (!(key in oldShape)) {
-                            throw new Error(`Unrecognized key: "${key}"`);
-                        }
-                        if (!mask[key])
-                            continue;
-                        // if (oldShape[key]!._zod.optin === "optional") continue;
-                        shape[key] = Class
-                            ? new Class({
-                                type: "optional",
-                                innerType: oldShape[key],
-                            })
-                            : oldShape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const oldShape = schema._zod.def.shape;
+            const shape = { ...oldShape };
+            if (mask) {
+                for (const key in mask) {
+                    if (!(key in oldShape)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
                     }
+                    if (!mask[key])
+                        continue;
+                    // if (oldShape[key]!._zod.optin === "optional") continue;
+                    shape[key] = Class
+                        ? new Class({
+                            type: "optional",
+                            innerType: oldShape[key],
+                        })
+                        : oldShape[key];
                 }
-                else {
-                    for (const key in oldShape) {
-                        // if (oldShape[key]!._zod.optin === "optional") continue;
-                        shape[key] = Class
-                            ? new Class({
-                                type: "optional",
-                                innerType: oldShape[key],
-                            })
-                            : oldShape[key];
-                    }
+            }
+            else {
+                for (const key in oldShape) {
+                    // if (oldShape[key]!._zod.optin === "optional") continue;
+                    shape[key] = Class
+                        ? new Class({
+                            type: "optional",
+                            innerType: oldShape[key],
+                        })
+                        : oldShape[key];
                 }
-                assignProp(this, "shape", shape); // self-caching
-                return shape;
-            },
-        },
-        checks: {
-            value: [],
+            }
+            assignProp(this, "shape", shape); // self-caching
+            return shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 function required(Class, schema, mask) {
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const oldShape = schema._zod.def.shape;
-                const shape = { ...oldShape };
-                if (mask) {
-                    for (const key in mask) {
-                        if (!(key in shape)) {
-                            throw new Error(`Unrecognized key: "${key}"`);
-                        }
-                        if (!mask[key])
-                            continue;
-                        // overwrite with non-optional
-                        shape[key] = new Class({
-                            type: "nonoptional",
-                            innerType: oldShape[key],
-                        });
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const oldShape = schema._zod.def.shape;
+            const shape = { ...oldShape };
+            if (mask) {
+                for (const key in mask) {
+                    if (!(key in shape)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
                     }
+                    if (!mask[key])
+                        continue;
+                    // overwrite with non-optional
+                    shape[key] = new Class({
+                        type: "nonoptional",
+                        innerType: oldShape[key],
+                    });
                 }
-                else {
-                    for (const key in oldShape) {
-                        // overwrite with non-optional
-                        shape[key] = new Class({
-                            type: "nonoptional",
-                            innerType: oldShape[key],
-                        });
-                    }
+            }
+            else {
+                for (const key in oldShape) {
+                    // overwrite with non-optional
+                    shape[key] = new Class({
+                        type: "nonoptional",
+                        innerType: oldShape[key],
+                    });
                 }
-                assignProp(this, "shape", shape); // self-caching
-                return shape;
-            },
-        },
-        checks: {
-            value: [],
+            }
+            assignProp(this, "shape", shape); // self-caching
+            return shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }

package/v4/core/util.d.cts

@@ -121,6 +121,7 @@ export declare function cleanRegex(source: string): string;
 export declare function floatSafeRemainder(val: number, step: number): number;
 export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
 export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+export declare function mergeDefs(...defs: Record<string, any>[]): any;
 export declare function cloneDef(schema: schemas.$ZodType): any;
 export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
 export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{

package/v4/core/util.d.ts

@@ -121,6 +121,7 @@ export declare function cleanRegex(source: string): string;
 export declare function floatSafeRemainder(val: number, step: number): number;
 export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
 export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+export declare function mergeDefs(...defs: Record<string, any>[]): any;
 export declare function cloneDef(schema: schemas.$ZodType): any;
 export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
 export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{

package/v4/core/util.js

@@ -83,10 +83,16 @@ export function assignProp(target, prop, value) {
         configurable: true,
     });
 }
+export function mergeDefs(...defs) {
+    const mergedDescriptors = {};
+    for (const def of defs) {
+        const descriptors = Object.getOwnPropertyDescriptors(def);
+        Object.assign(mergedDescriptors, descriptors);
+    }
+    return Object.defineProperties({}, mergedDescriptors);
+}
 export function cloneDef(schema) {
-    const def = {};
-    Object.defineProperties(def, Object.getOwnPropertyDescriptors(schema._zod.def));
-    return def;
+    return mergeDefs(schema._zod.def);
 }
 export function getElementAtPath(obj, path) {
     if (!path)
@@ -290,51 +296,41 @@ export const BIGINT_FORMAT_RANGES = {
 };
 export function pick(schema, mask) {
     const currDef = schema._zod.def;
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const newShape = {};
-                for (const key in mask) {
-                    if (!(key in currDef.shape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
-                    }
-                    if (!mask[key])
-                        continue;
-                    newShape[key] = currDef.shape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const newShape = {};
+            for (const key in mask) {
+                if (!(key in currDef.shape)) {
+                    throw new Error(`Unrecognized key: "${key}"`);
                 }
-                assignProp(this, "shape", newShape); // self-caching
-                return newShape;
-            },
-        },
-        checks: {
-            value: [],
+                if (!mask[key])
+                    continue;
+                newShape[key] = currDef.shape[key];
+            }
+            assignProp(this, "shape", newShape); // self-caching
+            return newShape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 export function omit(schema, mask) {
     const currDef = schema._zod.def;
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const newShape = { ...schema._zod.def.shape };
-                for (const key in mask) {
-                    if (!(key in currDef.shape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
-                    }
-                    if (!mask[key])
-                        continue;
-                    delete newShape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const newShape = { ...schema._zod.def.shape };
+            for (const key in mask) {
+                if (!(key in currDef.shape)) {
+                    throw new Error(`Unrecognized key: "${key}"`);
                 }
-                assignProp(this, "shape", newShape); // self-caching
-                return newShape;
-            },
-        },
-        checks: {
-            value: [],
+                if (!mask[key])
+                    continue;
+                delete newShape[key];
+            }
+            assignProp(this, "shape", newShape); // self-caching
+            return newShape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
@@ -342,123 +338,101 @@ export function extend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to extend: expected a plain object");
     }
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const _shape = { ...schema._zod.def.shape, ...shape };
-                assignProp(this, "shape", _shape); // self-caching
-                return _shape;
-            },
-        },
-        checks: {
-            value: [],
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const _shape = { ...schema._zod.def.shape, ...shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 export function merge(a, b) {
-    const def = cloneDef(a);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-                assignProp(this, "shape", _shape); // self-caching
-                return _shape;
-            },
+    const def = mergeDefs(a._zod.def, {
+        get shape() {
+            const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
         },
-        catchall: {
-            get() {
-                return b._zod.def.catchall;
-            },
-        },
-        checks: {
-            value: [], // delete existing checks
+        get catchall() {
+            return b._zod.def.catchall;
         },
+        checks: [], // delete existing checks
     });
     return clone(a, def);
 }
 export function partial(Class, schema, mask) {
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const oldShape = schema._zod.def.shape;
-                const shape = { ...oldShape };
-                if (mask) {
-                    for (const key in mask) {
-                        if (!(key in oldShape)) {
-                            throw new Error(`Unrecognized key: "${key}"`);
-                        }
-                        if (!mask[key])
-                            continue;
-                        // if (oldShape[key]!._zod.optin === "optional") continue;
-                        shape[key] = Class
-                            ? new Class({
-                                type: "optional",
-                                innerType: oldShape[key],
-                            })
-                            : oldShape[key];
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const oldShape = schema._zod.def.shape;
+            const shape = { ...oldShape };
+            if (mask) {
+                for (const key in mask) {
+                    if (!(key in oldShape)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
                     }
+                    if (!mask[key])
+                        continue;
+                    // if (oldShape[key]!._zod.optin === "optional") continue;
+                    shape[key] = Class
+                        ? new Class({
+                            type: "optional",
+                            innerType: oldShape[key],
+                        })
+                        : oldShape[key];
                 }
-                else {
-                    for (const key in oldShape) {
-                        // if (oldShape[key]!._zod.optin === "optional") continue;
-                        shape[key] = Class
-                            ? new Class({
-                                type: "optional",
-                                innerType: oldShape[key],
-                            })
-                            : oldShape[key];
-                    }
+            }
+            else {
+                for (const key in oldShape) {
+                    // if (oldShape[key]!._zod.optin === "optional") continue;
+                    shape[key] = Class
+                        ? new Class({
+                            type: "optional",
+                            innerType: oldShape[key],
+                        })
+                        : oldShape[key];
                 }
-                assignProp(this, "shape", shape); // self-caching
-                return shape;
-            },
-        },
-        checks: {
-            value: [],
+            }
+            assignProp(this, "shape", shape); // self-caching
+            return shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }
 export function required(Class, schema, mask) {
-    const def = cloneDef(schema);
-    Object.defineProperties(def, {
-        shape: {
-            get() {
-                const oldShape = schema._zod.def.shape;
-                const shape = { ...oldShape };
-                if (mask) {
-                    for (const key in mask) {
-                        if (!(key in shape)) {
-                            throw new Error(`Unrecognized key: "${key}"`);
-                        }
-                        if (!mask[key])
-                            continue;
-                        // overwrite with non-optional
-                        shape[key] = new Class({
-                            type: "nonoptional",
-                            innerType: oldShape[key],
-                        });
+    const def = mergeDefs(schema._zod.def, {
+        get shape() {
+            const oldShape = schema._zod.def.shape;
+            const shape = { ...oldShape };
+            if (mask) {
+                for (const key in mask) {
+                    if (!(key in shape)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
                     }
+                    if (!mask[key])
+                        continue;
+                    // overwrite with non-optional
+                    shape[key] = new Class({
+                        type: "nonoptional",
+                        innerType: oldShape[key],
+                    });
                 }
-                else {
-                    for (const key in oldShape) {
-                        // overwrite with non-optional
-                        shape[key] = new Class({
-                            type: "nonoptional",
-                            innerType: oldShape[key],
-                        });
-                    }
+            }
+            else {
+                for (const key in oldShape) {
+                    // overwrite with non-optional
+                    shape[key] = new Class({
+                        type: "nonoptional",
+                        innerType: oldShape[key],
+                    });
                 }
-                assignProp(this, "shape", shape); // self-caching
-                return shape;
-            },
-        },
-        checks: {
-            value: [],
+            }
+            assignProp(this, "shape", shape); // self-caching
+            return shape;
         },
+        checks: [],
     });
     return clone(schema, def);
 }

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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