zod 4.1.0-canary.20250730T051934 → 4.1.0-canary.20250804T184136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.1.0-canary.20250730T051934",
+  "version": "4.1.0-canary.20250804T184136",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -1149,7 +1149,7 @@ export function object<T extends core.$ZodLooseShape = Partial<Record<never, cor
   const def: core.$ZodObjectDef = {
     type: "object",
     get shape() {
-      util.assignProp(this, "shape", { ...shape });
+      util.assignProp(this, "shape", shape ? util.objectClone(shape) : {});
       return this.shape;
     },
     ...util.normalizeParams(params),
@@ -1166,7 +1166,7 @@ export function strictObject<T extends core.$ZodLooseShape>(
   return new ZodObject({
     type: "object",
     get shape() {
-      util.assignProp(this, "shape", { ...shape });
+      util.assignProp(this, "shape", util.objectClone(shape));
       return this.shape;
     },
     catchall: never(),
@@ -1183,7 +1183,7 @@ export function looseObject<T extends core.$ZodLooseShape>(
   return new ZodObject({
     type: "object",
     get shape() {
-      util.assignProp(this, "shape", { ...shape });
+      util.assignProp(this, "shape", util.objectClone(shape));
       return this.shape;
     },
     catchall: unknown(),

package/src/v4/classic/tests/recursive-types.test.ts

@@ -366,6 +366,21 @@ test("object utilities with recursive types", () => {
   ]);
 });
 
+test("tuple with recursive types", () => {
+  const TaskListNodeSchema = z.strictObject({
+    type: z.literal("taskList"),
+    get content() {
+      return z.array(z.tuple([TaskListNodeSchema, z.union([TaskListNodeSchema])])).min(1);
+    },
+  });
+  type TaskListNodeSchema = z.infer<typeof TaskListNodeSchema>;
+  type _TaskListNodeSchema = {
+    type: "taskList";
+    content: [_TaskListNodeSchema, _TaskListNodeSchema][];
+  };
+  expectTypeOf<TaskListNodeSchema>().toEqualTypeOf<_TaskListNodeSchema>();
+});
+
 test("recursion compatibility", () => {
   // array
   const A = z.object({
@@ -431,6 +446,68 @@ test("recursion compatibility", () => {
   });
 });
 
+test("recursive object with .check()", () => {
+  const Category = z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      get subcategories() {
+        return z.array(Category).optional();
+      },
+    })
+    .check((ctx) => {
+      // Check for duplicate IDs among direct subcategories
+      if (ctx.value.subcategories) {
+        const siblingIds = new Set<string>();
+        ctx.value.subcategories.forEach((sub, index) => {
+          if (siblingIds.has(sub.id)) {
+            ctx.issues.push({
+              code: "custom",
+              message: `Duplicate sibling ID found: ${sub.id}`,
+              path: ["subcategories", index, "id"],
+              input: ctx.value,
+            });
+          }
+          siblingIds.add(sub.id);
+        });
+      }
+    });
+
+  // Valid - siblings have unique IDs
+  const validData = {
+    id: "electronics",
+    name: "Electronics",
+    subcategories: [
+      {
+        id: "computers",
+        name: "Computers",
+        subcategories: [
+          { id: "laptops", name: "Laptops" },
+          { id: "desktops", name: "Desktops" },
+        ],
+      },
+      {
+        id: "phones",
+        name: "Phones",
+      },
+    ],
+  };
+
+  // Invalid - duplicate sibling IDs
+  const invalidData = {
+    id: "electronics",
+    name: "Electronics",
+    subcategories: [
+      { id: "computers", name: "Computers" },
+      { id: "phones", name: "Phones" },
+      { id: "computers", name: "Computers Again" }, // Duplicate at index 2
+    ],
+  };
+
+  expect(() => Category.parse(validData)).not.toThrow();
+  expect(() => Category.parse(invalidData)).toThrow();
+});
+
 // biome-ignore lint: sadf
 export type RecursiveA = z.ZodUnion<
   [

package/src/v4/core/api.ts

@@ -314,8 +314,8 @@ export function _ksuid<T extends schemas.$ZodKSUID>(
 }
 
 // IPv4
-export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
-export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
 export function _ipv4<T extends schemas.$ZodIPv4>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodIPv4Params | $ZodCheckIPv4Params
@@ -330,8 +330,8 @@ export function _ipv4<T extends schemas.$ZodIPv4>(
 }
 
 // IPv6
-export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
-export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
 export function _ipv6<T extends schemas.$ZodIPv6>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodIPv6Params | $ZodCheckIPv6Params

package/src/v4/core/schemas.ts

@@ -1701,6 +1701,8 @@ export interface $ZodObjectInternals<
   propValues: util.PropValues;
   output: $InferObjectOutput<Shape, Config["out"]>;
   input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
 }
 export type $ZodLooseShape = Record<string, any>;
 
@@ -2282,9 +2284,12 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
 export interface $ZodTupleInternals<
   T extends util.TupleItems = readonly $ZodType[],
   Rest extends SomeType | null = $ZodType | null,
-> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
+> extends _$ZodTypeInternals {
   def: $ZodTupleDef<T, Rest>;
   isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
+  // $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>>
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
 }
 
 export interface $ZodTuple<
@@ -3746,11 +3751,18 @@ export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
 export const $ZodLazy: core.$constructor<$ZodLazy> = /*@__PURE__*/ core.$constructor("$ZodLazy", (inst, def) => {
   $ZodType.init(inst, def);
 
+  // let _innerType!: any;
+  // util.defineLazy(def, "getter", () => {
+  //   if (!_innerType) {
+  //     _innerType = def.getter();
+  //   }
+  //   return () => _innerType;
+  // });
   util.defineLazy(inst._zod, "innerType", () => def.getter() as $ZodType);
   util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
   util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
+  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
   inst._zod.parse = (payload, ctx) => {
     const inner = inst._zod.innerType;
     return inner._zod.run(payload, ctx);

package/src/v4/core/util.ts

@@ -257,16 +257,21 @@ export function floatSafeRemainder(val: number, step: number): number {
   return (valInt % stepInt) / 10 ** decCount;
 }
 
+const EVALUATING = Symbol("evaluating");
+
 export function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void {
-  const set = false;
+  let value: T[K] | typeof EVALUATING | undefined = undefined;
   Object.defineProperty(object, key, {
     get() {
-      if (!set) {
-        const value = getter();
-        object[key] = value;
-        return value;
+      if (value === EVALUATING) {
+        // Circular reference detected, return undefined to break the cycle
+        return undefined as T[K];
       }
-      throw new Error("cached value already set");
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
     },
     set(v) {
       Object.defineProperty(object, key, {
@@ -279,6 +284,10 @@ export function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () =
   });
 }
 
+export function objectClone(obj: object) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+
 export function assignProp<T extends object, K extends PropertyKey>(
   target: T,
   prop: K,

package/src/v4/core/versions.ts

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

package/v4/classic/schemas.cjs

@@ -615,7 +615,7 @@ function object(shape, params) {
     const def = {
         type: "object",
         get shape() {
-            index_js_1.util.assignProp(this, "shape", { ...shape });
+            index_js_1.util.assignProp(this, "shape", shape ? index_js_1.util.objectClone(shape) : {});
             return this.shape;
         },
         ...index_js_1.util.normalizeParams(params),
@@ -627,7 +627,7 @@ function strictObject(shape, params) {
     return new exports.ZodObject({
         type: "object",
         get shape() {
-            index_js_1.util.assignProp(this, "shape", { ...shape });
+            index_js_1.util.assignProp(this, "shape", index_js_1.util.objectClone(shape));
             return this.shape;
         },
         catchall: never(),
@@ -639,7 +639,7 @@ function looseObject(shape, params) {
     return new exports.ZodObject({
         type: "object",
         get shape() {
-            index_js_1.util.assignProp(this, "shape", { ...shape });
+            index_js_1.util.assignProp(this, "shape", index_js_1.util.objectClone(shape));
             return this.shape;
         },
         catchall: unknown(),

package/v4/classic/schemas.js

@@ -509,7 +509,7 @@ export function object(shape, params) {
     const def = {
         type: "object",
         get shape() {
-            util.assignProp(this, "shape", { ...shape });
+            util.assignProp(this, "shape", shape ? util.objectClone(shape) : {});
             return this.shape;
         },
         ...util.normalizeParams(params),
@@ -521,7 +521,7 @@ export function strictObject(shape, params) {
     return new ZodObject({
         type: "object",
         get shape() {
-            util.assignProp(this, "shape", { ...shape });
+            util.assignProp(this, "shape", util.objectClone(shape));
             return this.shape;
         },
         catchall: never(),
@@ -533,7 +533,7 @@ export function looseObject(shape, params) {
     return new ZodObject({
         type: "object",
         get shape() {
-            util.assignProp(this, "shape", { ...shape });
+            util.assignProp(this, "shape", util.objectClone(shape));
             return this.shape;
         },
         catchall: unknown(),

package/v4/core/api.d.cts

@@ -63,11 +63,11 @@ export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<
 export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
 export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
 export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
-export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
-export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
 export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
-export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
-export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
 export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
 export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
 export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;

package/v4/core/api.d.ts

@@ -63,11 +63,11 @@ export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<
 export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
 export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
 export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
-export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
-export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
 export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
-export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
-export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
 export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
 export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
 export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;

package/v4/core/schemas.cjs

@@ -1684,11 +1684,18 @@ exports.$ZodPromise = core.$constructor("$ZodPromise", (inst, def) => {
 });
 exports.$ZodLazy = core.$constructor("$ZodLazy", (inst, def) => {
     exports.$ZodType.init(inst, def);
+    // let _innerType!: any;
+    // util.defineLazy(def, "getter", () => {
+    //   if (!_innerType) {
+    //     _innerType = def.getter();
+    //   }
+    //   return () => _innerType;
+    // });
     util.defineLazy(inst._zod, "innerType", () => def.getter());
     util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
     util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-    util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-    util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+    util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
+    util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
     inst._zod.parse = (payload, ctx) => {
         const inner = inst._zod.innerType;
         return inner._zod.run(payload, ctx);

package/v4/core/schemas.d.cts

@@ -587,6 +587,8 @@ out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends
     propValues: util.PropValues;
     output: $InferObjectOutput<Shape, Config["out"]>;
     input: $InferObjectInput<Shape, Config["in"]>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export type $ZodLooseShape = Record<string, any>;
 export interface $ZodObject<
@@ -673,9 +675,11 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
     ...infer Prefix extends SomeType[],
     infer Tail extends SomeType
 ] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
-export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
+export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
     def: $ZodTupleDef<T, Rest>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
+    output: $InferTupleOutputType<T, Rest>;
+    input: $InferTupleInputType<T, Rest>;
 }
 export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
     _zod: $ZodTupleInternals<T, Rest>;

package/v4/core/schemas.d.ts

@@ -587,6 +587,8 @@ out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends
     propValues: util.PropValues;
     output: $InferObjectOutput<Shape, Config["out"]>;
     input: $InferObjectInput<Shape, Config["in"]>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export type $ZodLooseShape = Record<string, any>;
 export interface $ZodObject<
@@ -673,9 +675,11 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
     ...infer Prefix extends SomeType[],
     infer Tail extends SomeType
 ] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
-export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
+export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
     def: $ZodTupleDef<T, Rest>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
+    output: $InferTupleOutputType<T, Rest>;
+    input: $InferTupleInputType<T, Rest>;
 }
 export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
     _zod: $ZodTupleInternals<T, Rest>;

package/v4/core/schemas.js

@@ -1653,11 +1653,18 @@ export const $ZodPromise = /*@__PURE__*/ core.$constructor("$ZodPromise", (inst,
 });
 export const $ZodLazy = /*@__PURE__*/ core.$constructor("$ZodLazy", (inst, def) => {
     $ZodType.init(inst, def);
+    // let _innerType!: any;
+    // util.defineLazy(def, "getter", () => {
+    //   if (!_innerType) {
+    //     _innerType = def.getter();
+    //   }
+    //   return () => _innerType;
+    // });
     util.defineLazy(inst._zod, "innerType", () => def.getter());
     util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
     util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-    util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-    util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+    util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
+    util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
     inst._zod.parse = (payload, ctx) => {
         const inner = inst._zod.innerType;
         return inner._zod.run(payload, ctx);

package/v4/core/util.cjs

@@ -14,6 +14,7 @@ exports.nullish = nullish;
 exports.cleanRegex = cleanRegex;
 exports.floatSafeRemainder = floatSafeRemainder;
 exports.defineLazy = defineLazy;
+exports.objectClone = objectClone;
 exports.assignProp = assignProp;
 exports.mergeDefs = mergeDefs;
 exports.cloneDef = cloneDef;
@@ -107,16 +108,20 @@ function floatSafeRemainder(val, step) {
     const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
     return (valInt % stepInt) / 10 ** decCount;
 }
+const EVALUATING = Symbol("evaluating");
 function defineLazy(object, key, getter) {
-    const set = false;
+    let value = undefined;
     Object.defineProperty(object, key, {
         get() {
-            if (!set) {
-                const value = getter();
-                object[key] = value;
-                return value;
+            if (value === EVALUATING) {
+                // Circular reference detected, return undefined to break the cycle
+                return undefined;
             }
-            throw new Error("cached value already set");
+            if (value === undefined) {
+                value = EVALUATING;
+                value = getter();
+            }
+            return value;
         },
         set(v) {
             Object.defineProperty(object, key, {
@@ -128,6 +133,9 @@ function defineLazy(object, key, getter) {
         configurable: true,
     });
 }
+function objectClone(obj) {
+    return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
 function assignProp(target, prop, value) {
     Object.defineProperty(target, prop, {
         value,

package/v4/core/util.d.cts

@@ -120,6 +120,7 @@ export declare function nullish(input: any): boolean;
 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 objectClone(obj: object): any;
 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;

package/v4/core/util.d.ts

@@ -120,6 +120,7 @@ export declare function nullish(input: any): boolean;
 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 objectClone(obj: object): any;
 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;

package/v4/core/util.js

@@ -61,16 +61,20 @@ export function floatSafeRemainder(val, step) {
     const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
     return (valInt % stepInt) / 10 ** decCount;
 }
+const EVALUATING = Symbol("evaluating");
 export function defineLazy(object, key, getter) {
-    const set = false;
+    let value = undefined;
     Object.defineProperty(object, key, {
         get() {
-            if (!set) {
-                const value = getter();
-                object[key] = value;
-                return value;
+            if (value === EVALUATING) {
+                // Circular reference detected, return undefined to break the cycle
+                return undefined;
             }
-            throw new Error("cached value already set");
+            if (value === undefined) {
+                value = EVALUATING;
+                value = getter();
+            }
+            return value;
         },
         set(v) {
             Object.defineProperty(object, key, {
@@ -82,6 +86,9 @@ export function defineLazy(object, key, getter) {
         configurable: true,
     });
 }
+export function objectClone(obj) {
+    return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
 export function assignProp(target, prop, value) {
     Object.defineProperty(target, prop, {
         value,

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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