zod 4.0.12 → 4.0.14

package/package.json

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

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

@@ -121,3 +121,16 @@ test("pipe optionality inside objects", () => {
     e: string;
   }>();
 });
+
+test("optional prop with pipe", () => {
+  const schema = z.object({
+    id: z
+      .union([z.number(), z.string().nullish()])
+      .transform((val) => (val === null || val === undefined ? val : Number(val)))
+      .pipe(z.number())
+      .optional(),
+  });
+
+  schema.parse({});
+  schema.parse({}, { jitless: true });
+});

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({

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/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<
@@ -3007,6 +3012,13 @@ export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodOptionalInternals<T>;
 }
 
+function handleOptionalResult(result: ParsePayload, input: unknown) {
+  if (result.issues.length && input === undefined) {
+    return { issues: [], value: undefined };
+  }
+  return result;
+}
+
 export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.$constructor(
   "$ZodOptional",
   (inst, def) => {
@@ -3024,7 +3036,9 @@ export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.
 
     inst._zod.parse = (payload, ctx) => {
       if (def.innerType._zod.optin === "optional") {
-        return def.innerType._zod.run(payload, ctx);
+        const result = def.innerType._zod.run(payload, ctx);
+        if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
+        return handleOptionalResult(result, payload.value);
       }
       if (payload.value === undefined) {
         return payload;
@@ -3737,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, {

package/src/v4/core/versions.ts

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

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

@@ -1415,6 +1415,12 @@ exports.$ZodTransform = core.$constructor("$ZodTransform", (inst, def) => {
         return payload;
     };
 });
+function handleOptionalResult(result, input) {
+    if (result.issues.length && input === undefined) {
+        return { issues: [], value: undefined };
+    }
+    return result;
+}
 exports.$ZodOptional = core.$constructor("$ZodOptional", (inst, def) => {
     exports.$ZodType.init(inst, def);
     inst._zod.optin = "optional";
@@ -1428,7 +1434,10 @@ exports.$ZodOptional = core.$constructor("$ZodOptional", (inst, def) => {
     });
     inst._zod.parse = (payload, ctx) => {
         if (def.innerType._zod.optin === "optional") {
-            return def.innerType._zod.run(payload, ctx);
+            const result = def.innerType._zod.run(payload, ctx);
+            if (result instanceof Promise)
+                return result.then((r) => handleOptionalResult(r, payload.value));
+            return handleOptionalResult(result, payload.value);
         }
         if (payload.value === undefined) {
             return payload;
@@ -1675,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

@@ -1384,6 +1384,12 @@ export const $ZodTransform = /*@__PURE__*/ core.$constructor("$ZodTransform", (i
         return payload;
     };
 });
+function handleOptionalResult(result, input) {
+    if (result.issues.length && input === undefined) {
+        return { issues: [], value: undefined };
+    }
+    return result;
+}
 export const $ZodOptional = /*@__PURE__*/ core.$constructor("$ZodOptional", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.optin = "optional";
@@ -1397,7 +1403,10 @@ export const $ZodOptional = /*@__PURE__*/ core.$constructor("$ZodOptional", (ins
     });
     inst._zod.parse = (payload, ctx) => {
         if (def.innerType._zod.optin === "optional") {
-            return def.innerType._zod.run(payload, ctx);
+            const result = def.innerType._zod.run(payload, ctx);
+            if (result instanceof Promise)
+                return result.then((r) => handleOptionalResult(r, payload.value));
+            return handleOptionalResult(result, payload.value);
         }
         if (payload.value === undefined) {
             return payload;
@@ -1644,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

@@ -107,16 +107,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, {

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, {

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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