zod 4.5.3 → 4.6.0

package/v4/core/json-schema-processors.cjs

@@ -23,11 +23,106 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allProcessors = exports.lazyProcessor = exports.optionalProcessor = exports.promiseProcessor = exports.readonlyProcessor = exports.pipeProcessor = exports.catchProcessor = exports.prefaultProcessor = exports.defaultProcessor = exports.nonoptionalProcessor = exports.nullableProcessor = exports.recordProcessor = exports.tupleProcessor = exports.intersectionProcessor = exports.unionProcessor = exports.objectProcessor = exports.arrayProcessor = exports.setProcessor = exports.mapProcessor = exports.transformProcessor = exports.functionProcessor = exports.customProcessor = exports.successProcessor = exports.fileProcessor = exports.templateLiteralProcessor = exports.nanProcessor = exports.literalProcessor = exports.enumProcessor = exports.dateProcessor = exports.unknownProcessor = exports.anyProcessor = exports.neverProcessor = exports.voidProcessor = exports.undefinedProcessor = exports.nullProcessor = exports.symbolProcessor = exports.bigintProcessor = exports.booleanProcessor = exports.numberProcessor = exports.stringProcessor = void 0;
+exports.allProcessors = exports.lazyProcessor = exports.optionalProcessor = exports.promiseProcessor = exports.readonlyProcessor = exports.pipeProcessor = exports.catchProcessor = exports.prefaultProcessor = exports.defaultProcessor = exports.nonoptionalProcessor = exports.nullableProcessor = exports.recordProcessor = exports.tupleProcessor = exports.intersectionProcessor = exports.unionProcessor = exports.propertiesProcessor = exports.objectProcessor = exports.arrayProcessor = exports.setProcessor = exports.mapProcessor = exports.transformProcessor = exports.functionProcessor = exports.customProcessor = exports.successProcessor = exports.fileProcessor = exports.templateLiteralProcessor = exports.nanProcessor = exports.literalProcessor = exports.enumProcessor = exports.dateProcessor = exports.unknownProcessor = exports.anyProcessor = exports.neverProcessor = exports.voidProcessor = exports.undefinedProcessor = exports.nullProcessor = exports.symbolProcessor = exports.bigintProcessor = exports.booleanProcessor = exports.numberProcessor = exports.stringProcessor = void 0;
+exports.aggregateChecks = aggregateChecks;
 exports.toJSONSchema = toJSONSchema;
 const regexes = __importStar(require("./regexes.cjs"));
+const schemas_js_1 = require("./schemas.cjs");
 const to_json_schema_js_1 = require("./to-json-schema.cjs");
 const util_js_1 = require("./util.cjs");
