zod 3.25.74 → 3.25.76

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

@@ -47,7 +47,7 @@ interface EmitParams {
     | {
         /**  */
         registry: $ZodRegistry<{ id?: string | undefined }>;
-        uri: (id: string) => string;
+        uri?: ((id: string) => string) | undefined;
         defs: Record<string, JSONSchema.BaseSchema>;
       }
     | undefined;
@@ -227,9 +227,10 @@ export class JSONSchemaGenerator {
           case "unknown": {
             break;
           }
-          case "undefined":
-          case "never": {
-            _json.not = {};
+          case "undefined": {
+            if (this.unrepresentable === "throw") {
+              throw new Error("Undefined cannot be represented in JSON Schema");
+            }
             break;
           }
           case "void": {
@@ -238,6 +239,10 @@ export class JSONSchemaGenerator {
             }
             break;
           }
+          case "never": {
+            _json.not = {};
+            break;
+          }
           case "date": {
             if (this.unrepresentable === "throw") {
               throw new Error("Date cannot be represented in JSON Schema");
@@ -609,6 +614,8 @@ export class JSONSchemaGenerator {
     // initialize result with root schema fields
     // Object.assign(result, seen.cached);
 
+    // returns a ref to the schema
+    // defId will be empty if the ref points to an external schema (or #)
     const makeURI = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): { ref: string; defId?: string } => {
       // comparing the seen objects because sometimes
       // multiple schemas map to the same seen object.
@@ -620,12 +627,15 @@ export class JSONSchemaGenerator {
         const externalId = params.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${this.counter++}`;
 
         // check if schema is in the external registry
-        if (externalId) return { ref: params.external.uri(externalId) };
+        const uriGenerator = params.external.uri ?? ((id) => id);
+        if (externalId) {
+          return { ref: uriGenerator(externalId) };
+        }
 
         // otherwise, add to __shared
         const id: string = entry[1].defId ?? (entry[1].schema.id as string) ?? `schema${this.counter++}`;
-        entry[1].defId = id;
-        return { defId: id, ref: `${params.external.uri("__shared")}#/${defsSegment}/${id}` };
+        entry[1].defId = id; // set defId so it will be reused if needed
+        return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
       }
 
       if (entry[1] === root) {
@@ -642,6 +652,7 @@ export class JSONSchemaGenerator {
     // stored cached version in `def` property
     // remove all properties, set $ref
     const extractToDef = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): void => {
+      // if the schema is already a reference, do not extract it
       if (entry[1].schema.$ref) {
         return;
       }
@@ -659,15 +670,29 @@ export class JSONSchemaGenerator {
       schema.$ref = ref;
     };
 
+    // throw on cycles
+
+    // break cycles
+    if (params.cycles === "throw") {
+      for (const entry of this.seen.entries()) {
+        const seen = entry[1];
+        if (seen.cycle) {
+          throw new Error(
+            "Cycle detected: " +
+              `#/${seen.cycle?.join("/")}/<root>` +
+              '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.'
+          );
+        }
+      }
+    }
+
     // extract schemas into $defs
     for (const entry of this.seen.entries()) {
       const seen = entry[1];
 
       // convert root schema to # $ref
-      // also prevents root schema from being extracted
       if (schema === entry[0]) {
-        // do not copy to defs...this is the root schema
-        extractToDef(entry);
+        extractToDef(entry); // this has special handling for the root schema
         continue;
       }
 
@@ -684,21 +709,13 @@ export class JSONSchemaGenerator {
       const id = this.metadataRegistry.get(entry[0])?.id;
       if (id) {
         extractToDef(entry);
-
         continue;
       }
 
       // break cycles
       if (seen.cycle) {
-        if (params.cycles === "throw") {
-          throw new Error(
-            "Cycle detected: " +
-              `#/${seen.cycle?.join("/")}/<root>` +
-              '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.'
-          );
-        } else if (params.cycles === "ref") {
-          extractToDef(entry);
-        }
+        // any
+        extractToDef(entry);
         continue;
       }
 
@@ -763,6 +780,12 @@ export class JSONSchemaGenerator {
       console.warn(`Invalid target: ${this.target}`);
     }
 
+    if (params.external?.uri) {
+      const id = params.external.registry.get(schema)?.id;
+      if (!id) throw new Error("Schema is missing an `id` property");
+      result.$id = params.external.uri(id);
+    }
+
     Object.assign(result, root.def);
 
     // build defs object
@@ -775,11 +798,14 @@ export class JSONSchemaGenerator {
     }
 
     // set definitions in result
-    if (!params.external && Object.keys(defs).length > 0) {
-      if (this.target === "draft-2020-12") {
-        result.$defs = defs;
-      } else {
-        result.definitions = defs;
+    if (params.external) {
+    } else {
+      if (Object.keys(defs).length > 0) {
+        if (this.target === "draft-2020-12") {
+          result.$defs = defs;
+        } else {
+          result.definitions = defs;
+        }
       }
     }
 
@@ -819,7 +845,7 @@ export function toJSONSchema(
     const schemas: Record<string, JSONSchema.BaseSchema> = {};
     const external = {
       registry: input,
-      uri: (_params as RegistryToJSONSchemaParams)?.uri || ((id) => id),
+      uri: (_params as RegistryToJSONSchemaParams)?.uri,
       defs,
     };
     for (const entry of input._idmap.entries()) {

package/v4/classic/schemas.cjs

@@ -1038,10 +1038,10 @@ exports.ZodCustom = core.$constructor("ZodCustom", (inst, def) => {
     exports.ZodType.init(inst, def);
 });
 // custom checks
-function check(fn, params) {
+function check(fn) {
     const ch = new core.$ZodCheck({
         check: "custom",
-        ...index_js_1.util.normalizeParams(params),
+        // ...util.normalizeParams(params),
     });
     ch._zod.check = fn;
     return ch;
@@ -1053,7 +1053,7 @@ function refine(fn, _params = {}) {
     return core._refine(exports.ZodCustom, fn, _params);
 }
 // superRefine
-function superRefine(fn, params) {
+function superRefine(fn) {
     const ch = check((payload) => {
         payload.addIssue = (issue) => {
             if (typeof issue === "string") {
@@ -1072,7 +1072,7 @@ function superRefine(fn, params) {
             }
         };
         return fn(payload.value, payload);
-    }, params);
+    });
     return ch;
 }
 function _instanceof(cls, params = {

package/v4/classic/schemas.d.cts

@@ -602,10 +602,10 @@ export declare function promise<T extends core.SomeType>(innerType: T): ZodPromi
 export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
+export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
-export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>, params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };

package/v4/classic/schemas.d.ts

@@ -602,10 +602,10 @@ export declare function promise<T extends core.SomeType>(innerType: T): ZodPromi
 export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
+export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
-export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>, params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };

package/v4/classic/schemas.js

@@ -935,10 +935,10 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
 });
 // custom checks
-export function check(fn, params) {
+export function check(fn) {
     const ch = new core.$ZodCheck({
         check: "custom",
-        ...util.normalizeParams(params),
+        // ...util.normalizeParams(params),
     });
     ch._zod.check = fn;
     return ch;
@@ -950,7 +950,7 @@ export function refine(fn, _params = {}) {
     return core._refine(ZodCustom, fn, _params);
 }
 // superRefine
-export function superRefine(fn, params) {
+export function superRefine(fn) {
     const ch = check((payload) => {
         payload.addIssue = (issue) => {
             if (typeof issue === "string") {
@@ -969,7 +969,7 @@ export function superRefine(fn, params) {
             }
         };
         return fn(payload.value, payload);
-    }, params);
+    });
     return ch;
 }
 function _instanceof(cls, params = {

package/v4/core/checks.cjs

@@ -248,11 +248,12 @@ exports.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst
     };
 });
 exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -274,11 +275,12 @@ exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) =>
     };
 });
 exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -300,11 +302,12 @@ exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) =>
     };
 });
 exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.size;
@@ -329,11 +332,12 @@ exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, de
     };
 });
 exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -357,11 +361,12 @@ exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def)
     };
 });
 exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -385,11 +390,12 @@ exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def)
     };
 });
 exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.length;

