zod 3.25.71 → 3.25.73

package/index.cjs

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.z = void 0;
-const z = __importStar(require("./v3/index.cjs"));
+const z = __importStar(require("./v3/external.cjs"));
 exports.z = z;
-__exportStar(require("./v3/index.cjs"), exports);
+__exportStar(require("./v3/external.cjs"), exports);
 exports.default = z;

package/index.d.cts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.cjs";
-export * from "./v3/index.cjs";
+import * as z from "./v3/external.cjs";
+export * from "./v3/external.cjs";
 export { z };
 export default z;

package/index.d.ts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/index.js

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/package.json

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

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/src/v4/classic/schemas.ts

@@ -365,6 +365,8 @@ export const ZodString: core.$constructor<ZodString> = /*@__PURE__*/ core.$const
   inst.duration = (params) => inst.check(iso.duration(params as any));
 });
 
+export function string(params?: string | core.$ZodStringParams): ZodString;
+export function string<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;
 export function string(params?: string | core.$ZodStringParams): ZodString {
   return core._string(ZodString, params) as any;
 }
@@ -1357,11 +1359,11 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends core
   keyType: Key,
   valueType: Value,
   params?: string | core.$ZodRecordParams
-): ZodRecord<ZodUnion<[Key, ZodNever]>, Value> {
+): ZodRecord<Key, ZodOptional<Value>> {
   return new ZodRecord({
     type: "record",
     keyType: union([keyType, never()]),
-    valueType: valueType as any as core.$ZodType,
+    valueType: optional(valueType),
     ...util.normalizeParams(params),
   }) as any;
 }

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