+const narrowMin = (agg, key, value) => {
+    if (agg[key] === undefined || value > agg[key])
+        agg[key] = value;
+};
+const narrowMax = (agg, key, value) => {
+    if (agg[key] === undefined || value < agg[key])
+        agg[key] = value;
+};
+const narrowBoth = (agg, value) => {
+    narrowMin(agg, "minimum", value);
+    narrowMax(agg, "maximum", value);
+};
+const addDivisor = (agg, value) => {
+    agg.multipleOf ?? (agg.multipleOf = []);
+    if (!agg.multipleOf.includes(value))
+        agg.multipleOf.push(value);
+};
+const addPattern = (agg, pattern) => {
+    agg.patterns ?? (agg.patterns = new Set());
+    agg.patterns.add(pattern);
+};
+const intersectMime = (agg, mime) => {
+    agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
+};
+// last-wins, matching the bag's historical write order; the flag keeps an integer format from being lost to a later float one
+const setFormat = (agg, format) => {
+    agg.format = format;
+    if (format.includes("int"))
+        agg.isInt = true;
+};
+const minContributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
+const maxContributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
+const formatContributor = (ranges) => (agg, def) => {
+    setFormat(agg, def.format);
+    const [minimum, maximum] = ranges[def.format];
+    narrowMin(agg, "minimum", minimum);
+    narrowMax(agg, "maximum", maximum);
+};
+const contributors = {
+    greater_than: (agg, def) => narrowMin(agg, def.inclusive ? "minimum" : "exclusiveMinimum", def.value),
+    less_than: (agg, def) => narrowMax(agg, def.inclusive ? "maximum" : "exclusiveMaximum", def.value),
+    multiple_of: (agg, def) => addDivisor(agg, def.value),
+    number_format: formatContributor(util_js_1.NUMBER_FORMAT_RANGES),
+    bigint_format: formatContributor(util_js_1.BIGINT_FORMAT_RANGES),
+    min_length: minContributor,
+    max_length: maxContributor,
+    length_equals: (agg, def) => narrowBoth(agg, def.length),
+    min_size: minContributor,
+    max_size: maxContributor,
+    size_equals: (agg, def) => narrowBoth(agg, def.size),
+    string_format: (agg, def) => {
+        setFormat(agg, def.format);
+        if (def.pattern)
+            addPattern(agg, def.pattern);
+        if (def.format === "base64" || def.format === "base64url")
+            agg.contentEncoding = def.format;
+        if (def.local || def.precision === -1)
+            agg.laxFormat = true;
+    },
+    mime_type: (agg, def) => intersectMime(agg, def.mime),
+};
+function aggregateChecks(schema) {
+    const agg = {};
+    const def = schema._zod.def;
+    // a format schema is its own first check, same rule as $ZodType init
+    const list = schema._zod.traits.has("$ZodCheck")
+        ? [schema, ...(def.checks ?? [])]
+        : (def.checks ?? []);
+    for (const ch of list)
+        contributors[ch._zod.def.check]?.(agg, ch._zod.def);
+    // reconcile with the bag so third-party onattach contributions still land; first-party residue is never tighter than the fold, so merging it back is idempotent for one and additive for the other
+    const bag = schema._zod.bag;
+    if (bag.minimum !== undefined)
+        narrowMin(agg, "minimum", bag.minimum);
+    if (bag.exclusiveMinimum !== undefined)
+        narrowMin(agg, "exclusiveMinimum", bag.exclusiveMinimum);
+    if (bag.maximum !== undefined)
+        narrowMax(agg, "maximum", bag.maximum);
+    if (bag.exclusiveMaximum !== undefined)
+        narrowMax(agg, "exclusiveMaximum", bag.exclusiveMaximum);
+    if (bag.multipleOf !== undefined)
+        addDivisor(agg, bag.multipleOf);
+    if (bag.format !== undefined) {
+        agg.format ?? (agg.format = bag.format);
+        if (bag.format.includes("int"))
+            agg.isInt = true;
+    }
+    if (bag.mime)
+        intersectMime(agg, bag.mime);
+    for (const pattern of bag.patterns ?? [])
+        addPattern(agg, pattern);
+    return agg;
+}
 const formatMap = {
     guid: "uuid",
     url: "uri",
@@ -36,11 +131,16 @@ const formatMap = {
     regex: "", // do not set
 };
 // ==================== SIMPLE TYPE PROCESSORS ====================
+// the runtime patterns are lax so parse paths never overflow the regex stack; the emitted schema swaps in the exact block forms, which zod itself never executes
+const exactPatterns = new Map([
+    [schemas_js_1.base64Charset, regexes.base64],
+    [schemas_js_1.base64urlCharset, regexes.base64url],
+]);
+const exactPattern = (p) => exactPatterns.get(p) ?? p;
 const stringProcessor = (schema, ctx, _json, _params) => {
     const json = _json;
     json.type = "string";
-    const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = schema._zod
-        .bag;
+    const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
     if (typeof minimum === "number")
         json.minLength = minimum;
     if (typeof maximum === "number")
@@ -58,7 +158,7 @@ const stringProcessor = (schema, ctx, _json, _params) => {
     if (contentEncoding)
         json.contentEncoding = contentEncoding;
     if (patterns && patterns.size > 0) {
-        const patternList = [...patterns];
+        const patternList = [...patterns].map(exactPattern);
         if (patternList.length === 1)
             json.pattern = patternList[0].source;
         else if (patternList.length > 1) {
@@ -76,11 +176,8 @@ const stringProcessor = (schema, ctx, _json, _params) => {
 exports.stringProcessor = stringProcessor;
 const numberProcessor = (schema, ctx, _json, params) => {
     const json = _json;
-    const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-    if (typeof format === "string" && format.includes("int"))
-        json.type = "integer";
-    else
-        json.type = "number";
+    const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
+    json.type = isInt ? "integer" : "number";
     // when both minimum and exclusiveMinimum exist, pick the more restrictive one
     const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
     const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
@@ -109,12 +206,21 @@ const numberProcessor = (schema, ctx, _json, params) => {
     else if (typeof maximum === "number") {
         json.maximum = maximum;
     }
-    if (typeof multipleOf === "number") {
+    if (multipleOf) {
         // JSON Schema requires a divisor strictly greater than zero, and a non-finite one does not survive JSON at all. A negative divisor accepts exactly what its absolute value accepts, so it still maps; zero, NaN and Infinity have no keyword form.
-        if (Number.isFinite(multipleOf) && multipleOf !== 0)
-            json.multipleOf = Math.abs(multipleOf);
-        else
-            (0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, `A multipleOf divisor of ${multipleOf} cannot be represented in JSON Schema`);
+        const divisors = new Set();
+        for (const divisor of multipleOf) {
+            if (Number.isFinite(divisor) && divisor !== 0)
+                divisors.add(Math.abs(divisor));
+            else
+                (0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        }
+        // chained divisors are a conjunction the keyword cannot carry alone, so extras ride an allOf, same as stacked patterns
+        const [first, ...rest] = divisors;
+        if (first !== undefined)
+            json.multipleOf = first;
+        if (rest.length)
+            json.allOf = [...(json.allOf ?? []), ...rest.map((m) => ({ multipleOf: m }))];
     }
 };
 exports.numberProcessor = numberProcessor;
@@ -246,29 +352,24 @@ const templateLiteralProcessor = (schema, _ctx, json, _params) => {
 exports.templateLiteralProcessor = templateLiteralProcessor;
 const fileProcessor = (schema, _ctx, json, _params) => {
     const _json = json;
-    const file = {
-        type: "string",
-        format: "binary",
-        contentEncoding: "binary",
-    };
-    const { minimum, maximum, mime } = schema._zod.bag;
+    _json.type = "string";
+    _json.format = "binary";
+    _json.contentEncoding = "binary";
+    const { minimum, maximum, mime } = aggregateChecks(schema);
     if (minimum !== undefined)
-        file.minLength = minimum;
+        _json.minLength = minimum;
     if (maximum !== undefined)
-        file.maxLength = maximum;
-    if (mime) {
-        if (mime.length === 1) {
-            file.contentMediaType = mime[0];
-            Object.assign(_json, file);
-        }
-        else {
-            Object.assign(_json, file); // shared props at root
-            _json.anyOf = mime.map((m) => ({ contentMediaType: m })); // only contentMediaType differs
-        }
-    }
-    else {
-        Object.assign(_json, file);
-    }
+        _json.maxLength = maximum;
+    if (!mime)
+        return;
+    // an empty intersection means the mime checks share no value, so nothing passes at runtime; `anyOf` must be non-empty, so the false schema is `not: {}`
+    if (mime.length === 0)
+        _json.not = {};
+    else if (mime.length === 1)
+        _json.contentMediaType = mime[0];
+    // only contentMediaType differs, so the shared props stay at the root
+    else
+        _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
 };
 exports.fileProcessor = fileProcessor;
 const successProcessor = (_schema, _ctx, json, _params) => {
@@ -299,13 +400,13 @@ exports.setProcessor = setProcessor;
 const arrayProcessor = (schema, ctx, _json, params) => {
     const json = _json;
     const def = schema._zod.def;
-    const { minimum, maximum } = schema._zod.bag;
+    const { minimum, maximum } = aggregateChecks(schema);
     if (typeof minimum === "number")
         json.minItems = minimum;
     if (typeof maximum === "number")
         json.maxItems = maximum;
     json.type = "array";
-    json.items = (0, to_json_schema_js_1.process)(def.element, ctx, {
+    json.items = (0, to_json_schema_js_1.processSchema)(def.element, ctx, {
         ...params,
         path: [...params.path, "items"],
     });
@@ -340,7 +441,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
     json.properties = {};
     for (const key in shape) {
         // assignProp so a __proto__ key becomes an own property instead of hitting the inherited setter on the plain {} we build into
-        (0, util_js_1.assignProp)(json.properties, key, (0, to_json_schema_js_1.process)(shape[key], ctx, {
+        (0, util_js_1.assignProp)(json.properties, key, (0, to_json_schema_js_1.processSchema)(shape[key], ctx, {
             ...params,
             path: [...params.path, "properties", key],
         }));
@@ -370,18 +471,50 @@ const objectProcessor = (schema, ctx, _json, params) => {
             json.additionalProperties = false;
     }
     else if (def.catchall) {
-        json.additionalProperties = (0, to_json_schema_js_1.process)(def.catchall, ctx, {
+        json.additionalProperties = (0, to_json_schema_js_1.processSchema)(def.catchall, ctx, {
             ...params,
             path: [...params.path, "additionalProperties"],
         });
     }
 };
 exports.objectProcessor = objectProcessor;
+// asserts named properties in place and passes everything else through, so no additionalProperties constraint is emitted
+const propertiesProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    // dropping a symbol key silently would emit a schema that asserts less than this one does
+    if (Object.getOwnPropertySymbols(def.shape).length &&
+        (0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")) {
+        return;
+    }
+    // the parsed value is the input, so an output-mode emission would describe a transformed value this schema never returns
+    if (ctx.io === "output") {
+        for (const key in def.shape) {
+            if ((0, to_json_schema_js_1.isTransforming)(def.shape[key]) &&
+                (0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, `z.properties() returns its input, so the output of a transforming schema at key "${key}" cannot be represented in JSON Schema`)) {
+                return;
+            }
+        }
+    }
+    json.type = "object";
+    json.properties = {};
+    for (const key in def.shape) {
+        (0, util_js_1.assignProp)(json.properties, key, (0, to_json_schema_js_1.processSchema)(def.shape[key], ctx, {
+            ...params,
+            path: [...params.path, "properties", key],
+        }));
+    }
+    // input-side optionality in both modes: the parsed value is the input, so a defaulted key that stays absent must not be required of the output either
+    const required = Object.keys(def.shape).filter((key) => inputOptin(def.shape[key]) === undefined);
+    if (required.length > 0)
+        json.required = required;
+};
+exports.propertiesProcessor = propertiesProcessor;
 const unionProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
     // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches). This includes both z.xor() and discriminated unions
     const isExclusive = def.inclusive === false;
-    const options = def.options.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
+    const options = def.options.map((x, i) => (0, to_json_schema_js_1.processSchema)(x, ctx, {
         ...params,
         path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
     }));
@@ -395,11 +528,11 @@ const unionProcessor = (schema, ctx, json, params) => {
 exports.unionProcessor = unionProcessor;
 const intersectionProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    const a = (0, to_json_schema_js_1.process)(def.left, ctx, {
+    const a = (0, to_json_schema_js_1.processSchema)(def.left, ctx, {
         ...params,
         path: [...params.path, "allOf", 0],
     });
-    const b = (0, to_json_schema_js_1.process)(def.right, ctx, {
+    const b = (0, to_json_schema_js_1.processSchema)(def.right, ctx, {
         ...params,
         path: [...params.path, "allOf", 1],
     });
@@ -419,12 +552,12 @@ const tupleProcessor = (schema, ctx, _json, params) => {
     json.type = "array";
     const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
     const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-    const prefixItems = def.items.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
+    const prefixItems = def.items.map((x, i) => (0, to_json_schema_js_1.processSchema)(x, ctx, {
         ...params,
         path: [...params.path, prefixPath, i],
     }));
     const rest = def.rest
-        ? (0, to_json_schema_js_1.process)(def.rest, ctx, {
+        ? (0, to_json_schema_js_1.processSchema)(def.rest, ctx, {
             ...params,
             path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
         })
@@ -478,7 +611,7 @@ const tupleProcessor = (schema, ctx, _json, params) => {
             json.maxItems = maxItems;
     }
     // explicit user-defined length checks take precedence
-    const { minimum, maximum } = schema._zod.bag;
+    const { minimum, maximum } = aggregateChecks(schema);
     if (typeof minimum === "number")
         json.minItems = minimum;
     if (typeof maximum === "number")
@@ -572,23 +705,22 @@ const recordProcessor = (schema, ctx, _json, params) => {
     json.type = "object";
     // For looseRecord with regex patterns, use patternProperties. This correctly represents "only validate keys matching the pattern" semantics and composes well with allOf (intersections)
     const keyType = def.keyType;
-    const keyBag = keyType._zod.bag;
-    const patterns = keyBag?.patterns;
+    const patterns = aggregateChecks(keyType).patterns;
     if (def.mode === "loose" && patterns && patterns.size > 0) {
         // Use patternProperties for looseRecord with regex patterns
-        const valueSchema = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
+        const valueSchema = (0, to_json_schema_js_1.processSchema)(def.valueType, ctx, {
             ...params,
             path: [...params.path, "patternProperties", "*"],
         });
         json.patternProperties = {};
         for (const pattern of patterns) {
-            (0, util_js_1.assignProp)(json.patternProperties, pattern.source, valueSchema);
+            (0, util_js_1.assignProp)(json.patternProperties, exactPattern(pattern).source, valueSchema);
         }
     }
     else {
         // Default behavior: use propertyNames + additionalProperties
         if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-            json.propertyNames = (0, to_json_schema_js_1.process)(def.keyType, ctx, {
+            json.propertyNames = (0, to_json_schema_js_1.processSchema)(def.keyType, ctx, {
                 ...params,
                 path: [...params.path, "propertyNames"],
             });
@@ -600,7 +732,7 @@ const recordProcessor = (schema, ctx, _json, params) => {
             }
             pending.push(schema);
         }
-        json.additionalProperties = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
+        json.additionalProperties = (0, to_json_schema_js_1.processSchema)(def.valueType, ctx, {
             ...params,
             path: [...params.path, "additionalProperties"],
         });
@@ -619,7 +751,7 @@ const recordProcessor = (schema, ctx, _json, params) => {
 exports.recordProcessor = recordProcessor;
 const nullableProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    const inner = (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    const inner = (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     if (ctx.target === "openapi-3.0") {
         seen.ref = def.innerType;
@@ -632,7 +764,7 @@ const nullableProcessor = (schema, ctx, json, params) => {
 exports.nullableProcessor = nullableProcessor;
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
@@ -656,7 +788,7 @@ function serializeDefaultValue(value, schema, ctx, json, params) {
 }
 const defaultProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
@@ -666,7 +798,7 @@ const defaultProcessor = (schema, ctx, json, params) => {
 exports.defaultProcessor = defaultProcessor;
 const prefaultProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     if (ctx.io !== "input")
@@ -678,7 +810,7 @@ const prefaultProcessor = (schema, ctx, json, params) => {
 exports.prefaultProcessor = prefaultProcessor;
 const catchProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     let catchValue;
@@ -696,14 +828,14 @@ const pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
     const inIsTransform = def.in._zod.traits.has("$ZodTransform");
     const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
-    (0, to_json_schema_js_1.process)(innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
 };
 exports.pipeProcessor = pipeProcessor;
 const readonlyProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     json.readOnly = true;
@@ -711,21 +843,21 @@ const readonlyProcessor = (schema, ctx, json, params) => {
 exports.readonlyProcessor = readonlyProcessor;
 const promiseProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
 exports.promiseProcessor = promiseProcessor;
 const optionalProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
 exports.optionalProcessor = optionalProcessor;
 const lazyProcessor = (schema, ctx, _json, params) => {
     const innerType = schema._zod.innerType;
-    (0, to_json_schema_js_1.process)(innerType, ctx, params);
+    (0, to_json_schema_js_1.processSchema)(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
 };
@@ -751,6 +883,7 @@ exports.allProcessors = {
     file: exports.fileProcessor,
     success: exports.successProcessor,
     custom: exports.customProcessor,
+    properties: exports.propertiesProcessor,
     function: exports.functionProcessor,
     transform: exports.transformProcessor,
     map: exports.mapProcessor,
@@ -781,7 +914,7 @@ function toJSONSchema(input, params) {
         // First pass: process all schemas to build the seen map
         for (const entry of registry._idmap.entries()) {
             const [_, schema] = entry;
-            (0, to_json_schema_js_1.process)(schema, ctx);
+            (0, to_json_schema_js_1.processSchema)(schema, ctx);
         }
         const schemas = {};
         const external = {
@@ -807,7 +940,26 @@ function toJSONSchema(input, params) {
     }
     // Single schema case
     const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports.allProcessors });
-    (0, to_json_schema_js_1.process)(input, ctx);
+    (0, to_json_schema_js_1.processSchema)(input, ctx);
     (0, to_json_schema_js_1.extractDefs)(ctx, input);
     return (0, to_json_schema_js_1.finalize)(ctx, input);
 }
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

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

@@ -1,6 +1,21 @@
 import type { $ZodRegistry } from "./registries.cjs";
 import type * as schemas from "./schemas.cjs";
 import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.cjs";
+type Bound = number | bigint | Date;
+interface CheckAggregate<N extends Bound = Bound> {
+    minimum?: N;
+    maximum?: N;
+    exclusiveMinimum?: N;
+    exclusiveMaximum?: N;
+    multipleOf?: number[];
+    format?: string;
+    isInt?: boolean;
+    patterns?: Set<RegExp>;
+    mime?: string[];
+    contentEncoding?: string;
+    laxFormat?: boolean;
+}
+export declare function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N>;
 export declare const stringProcessor: Processor<schemas.$ZodString>;
 export declare const numberProcessor: Processor<schemas.$ZodNumber>;
 export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
@@ -26,6 +41,7 @@ export declare const mapProcessor: Processor<schemas.$ZodMap>;
 export declare const setProcessor: Processor<schemas.$ZodSet>;
 export declare const arrayProcessor: Processor<schemas.$ZodArray>;
 export declare const objectProcessor: Processor<schemas.$ZodObject>;
+export declare const propertiesProcessor: Processor<schemas.$ZodProperties>;
 export declare const unionProcessor: Processor<schemas.$ZodUnion>;
 export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
 export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
@@ -47,3 +63,4 @@ export declare function toJSONSchema(registry: $ZodRegistry<{
 }>, params?: RegistryToJSONSchemaParams): {
     schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
 };
+export {};

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

@@ -1,6 +1,21 @@
 import type { $ZodRegistry } from "./registries.js";
 import type * as schemas from "./schemas.js";
 import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.js";
+type Bound = number | bigint | Date;
+interface CheckAggregate<N extends Bound = Bound> {
+    minimum?: N;
+    maximum?: N;
+    exclusiveMinimum?: N;
+    exclusiveMaximum?: N;
+    multipleOf?: number[];
+    format?: string;
+    isInt?: boolean;
+    patterns?: Set<RegExp>;
+    mime?: string[];
+    contentEncoding?: string;
+    laxFormat?: boolean;
+}
+export declare function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N>;
 export declare const stringProcessor: Processor<schemas.$ZodString>;
 export declare const numberProcessor: Processor<schemas.$ZodNumber>;
 export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
@@ -26,6 +41,7 @@ export declare const mapProcessor: Processor<schemas.$ZodMap>;
 export declare const setProcessor: Processor<schemas.$ZodSet>;
 export declare const arrayProcessor: Processor<schemas.$ZodArray>;
 export declare const objectProcessor: Processor<schemas.$ZodObject>;
+export declare const propertiesProcessor: Processor<schemas.$ZodProperties>;
 export declare const unionProcessor: Processor<schemas.$ZodUnion>;
 export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
 export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
@@ -47,3 +63,4 @@ export declare function toJSONSchema(registry: $ZodRegistry<{
 }>, params?: RegistryToJSONSchemaParams): {
     schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
 };
+export {};