package/v4/core/checks.d.cts

@@ -7,6 +7,8 @@ export interface $ZodCheckDef {
     error?: errors.$ZodErrorMap<never> | undefined;
     /** If true, no later checks will be executed if this check fails. Default `false`. */
     abort?: boolean | undefined;
+    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheckInternals<T> {
     def: $ZodCheckDef;
@@ -14,7 +16,6 @@ export interface $ZodCheckInternals<T> {
     issc?: errors.$ZodIssueBase;
     check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
     onattach: ((schema: schemas.$ZodType) => void)[];
-    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheck<in T = never> {
     _zod: $ZodCheckInternals<T>;

package/v4/core/checks.d.ts

@@ -7,6 +7,8 @@ export interface $ZodCheckDef {
     error?: errors.$ZodErrorMap<never> | undefined;
     /** If true, no later checks will be executed if this check fails. Default `false`. */
     abort?: boolean | undefined;
+    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheckInternals<T> {
     def: $ZodCheckDef;
@@ -14,7 +16,6 @@ export interface $ZodCheckInternals<T> {
     issc?: errors.$ZodIssueBase;
     check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
     onattach: ((schema: schemas.$ZodType) => void)[];
-    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheck<in T = never> {
     _zod: $ZodCheckInternals<T>;

package/v4/core/checks.js

@@ -222,11 +222,12 @@ export const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodCheckB
     };
 });
 export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSize", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -248,11 +249,12 @@ export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSiz
     };
 });
 export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSize", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -274,11 +276,12 @@ export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSiz
     };
 });
 export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.size;
@@ -303,11 +306,12 @@ export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSiz
     };
 });
 export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxLength", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -331,11 +335,12 @@ export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxL
     };
 });
 export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinLength", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -359,11 +364,12 @@ export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinL
     };
 });
 export const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.length;

package/v4/core/errors.cjs

