zod 4.0.7 → 4.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.7",
+  "version": "4.0.9",
   "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/union.test.ts

@@ -134,3 +134,48 @@ test("non-aborted errors", () => {
     }
   `);
 });
+
+test("surface continuable errors only if they exist", () => {
+  const schema = z.union([z.boolean(), z.uuid(), z.jwt()]);
+
+  expect(schema.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "invalid_union",
+        "errors": [
+          [
+            {
+              "expected": "boolean",
+              "code": "invalid_type",
+              "path": [],
+              "message": "Invalid input: expected boolean, received string"
+            }
+          ],
+          [
+            {
+              "origin": "string",
+              "code": "invalid_format",
+              "format": "uuid",
+              "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/",
+              "path": [],
+              "message": "Invalid UUID"
+            }
+          ],
+          [
+            {
+              "code": "invalid_format",
+              "format": "jwt",
+              "path": [],
+              "message": "Invalid JWT"
+            }
+          ]
+        ],
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});

package/src/v4/core/schemas.ts

@@ -1911,7 +1911,7 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
   }
 
   const nonaborted = results.filter((r) => !util.aborted(r));
-  if (nonaborted.length > 0) {
+  if (nonaborted.length === 1) {
     final.value = nonaborted[0].value;
     return nonaborted[0];
   }
@@ -2781,6 +2781,9 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
   "$ZodLiteral",
   (inst, def) => {
     $ZodType.init(inst, def);
+    if (def.values.length === 0) {
+      throw new Error("Cannot create literal schema with no valid values");
+    }
 
     inst._zod.values = new Set<util.Literal>(def.values);
     inst._zod.pattern = new RegExp(

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: 7 as number,
+  patch: 9 as number,
 } as const;

package/v4/core/schemas.cjs

@@ -863,7 +863,7 @@ function handleUnionResults(results, final, inst, ctx) {
         }
     }
     const nonaborted = results.filter((r) => !util.aborted(r));
-    if (nonaborted.length > 0) {
+    if (nonaborted.length === 1) {
         final.value = nonaborted[0].value;
         return nonaborted[0];
     }
@@ -1354,6 +1354,9 @@ exports.$ZodEnum = core.$constructor("$ZodEnum", (inst, def) => {
 });
 exports.$ZodLiteral = core.$constructor("$ZodLiteral", (inst, def) => {
     exports.$ZodType.init(inst, def);
+    if (def.values.length === 0) {
+        throw new Error("Cannot create literal schema with no valid values");
+    }
     inst._zod.values = new Set(def.values);
     inst._zod.pattern = new RegExp(`^(${def.values
         .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))

package/v4/core/schemas.js

@@ -832,7 +832,7 @@ function handleUnionResults(results, final, inst, ctx) {
         }
     }
     const nonaborted = results.filter((r) => !util.aborted(r));
-    if (nonaborted.length > 0) {
+    if (nonaborted.length === 1) {
         final.value = nonaborted[0].value;
         return nonaborted[0];
     }
@@ -1323,6 +1323,9 @@ export const $ZodEnum = /*@__PURE__*/ core.$constructor("$ZodEnum", (inst, def)
 });
 export const $ZodLiteral = /*@__PURE__*/ core.$constructor("$ZodLiteral", (inst, def) => {
     $ZodType.init(inst, def);
+    if (def.values.length === 0) {
+        throw new Error("Cannot create literal schema with no valid values");
+    }
     inst._zod.values = new Set(def.values);
     inst._zod.pattern = new RegExp(`^(${def.values
         .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))

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: 7,
+    patch: 9,
 };

package/v4/core/versions.js

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