@@ -59,7 +59,5 @@ test("$branded", () => {
 test("branded record", () => {
   const recordWithBrandedNumberKeys = z.record(z.string().brand("SomeBrand"), z.number());
   type recordWithBrandedNumberKeys = z.infer<typeof recordWithBrandedNumberKeys>;
-  expectTypeOf<recordWithBrandedNumberKeys>().toEqualTypeOf<
-    Record<string & z.core.$brand<"SomeBrand">, number | undefined>
-  >();
+  expectTypeOf<recordWithBrandedNumberKeys>().toEqualTypeOf<Record<string & z.core.$brand<"SomeBrand">, number>>();
 });

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -24,6 +24,9 @@ test("_values", () => {
 
   const post = z.literal("test").transform((_) => Math.random());
   expect(post._zod.values).toEqual(new Set(["test"]));
+
+  // Test that readonly literals pass through their values property
+  expect(z.literal("test").readonly()._zod.values).toEqual(new Set(["test"]));
 });
 
 test("valid parse - object", () => {
@@ -590,3 +593,27 @@ test("nested discriminated unions", () => {
     }
   `);
 });
+
+test("readonly literal discriminator", () => {
+  const discUnion = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("a").readonly(), a: z.string() }),
+    z.object({ type: z.literal("b"), b: z.number() }),
+  ]);
+
+  // Test that both discriminator values are correctly included in propValues
+  const propValues = discUnion._zod.propValues;
+  expect(propValues?.type?.has("a")).toBe(true);
+  expect(propValues?.type?.has("b")).toBe(true);
+
+  // Test that the discriminated union works correctly
+  const result1 = discUnion.parse({ type: "a", a: "hello" });
+  expect(result1).toEqual({ type: "a", a: "hello" });
+
+  const result2 = discUnion.parse({ type: "b", b: 42 });
+  expect(result2).toEqual({ type: "b", b: 42 });
+
+  // Test that invalid discriminator values are rejected
+  expect(() => {
+    discUnion.parse({ type: "c", a: "hello" });
+  }).toThrow();
+});

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

@@ -301,7 +301,7 @@ test("z.record", () => {
   // partial enum
   const d = z.record(z.enum(["a", "b"]).or(z.never()), z.string());
   type d = z.output<typeof d>;
-  expectTypeOf<d>().toEqualTypeOf<Partial<Record<"a" | "b", string>>>();
+  expectTypeOf<d>().toEqualTypeOf<Record<"a" | "b", string>>();
 });
 
 test("z.map", () => {

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

@@ -217,6 +217,16 @@ test("test inferred merged type", async () => {
   expectTypeOf<asdf>().toEqualTypeOf<{ a: number }>();
 });
 
+test("inferred type with Record shape", () => {
+  type A = z.ZodObject<Record<string, z.ZodType<string, number>>>;
+  expectTypeOf<z.infer<A>>().toEqualTypeOf<Record<string, string>>();
+  expectTypeOf<z.input<A>>().toEqualTypeOf<Record<string, number>>();
+
+  type B = z.ZodObject;
+  expectTypeOf<z.infer<B>>().toEqualTypeOf<Record<string, unknown>>();
+  expectTypeOf<z.input<B>>().toEqualTypeOf<Record<string, unknown>>();
+});
+
 test("inferred merged object type with optional properties", async () => {
   const Merged = z
     .object({ a: z.string(), b: z.string().optional() })
@@ -549,5 +559,5 @@ test("index signature in shape", () => {
   const schema = makeZodObj("foo");
   type schema = z.infer<typeof schema>;
 
-  expectTypeOf<schema>().toEqualTypeOf<Record<string, unknown>>();
+  expectTypeOf<schema>().toEqualTypeOf<Record<string, string>>();
 });

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

@@ -37,6 +37,26 @@ test("optionality", () => {
   const e = z.string().default("asdf").nullable();
   expect(e._zod.optin).toEqual("optional");
   expect(e._zod.optout).toEqual(undefined);
+
+  // z.undefined should NOT be optional
+  const f = z.undefined();
+  expect(f._zod.optin).toEqual("optional");
+  expect(f._zod.optout).toEqual("optional");
+  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof f._zod.optout>().toEqualTypeOf<"optional" | undefined>();
+
+  // z.union should be optional if any of the types are optional
+  const g = z.union([z.string(), z.undefined()]);
+  expect(g._zod.optin).toEqual("optional");
+  expect(g._zod.optout).toEqual("optional");
+  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();
+
+  const h = z.union([z.string(), z.optional(z.string())]);
+  expect(h._zod.optin).toEqual("optional");
+  expect(h._zod.optout).toEqual("optional");
+  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional">();
+  expectTypeOf<typeof h._zod.optout>().toEqualTypeOf<"optional">();
 });
 
 test("pipe optionality", () => {

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

@@ -17,7 +17,7 @@ test("type inference", () => {
   expectTypeOf<booleanRecord>().toEqualTypeOf<Record<string, boolean>>();
   expectTypeOf<recordWithEnumKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
   expectTypeOf<recordWithLiteralKey>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
-  expectTypeOf<recordWithLiteralUnionKeys>().toEqualTypeOf<Partial<Record<"Tuna" | "Salmon", string>>>();
+  expectTypeOf<recordWithLiteralUnionKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
 });
 
 test("enum exhaustiveness", () => {
@@ -330,3 +330,9 @@ test("async parsing", async () => {
     ]]
   `);
 });
+
+test("partial record", () => {
+  const schema = z.partialRecord(z.string(), z.string());
+  type schema = z.infer<typeof schema>;
+  expectTypeOf<schema>().toEqualTypeOf<Partial<Record<string, string>>>();
+});

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

@@ -160,9 +160,10 @@ test("deferred self-recursion", () => {
   const Output = z.object({
     id: z.int(), //.nonnegative(),
     name: z.string(),
-    features: z.array(Feature), //.array(), // <—
+    get features(): z.ZodArray<typeof Feature> {
+      return Feature.array();
+    },
   });
-
   type Output = z.output<typeof Output>;
 
   type _Feature = {

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -31,7 +31,7 @@ describe("toJSONSchema", () => {
     expect(z.toJSONSchema(z.undefined())).toMatchInlineSnapshot(`
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "type": "null",
+        "not": {},
       }
     `);
     expect(z.toJSONSchema(z.any())).toMatchInlineSnapshot(`
@@ -1259,6 +1259,35 @@ test("override execution order", () => {
   `);
 });
 
+test("override with path", () => {
+  const userSchema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  const capturedPaths: (string | number)[][] = [];
+
+  z.toJSONSchema(userSchema, {
+    override(ctx) {
+      capturedPaths.push(ctx.path);
+    },
+  });
+
+  expect(capturedPaths).toMatchInlineSnapshot(`
+    [
+      [
+        "properties",
+        "age",
+      ],
+      [
+        "properties",
+        "name",
+      ],
+      [],
+    ]
+  `);
+});
+
 test("pipe", () => {
   const mySchema = z
     .string()
@@ -1856,6 +1885,11 @@ test("input type", () => {
     c: z.string().default("hello"),
     d: z.string().nullable(),
     e: z.string().prefault("hello"),
+    f: z.string().catch("hello"),
+    g: z.never(),
+    h: z.undefined(),
+    i: z.union([z.string(), z.number().default(2)]),
+    j: z.union([z.string(), z.string().optional()]),
   });
   expect(z.toJSONSchema(schema, { io: "input" })).toMatchInlineSnapshot(`
     {
@@ -1885,10 +1919,42 @@ test("input type", () => {
           "default": "hello",
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "not": {},
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "j": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "d",
+        "g",
       ],
       "type": "object",
     }
@@ -1921,12 +1987,46 @@ test("input type", () => {
         "e": {
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "not": {},
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "j": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "c",
         "d",
         "e",
+        "f",
+        "g",
+        "i",
       ],
       "type": "object",
     }

package/src/v4/core/schemas.ts

@@ -90,7 +90,7 @@ export interface _$ZodTypeInternals {
   // types: Types;
 
   /** @internal Randomly generated ID for this schema. */
-  id: string;
+  // id: string;
 
   /** @internal List of deferred initializers. */
   deferred: util.AnyFunc[] | undefined;
@@ -171,8 +171,7 @@ export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals>
 
 export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def) => {
   inst ??= {} as any;
-  // avoids issues with using Math.random() in Next.js caching
-  util.defineLazy(inst._zod, "id", () => def.type + "_" + util.randomString(10));
+
   inst._zod.def = def; // set _def property
   inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
   inst._zod.version = version;
@@ -428,7 +427,9 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
     try {
-      const url = new URL(payload.value);
+      const orig = payload.value;
+      const url = new URL(orig);
+      const href = url.href;
 
       if (def.hostname) {
         def.hostname.lastIndex = 0;
@@ -460,6 +461,13 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
         }
       }
 
+      // payload.value = url.href;
+      if (!orig.endsWith("/") && href.endsWith("/")) {
+        payload.value = href.slice(0, -1);
+      } else {
+        payload.value = href;
+      }
+
       return;
     } catch (_) {
       payload.issues.push({
@@ -1238,6 +1246,8 @@ export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ cor
     $ZodType.init(inst, def);
     inst._zod.pattern = regexes.undefined;
     inst._zod.values = new Set([undefined]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
 
     inst._zod.parse = (payload, _ctx) => {
       const input = payload.value;
@@ -1374,7 +1384,6 @@ export interface $ZodNever extends $ZodType {
 
 export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$constructor("$ZodNever", (inst, def) => {
   $ZodType.init(inst, def);
-
   inst._zod.parse = (payload, _ctx) => {
     payload.issues.push({
       expected: "never",
@@ -1488,14 +1497,15 @@ export interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef
   element: T;
 }
 
-export interface $ZodArrayInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<T>[], core.input<T>[]> {
+export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  //$ZodTypeInternals<core.output<T>[], core.input<T>[]> {
   def: $ZodArrayDef<T>;
   isst: errors.$ZodIssueInvalidType;
+  output: core.output<T>[];
+  input: core.input<T>[];
 }
 
-export interface $ZodArray<T extends SomeType = $ZodType>
-  extends $ZodType<core.output<T>[], core.input<T>[], $ZodArrayInternals<T>> {}
+export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
 
 function handleArrayResult(result: ParsePayload<any>, final: ParsePayload<any[]>, index: number) {
   if (result.issues.length) {
@@ -1559,7 +1569,9 @@ type OptionalOutSchema = { _zod: { optout: "optional" } };
 type OptionalInSchema = { _zod: { optin: "optional" } };
 
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
-  ? Record<string, unknown>
+  ? util.IsAny<T[keyof T]> extends true
+    ? Record<string, unknown>
+    : Record<string, core.output<T[keyof T]>>
   : keyof (T & Extra) extends never
     ? Record<string, never>
     : util.Prettify<
@@ -1571,7 +1583,9 @@ export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<st
       >;
 
 export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
-  ? Record<string, unknown>
+  ? util.IsAny<T[keyof T]> extends true
+    ? Record<string, unknown>
+    : Record<string, core.input<T[keyof T]>>
   : keyof (T & Extra) extends never
     ? Record<string, never>
     : util.Prettify<
@@ -1710,8 +1724,9 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
     doc.write(`const input = payload.value;`);
 
     const ids: any = Object.create(null);
+    let counter = 0;
     for (const key of normalized.keys) {
-      ids[key] = util.randomString(15);
+      ids[key] = `key_${counter++}`;
     }
 
     // A: preserve key order {
@@ -1882,14 +1897,23 @@ export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $Zo
   options: Options;
 }
 
-export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]>
-  extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+
+export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
   def: $ZodUnionDef<T>;
   isst: errors.$ZodIssueInvalidUnion;
   pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"]; //GetValues<T[number]>;
+  output: $InferUnionOutput<T[number]>;
+  input: $InferUnionInput<T[number]>;
+  // if any element in the union is optional, then the union is optional
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
 
-export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
+export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]>
+  extends $ZodType<any, any, $ZodUnionInternals<T>> {
   _zod: $ZodUnionInternals<T>;
 }
 
@@ -1914,6 +1938,14 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
 export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$constructor("$ZodUnion", (inst, def) => {
   $ZodType.init(inst, def);
 
+  util.defineLazy(inst._zod, "optin", () =>
+    def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined
+  );
+
+  util.defineLazy(inst._zod, "optout", () =>
+    def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined
+  );
+
   util.defineLazy(inst._zod, "values", () => {
     if (def.options.every((o) => o._zod.values)) {
       return new Set<util.Primitive>(def.options.flatMap((option) => Array.from(option._zod.values!)));
@@ -2354,7 +2386,7 @@ export type $InferZodRecordOutput<
       ? Record<core.output<Key>, core.output<Value>>
       : symbol extends core.output<Key>
         ? Record<core.output<Key>, core.output<Value>>
-        : Partial<Record<core.output<Key>, core.output<Value>>>
+        : Record<core.output<Key>, core.output<Value>>
   : Record<core.output<Key>, core.output<Value>>;
 
 export type $InferZodRecordInput<
@@ -2367,7 +2399,7 @@ export type $InferZodRecordInput<
       ? Record<core.input<Key>, core.input<Value>>
       : symbol extends core.input<Key>
         ? Record<core.input<Key>, core.input<Value>>
-        : Partial<Record<core.input<Key>, core.input<Value>>>
+        : Record<core.input<Key>, core.input<Value>>
   : Record<core.input<Key>, core.input<Value>>;
 
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType>
@@ -3272,7 +3304,7 @@ export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
 
 export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
   $ZodType.init(inst, def);
-  util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  inst._zod.optin = "optional";
   util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 
@@ -3417,6 +3449,7 @@ export interface $ZodReadonlyInternals<T extends SomeType = $ZodType>
   optout: T["_zod"]["optout"];
   isst: never;
   propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
 }
 
 export interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
@@ -3428,6 +3461,7 @@ export const $ZodReadonly: core.$constructor<$ZodReadonly> = /*@__PURE__*/ core.
   (inst, def) => {
     $ZodType.init(inst, def);
     util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+    util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
 

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

@@ -17,9 +17,13 @@ interface JSONSchemaGeneratorParams {
    * - `"any"` — Unrepresentable types become `{}` */
   unrepresentable?: "throw" | "any";
   /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
-  override?: (ctx: { zodSchema: schemas.$ZodTypes; jsonSchema: JSONSchema.BaseSchema }) => void;
+  override?: (ctx: {
+    zodSchema: schemas.$ZodTypes;
+    jsonSchema: JSONSchema.BaseSchema;
+    path: (string | number)[];
+  }) => void;
   /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, Error converting schema to JSONz, defaults, coerced primitives, etc.
-   * - `"output" — Default. Convert the output schema.
+   * - `"output"` — Default. Convert the output schema.
    * - `"input"` — Convert the input schema. */
   io?: "input" | "output";
 }
@@ -61,13 +65,19 @@ interface Seen {
   cycle?: (string | number)[] | undefined;
   isParent?: boolean | undefined;
   ref?: schemas.$ZodType | undefined | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
 }
 
 export class JSONSchemaGenerator {
   metadataRegistry: $ZodRegistry<Record<string, any>>;
   target: "draft-7" | "draft-2020-12";
   unrepresentable: "throw" | "any";
-  override: (ctx: { zodSchema: schemas.$ZodTypes; jsonSchema: JSONSchema.BaseSchema }) => void;
+  override: (ctx: {
+    zodSchema: schemas.$ZodTypes;
+    jsonSchema: JSONSchema.BaseSchema;
+    path: (string | number)[];
+  }) => void;
   io: "input" | "output";
 
   counter = 0;
@@ -110,7 +120,7 @@ export class JSONSchemaGenerator {
     }
 
     // initialize
-    const result: Seen = { schema: {}, count: 1, cycle: undefined };
+    const result: Seen = { schema: {}, count: 1, cycle: undefined, path: _params.path };
     this.seen.set(schema, result);
 
     // custom method overrides default behavior
@@ -207,11 +217,6 @@ export class JSONSchemaGenerator {
             }
             break;
           }
-          case "undefined": {
-            const json = _json as JSONSchema.NullSchema;
-            json.type = "null";
-            break;
-          }
           case "null": {
             _json.type = "null";
             break;
@@ -222,6 +227,7 @@ export class JSONSchemaGenerator {
           case "unknown": {
             break;
           }
+          case "undefined":
           case "never": {
             _json.not = {};
             break;
@@ -740,6 +746,7 @@ export class JSONSchemaGenerator {
         this.override({
           zodSchema: zodSchema as schemas.$ZodTypes,
           jsonSchema: schema,
+          path: seen.path ?? [],
         });
     };