@@ -48,6 +48,10 @@ const initializer = (inst, def) => {
         enumerable: true,
         // configurable: false,
     });
+    Object.defineProperty(inst, "toString", {
+        value: () => inst.message,
+        enumerable: false,
+    });
 };
 exports.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer);
 exports.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer, { Parent: Error });

package/v4/core/errors.js

@@ -17,6 +17,10 @@ const initializer = (inst, def) => {
         enumerable: true,
         // configurable: false,
     });
+    Object.defineProperty(inst, "toString", {
+        value: () => inst.message,
+        enumerable: false,
+    });
 };
 export const $ZodError = $constructor("$ZodError", initializer);
 export const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });

package/v4/core/registries.cjs

@@ -6,7 +6,7 @@ exports.$output = Symbol("ZodOutput");
 exports.$input = Symbol("ZodInput");
 class $ZodRegistry {
     constructor() {
-        this._map = new WeakMap();
+        this._map = new Map();
         this._idmap = new Map();
     }
     add(schema, ..._meta) {
@@ -20,7 +20,16 @@ class $ZodRegistry {
         }
         return this;
     }
+    clear() {
+        this._map = new Map();
+        this._idmap = new Map();
+        return this;
+    }
     remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.delete(meta.id);
+        }
         this._map.delete(schema);
         return this;
     }

package/v4/core/registries.d.cts

@@ -13,9 +13,10 @@ type MetadataType = Record<string, unknown> | undefined;
 export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
     _meta: Meta;
     _schema: Schema;
-    _map: WeakMap<Schema, $replace<Meta, Schema>>;
+    _map: Map<Schema, $replace<Meta, Schema>>;
     _idmap: Map<string, Schema>;
     add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+    clear(): this;
     remove(schema: Schema): this;
     get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
     has(schema: Schema): boolean;

package/v4/core/registries.d.ts

@@ -13,9 +13,10 @@ type MetadataType = Record<string, unknown> | undefined;
 export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
     _meta: Meta;
     _schema: Schema;
-    _map: WeakMap<Schema, $replace<Meta, Schema>>;
+    _map: Map<Schema, $replace<Meta, Schema>>;
     _idmap: Map<string, Schema>;
     add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+    clear(): this;
     remove(schema: Schema): this;
     get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
     has(schema: Schema): boolean;

package/v4/core/registries.js

@@ -2,7 +2,7 @@ export const $output = Symbol("ZodOutput");
 export const $input = Symbol("ZodInput");
 export class $ZodRegistry {
     constructor() {
-        this._map = new WeakMap();
+        this._map = new Map();
         this._idmap = new Map();
     }
     add(schema, ..._meta) {
@@ -16,7 +16,16 @@ export class $ZodRegistry {
         }
         return this;
     }
+    clear() {
+        this._map = new Map();
+        this._idmap = new Map();
+        return this;
+    }
     remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.delete(meta.id);
+        }
         this._map.delete(schema);
         return this;
     }

package/v4/core/schemas.cjs

@@ -65,8 +65,8 @@ exports.$ZodType = core.$constructor("$ZodType", (inst, def) => {
             let isAborted = util.aborted(payload);
             let asyncResult;
             for (const ch of checks) {
-                if (ch._zod.when) {
-                    const shouldRun = ch._zod.when(payload);
+                if (ch._zod.def.when) {
+                    const shouldRun = ch._zod.def.when(payload);
                     if (!shouldRun)
                         continue;
                 }

package/v4/core/schemas.d.cts

@@ -635,6 +635,8 @@ export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right ext
 export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
     def: $ZodIntersectionDef<A, B>;
     isst: never;
+    optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+    optout: A["_zod"]["optout"] | B["_zod"]["optout"];
 }
 export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodIntersectionInternals<A, B>;
@@ -686,6 +688,8 @@ export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Valu
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
     def: $ZodRecordDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export type $partial = {
     "~~partial": true;
@@ -702,6 +706,8 @@ export interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeT
 export interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
     def: $ZodMapDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement<unknown>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodMapInternals<Key, Value>;
@@ -714,6 +720,8 @@ export interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
 export interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
     def: $ZodSetDef<T>;
     isst: errors.$ZodIssueInvalidType;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSetInternals<T>;
@@ -826,6 +834,7 @@ export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeD
 export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodDefaultDef<T>;
     optin: "optional";
+    optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
 }
@@ -842,6 +851,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
 export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "optional";
+    optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
 }
@@ -857,6 +867,8 @@ export interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends
     def: $ZodNonOptionalDef<T>;
     isst: errors.$ZodIssueInvalidType;
     values: T["_zod"]["values"];
+    optin: "optional" | undefined;
+    optout: "optional" | undefined;
 }
 export interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodNonOptionalInternals<T>;
@@ -869,6 +881,8 @@ export interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeD
 export interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {
     def: $ZodSuccessDef<T>;
     isst: never;
+    optin: T["_zod"]["optin"];
+    optout: "optional" | undefined;
 }
 export interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSuccessInternals<T>;