zod 4.0.13 → 4.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.13",
+  "version": "4.0.15",
   "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/classic/tests/to-json-schema.test.ts

@@ -539,6 +539,19 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("number constraints draft-4", () => {
+    expect(z.toJSONSchema(z.number().gt(5).lt(10), { target: "draft-4" })).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema#",
+        "exclusiveMaximum": true,
+        "exclusiveMinimum": true,
+        "maximum": 10,
+        "minimum": 5,
+        "type": "number",
+      }
+    `);
+  });
+
   test("arrays", () => {
     expect(z.toJSONSchema(z.array(z.string()))).toMatchInlineSnapshot(`
       {
@@ -745,6 +758,19 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("literal draft-4", () => {
+    const a = z.literal("hello");
+    expect(z.toJSONSchema(a, { target: "draft-4" })).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema#",
+        "enum": [
+          "hello",
+        ],
+        "type": "string",
+      }
+    `);
+  });
+
   // pipe
   test("pipe", () => {
     const schema = z

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/core.ts

@@ -84,8 +84,8 @@ export class $ZodAsyncError extends Error {
 // export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
 // export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
 // export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
-export type input<T> = T extends { _zod: { input: any } } ? Required<T["_zod"]>["input"] : unknown;
-export type output<T> = T extends { _zod: { output: any } } ? Required<T["_zod"]>["output"] : unknown;
+export type input<T> = T extends { _zod: { input: any } } ? T["_zod"]["input"] : unknown;
+export type output<T> = T extends { _zod: { output: any } } ? T["_zod"]["output"] : unknown;
 
 // Mk2
 // export type input<T> = T extends { _zod: { "~input": any } }

package/src/v4/core/json-schema.ts

@@ -45,7 +45,10 @@ export type Schema =
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
   [k: string]: unknown;
-  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
+  $schema?:
+    | "https://json-schema.org/draft/2020-12/schema"
+    | "http://json-schema.org/draft-07/schema#"
+    | "http://json-schema.org/draft-04/schema#";
   $id?: string;
   $anchor?: string;
   $ref?: string;
@@ -75,9 +78,9 @@ export type JSONSchema = {
   not?: _JSONSchema;
   multipleOf?: number;
   maximum?: number;
-  exclusiveMaximum?: number;
+  exclusiveMaximum?: number | boolean;
   minimum?: number;
-  exclusiveMinimum?: number;
+  exclusiveMinimum?: number | boolean;
   maxLength?: number;
   minLength?: number;
   pattern?: string;

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/to-json-schema.ts

@@ -10,8 +10,9 @@ interface JSONSchemaGeneratorParams {
   metadata?: $ZodRegistry<Record<string, any>>;
   /** The JSON Schema version to target.
    * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
-   * - `"draft-7"` — JSON Schema Draft 7 */
-  target?: "draft-7" | "draft-2020-12";
+   * - `"draft-7"` — JSON Schema Draft 7
+   * - `"draft-4"` — JSON Schema Draft 4 */
+  target?: "draft-4" | "draft-7" | "draft-2020-12";
   /** How to handle unrepresentable types.
    * - `"throw"` — Default. Unrepresentable types throw an error
    * - `"any"` — Unrepresentable types become `{}` */
@@ -71,7 +72,7 @@ interface Seen {
 
 export class JSONSchemaGenerator {
   metadataRegistry: $ZodRegistry<Record<string, any>>;
-  target: "draft-7" | "draft-2020-12";
+  target: "draft-4" | "draft-7" | "draft-2020-12";
   unrepresentable: "throw" | "any";
   override: (ctx: {
     zodSchema: schemas.$ZodTypes;
@@ -163,7 +164,7 @@ export class JSONSchemaGenerator {
               else if (regexes.length > 1) {
                 result.schema.allOf = [
                   ...regexes.map((regex) => ({
-                    ...(this.target === "draft-7" ? ({ type: "string" } as const) : {}),
+                    ...(this.target === "draft-7" || this.target === "draft-4" ? ({ type: "string" } as const) : {}),
                     pattern: regex.source,
                   })),
                 ];
@@ -178,19 +179,33 @@ export class JSONSchemaGenerator {
             if (typeof format === "string" && format.includes("int")) json.type = "integer";
             else json.type = "number";
 
-            if (typeof exclusiveMinimum === "number") json.exclusiveMinimum = exclusiveMinimum;
+            if (typeof exclusiveMinimum === "number") {
+              if (this.target === "draft-4") {
+                json.minimum = exclusiveMinimum;
+                json.exclusiveMinimum = true;
+              } else {
+                json.exclusiveMinimum = exclusiveMinimum;
+              }
+            }
             if (typeof minimum === "number") {
               json.minimum = minimum;
-              if (typeof exclusiveMinimum === "number") {
+              if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
                 if (exclusiveMinimum >= minimum) delete json.minimum;
                 else delete json.exclusiveMinimum;
               }
             }
 
-            if (typeof exclusiveMaximum === "number") json.exclusiveMaximum = exclusiveMaximum;
+            if (typeof exclusiveMaximum === "number") {
+              if (this.target === "draft-4") {
+                json.maximum = exclusiveMaximum;
+                json.exclusiveMaximum = true;
+              } else {
+                json.exclusiveMaximum = exclusiveMaximum;
+              }
+            }
             if (typeof maximum === "number") {
               json.maximum = maximum;
-              if (typeof exclusiveMaximum === "number") {
+              if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
                 if (exclusiveMaximum <= maximum) delete json.maximum;
                 else delete json.exclusiveMaximum;
               }
@@ -379,7 +394,12 @@ export class JSONSchemaGenerator {
           case "record": {
             const json: JSONSchema.ObjectSchema = _json as any;
             json.type = "object";
-            json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+            if (this.target !== "draft-4") {
+              json.propertyNames = this.process(def.keyType, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+              });
+            }
             json.additionalProperties = this.process(def.valueType, {
               ...params,
               path: [...params.path, "additionalProperties"],
@@ -432,7 +452,11 @@ export class JSONSchemaGenerator {
             } else if (vals.length === 1) {
               const val = vals[0]!;
               json.type = val === null ? ("null" as const) : (typeof val as any);
-              json.const = val;
+              if (this.target === "draft-4") {
+                json.enum = [val];
+              } else {
+                json.const = val;
+              }
             } else {
               if (vals.every((v) => typeof v === "number")) json.type = "number";
               if (vals.every((v) => typeof v === "string")) json.type = "string";
@@ -749,7 +773,7 @@ export class JSONSchemaGenerator {
 
         // merge referenced schema into current
         const refSchema = this.seen.get(ref)!.schema;
-        if (refSchema.$ref && params.target === "draft-7") {
+        if (refSchema.$ref && (params.target === "draft-7" || params.target === "draft-4")) {
           schema.allOf = schema.allOf ?? [];
           schema.allOf.push(refSchema);
         } else {
@@ -776,6 +800,8 @@ export class JSONSchemaGenerator {
       result.$schema = "https://json-schema.org/draft/2020-12/schema";
     } else if (this.target === "draft-7") {
       result.$schema = "http://json-schema.org/draft-07/schema#";
+    } else if (this.target === "draft-4") {
+      result.$schema = "http://json-schema.org/draft-04/schema#";
     } else {
       // @ts-ignore
       console.warn(`Invalid target: ${this.target}`);

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: 15 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/core.d.cts

@@ -30,12 +30,12 @@ export type input<T> = T extends {
     _zod: {
         input: any;
     };
-} ? Required<T["_zod"]>["input"] : unknown;
+} ? T["_zod"]["input"] : unknown;
 export type output<T> = T extends {
     _zod: {
         output: any;
     };
-} ? Required<T["_zod"]>["output"] : unknown;
+} ? T["_zod"]["output"] : unknown;
 export type { output as infer };
 export interface $ZodConfig {
     /** Custom error map. Overrides `config().localeError`. */

package/v4/core/core.d.ts

@@ -30,12 +30,12 @@ export type input<T> = T extends {
     _zod: {
         input: any;
     };
-} ? Required<T["_zod"]>["input"] : unknown;
+} ? T["_zod"]["input"] : unknown;
 export type output<T> = T extends {
     _zod: {
         output: any;
     };
-} ? Required<T["_zod"]>["output"] : unknown;
+} ? T["_zod"]["output"] : unknown;
 export type { output as infer };
 export interface $ZodConfig {
     /** Custom error map. Overrides `config().localeError`. */

package/v4/core/json-schema.d.cts

@@ -2,7 +2,7 @@ export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema |
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
     [k: string]: unknown;
-    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
     $id?: string;
     $anchor?: string;
     $ref?: string;
@@ -32,9 +32,9 @@ export type JSONSchema = {
     not?: _JSONSchema;
     multipleOf?: number;
     maximum?: number;
-    exclusiveMaximum?: number;
+    exclusiveMaximum?: number | boolean;
     minimum?: number;
-    exclusiveMinimum?: number;
+    exclusiveMinimum?: number | boolean;
     maxLength?: number;
     minLength?: number;
     pattern?: string;

package/v4/core/json-schema.d.ts

@@ -2,7 +2,7 @@ export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema |
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
     [k: string]: unknown;
-    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
     $id?: string;
     $anchor?: string;
     $ref?: string;
@@ -32,9 +32,9 @@ export type JSONSchema = {
     not?: _JSONSchema;
     multipleOf?: number;
     maximum?: number;
-    exclusiveMaximum?: number;
+    exclusiveMaximum?: number | boolean;
     minimum?: number;
-    exclusiveMinimum?: number;
+    exclusiveMinimum?: number | boolean;
     maxLength?: number;
     minLength?: number;
     pattern?: string;

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/to-json-schema.cjs

@@ -83,7 +83,7 @@ class JSONSchemaGenerator {
                             else if (regexes.length > 1) {
                                 result.schema.allOf = [
                                     ...regexes.map((regex) => ({
-                                        ...(this.target === "draft-7" ? { type: "string" } : {}),
+                                        ...(this.target === "draft-7" || this.target === "draft-4" ? { type: "string" } : {}),
                                         pattern: regex.source,
                                     })),
                                 ];
@@ -98,22 +98,36 @@ class JSONSchemaGenerator {
                             json.type = "integer";
                         else
                             json.type = "number";
-                        if (typeof exclusiveMinimum === "number")
-                            json.exclusiveMinimum = exclusiveMinimum;
+                        if (typeof exclusiveMinimum === "number") {
+                            if (this.target === "draft-4") {
+                                json.minimum = exclusiveMinimum;
+                                json.exclusiveMinimum = true;
+                            }
+                            else {
+                                json.exclusiveMinimum = exclusiveMinimum;
+                            }
+                        }
                         if (typeof minimum === "number") {
                             json.minimum = minimum;
-                            if (typeof exclusiveMinimum === "number") {
+                            if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
                                 if (exclusiveMinimum >= minimum)
                                     delete json.minimum;
                                 else
                                     delete json.exclusiveMinimum;
                             }
                         }
-                        if (typeof exclusiveMaximum === "number")
-                            json.exclusiveMaximum = exclusiveMaximum;
+                        if (typeof exclusiveMaximum === "number") {
+                            if (this.target === "draft-4") {
+                                json.maximum = exclusiveMaximum;
+                                json.exclusiveMaximum = true;
+                            }
+                            else {
+                                json.exclusiveMaximum = exclusiveMaximum;
+                            }
+                        }
                         if (typeof maximum === "number") {
                             json.maximum = maximum;
-                            if (typeof exclusiveMaximum === "number") {
+                            if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
                                 if (exclusiveMaximum <= maximum)
                                     delete json.maximum;
                                 else
@@ -294,7 +308,12 @@ class JSONSchemaGenerator {
                     case "record": {
                         const json = _json;
                         json.type = "object";
-                        json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+                        if (this.target !== "draft-4") {
+                            json.propertyNames = this.process(def.keyType, {
+                                ...params,
+                                path: [...params.path, "propertyNames"],
+                            });
+                        }
                         json.additionalProperties = this.process(def.valueType, {
                             ...params,
                             path: [...params.path, "additionalProperties"],
@@ -354,7 +373,12 @@ class JSONSchemaGenerator {
                         else if (vals.length === 1) {
                             const val = vals[0];
                             json.type = val === null ? "null" : typeof val;
-                            json.const = val;
+                            if (this.target === "draft-4") {
+                                json.enum = [val];
+                            }
+                            else {
+                                json.const = val;
+                            }
                         }
                         else {
                             if (vals.every((v) => typeof v === "number"))
@@ -650,7 +674,7 @@ class JSONSchemaGenerator {
                 flattenRef(ref, params);
                 // merge referenced schema into current
                 const refSchema = this.seen.get(ref).schema;
-                if (refSchema.$ref && params.target === "draft-7") {
+                if (refSchema.$ref && (params.target === "draft-7" || params.target === "draft-4")) {
                     schema.allOf = schema.allOf ?? [];
                     schema.allOf.push(refSchema);
                 }
@@ -677,6 +701,9 @@ class JSONSchemaGenerator {
         else if (this.target === "draft-7") {
             result.$schema = "http://json-schema.org/draft-07/schema#";
         }
+        else if (this.target === "draft-4") {
+            result.$schema = "http://json-schema.org/draft-04/schema#";
+        }
         else {
             // @ts-ignore
             console.warn(`Invalid target: ${this.target}`);

package/v4/core/to-json-schema.d.cts

@@ -7,8 +7,9 @@ interface JSONSchemaGeneratorParams {
     metadata?: $ZodRegistry<Record<string, any>>;
     /** The JSON Schema version to target.
      * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
-     * - `"draft-7"` — JSON Schema Draft 7 */
-    target?: "draft-7" | "draft-2020-12";
+     * - `"draft-7"` — JSON Schema Draft 7
+     * - `"draft-4"` — JSON Schema Draft 4 */
+    target?: "draft-4" | "draft-7" | "draft-2020-12";
     /** How to handle unrepresentable types.
      * - `"throw"` — Default. Unrepresentable types throw an error
      * - `"any"` — Unrepresentable types become `{}` */
@@ -60,7 +61,7 @@ interface Seen {
 }
 export declare class JSONSchemaGenerator {
     metadataRegistry: $ZodRegistry<Record<string, any>>;
-    target: "draft-7" | "draft-2020-12";
+    target: "draft-4" | "draft-7" | "draft-2020-12";
     unrepresentable: "throw" | "any";
     override: (ctx: {
         zodSchema: schemas.$ZodTypes;

package/v4/core/to-json-schema.d.ts

@@ -7,8 +7,9 @@ interface JSONSchemaGeneratorParams {
     metadata?: $ZodRegistry<Record<string, any>>;
     /** The JSON Schema version to target.
      * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
-     * - `"draft-7"` — JSON Schema Draft 7 */
-    target?: "draft-7" | "draft-2020-12";
+     * - `"draft-7"` — JSON Schema Draft 7
+     * - `"draft-4"` — JSON Schema Draft 4 */
+    target?: "draft-4" | "draft-7" | "draft-2020-12";
     /** How to handle unrepresentable types.
      * - `"throw"` — Default. Unrepresentable types throw an error
      * - `"any"` — Unrepresentable types become `{}` */
@@ -60,7 +61,7 @@ interface Seen {
 }
 export declare class JSONSchemaGenerator {
     metadataRegistry: $ZodRegistry<Record<string, any>>;
-    target: "draft-7" | "draft-2020-12";
+    target: "draft-4" | "draft-7" | "draft-2020-12";
     unrepresentable: "throw" | "any";
     override: (ctx: {
         zodSchema: schemas.$ZodTypes;

package/v4/core/to-json-schema.js

@@ -79,7 +79,7 @@ export class JSONSchemaGenerator {
                             else if (regexes.length > 1) {
                                 result.schema.allOf = [
                                     ...regexes.map((regex) => ({
-                                        ...(this.target === "draft-7" ? { type: "string" } : {}),
+                                        ...(this.target === "draft-7" || this.target === "draft-4" ? { type: "string" } : {}),
                                         pattern: regex.source,
                                     })),
                                 ];
@@ -94,22 +94,36 @@ export class JSONSchemaGenerator {
                             json.type = "integer";
                         else
                             json.type = "number";
-                        if (typeof exclusiveMinimum === "number")
-                            json.exclusiveMinimum = exclusiveMinimum;
+                        if (typeof exclusiveMinimum === "number") {
+                            if (this.target === "draft-4") {
+                                json.minimum = exclusiveMinimum;
+                                json.exclusiveMinimum = true;
+                            }
+                            else {
+                                json.exclusiveMinimum = exclusiveMinimum;
+                            }
+                        }
                         if (typeof minimum === "number") {
                             json.minimum = minimum;
-                            if (typeof exclusiveMinimum === "number") {
+                            if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
                                 if (exclusiveMinimum >= minimum)
                                     delete json.minimum;
                                 else
                                     delete json.exclusiveMinimum;
                             }
                         }
-                        if (typeof exclusiveMaximum === "number")
-                            json.exclusiveMaximum = exclusiveMaximum;
+                        if (typeof exclusiveMaximum === "number") {
+                            if (this.target === "draft-4") {
+                                json.maximum = exclusiveMaximum;
+                                json.exclusiveMaximum = true;
+                            }
+                            else {
+                                json.exclusiveMaximum = exclusiveMaximum;
+                            }
+                        }
                         if (typeof maximum === "number") {
                             json.maximum = maximum;
-                            if (typeof exclusiveMaximum === "number") {
+                            if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
                                 if (exclusiveMaximum <= maximum)
                                     delete json.maximum;
                                 else
@@ -290,7 +304,12 @@ export class JSONSchemaGenerator {
                     case "record": {
                         const json = _json;
                         json.type = "object";
-                        json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+                        if (this.target !== "draft-4") {
+                            json.propertyNames = this.process(def.keyType, {
+                                ...params,
+                                path: [...params.path, "propertyNames"],
+                            });
+                        }
                         json.additionalProperties = this.process(def.valueType, {
                             ...params,
                             path: [...params.path, "additionalProperties"],
@@ -350,7 +369,12 @@ export class JSONSchemaGenerator {
                         else if (vals.length === 1) {
                             const val = vals[0];
                             json.type = val === null ? "null" : typeof val;
-                            json.const = val;
+                            if (this.target === "draft-4") {
+                                json.enum = [val];
+                            }
+                            else {
+                                json.const = val;
+                            }
                         }
                         else {
                             if (vals.every((v) => typeof v === "number"))
@@ -646,7 +670,7 @@ export class JSONSchemaGenerator {
                 flattenRef(ref, params);
                 // merge referenced schema into current
                 const refSchema = this.seen.get(ref).schema;
-                if (refSchema.$ref && params.target === "draft-7") {
+                if (refSchema.$ref && (params.target === "draft-7" || params.target === "draft-4")) {
                     schema.allOf = schema.allOf ?? [];
                     schema.allOf.push(refSchema);
                 }
@@ -673,6 +697,9 @@ export class JSONSchemaGenerator {
         else if (this.target === "draft-7") {
             result.$schema = "http://json-schema.org/draft-07/schema#";
         }
+        else if (this.target === "draft-4") {
+            result.$schema = "http://json-schema.org/draft-04/schema#";
+        }
         else {
             // @ts-ignore
             console.warn(`Invalid target: ${this.target}`);

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: 15,
 };

package/v4/core/versions.js

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