zod 4.5.3 → 4.6.0

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

@@ -2,6 +2,7 @@ import type * as checks from "./checks.js";
 import type * as JSONSchema from "./json-schema.js";
 import * as regexes from "./regexes.js";
 import type { $ZodRegistry } from "./registries.js";
+import { base64Charset, base64urlCharset } from "./schemas.js";
 import type * as schemas from "./schemas.js";
 import {
   type ProcessParams,
@@ -15,9 +16,116 @@ import {
   finalize,
   handleUnrepresentable,
   initializeContext,
-  process,
+  isTransforming,
+  processSchema,
 } from "./to-json-schema.js";
-import { assignProp, getEnumValues } from "./util.js";
+import { BIGINT_FORMAT_RANGES, NUMBER_FORMAT_RANGES, assignProp, getEnumValues } from "./util.js";
+
+// ==================== CHECK AGGREGATION ====================
+
+// constraint metadata comes from folding `def.checks` here, not from trusting `_zod.bag`: the bag is written by each check's own `onattach` in chain order, which has repeatedly produced order-dependent and lossy values (#6550). runtime checks are a conjunction, so every merge below is the conjunction's — tightest bound wins, patterns union, divisors collect, mime lists intersect
+type Bound = number | bigint | Date;
+
+interface CheckAggregate<N extends Bound = Bound> {
+  minimum?: N;
+  maximum?: N;
+  exclusiveMinimum?: N;
+  exclusiveMaximum?: N;
+  multipleOf?: number[];
+  format?: string;
+  // ORed across formats: any integer format keeps the conjunction integer, whatever format lands last
+  isInt?: boolean;
+  patterns?: Set<RegExp>;
+  mime?: string[];
+  contentEncoding?: string;
+  // a datetime that drops the offset or the seconds accepts what `date-time` forbids, so the keyword is withheld
+  laxFormat?: boolean;
+}
+
+const narrowMin = (agg: CheckAggregate, key: "minimum" | "exclusiveMinimum", value: Bound): void => {
+  if (agg[key] === undefined || value > agg[key]) agg[key] = value;
+};
+const narrowMax = (agg: CheckAggregate, key: "maximum" | "exclusiveMaximum", value: Bound): void => {
+  if (agg[key] === undefined || value < agg[key]) agg[key] = value;
+};
+const narrowBoth = (agg: CheckAggregate, value: number): void => {
+  narrowMin(agg, "minimum", value);
+  narrowMax(agg, "maximum", value);
+};
+const addDivisor = (agg: CheckAggregate, value: number): void => {
+  agg.multipleOf ??= [];
+  if (!agg.multipleOf.includes(value)) agg.multipleOf.push(value);
+};
+const addPattern = (agg: CheckAggregate, pattern: RegExp): void => {
+  agg.patterns ??= new Set();
+  agg.patterns.add(pattern);
+};
+const intersectMime = (agg: CheckAggregate, mime: string[]): void => {
+  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: CheckAggregate, format: string): void => {
+  agg.format = format;
+  if (format.includes("int")) agg.isInt = true;
+};
+
+type Contributor = (agg: CheckAggregate, def: any) => void;
+const minContributor: Contributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
+const maxContributor: Contributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
+const formatContributor =
+  (ranges: Record<string, [Bound, Bound]>): Contributor =>
+  (agg, def) => {
+    setFormat(agg, def.format);
+    const [minimum, maximum] = ranges[def.format]!;
+    narrowMin(agg, "minimum", minimum);
+    narrowMax(agg, "maximum", maximum);
+  };
+
+const contributors: Record<string, Contributor> = {
+  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(NUMBER_FORMAT_RANGES),
+  bigint_format: formatContributor(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),
+};
+
+export function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N> {
+  const agg: CheckAggregate = {};
+  const def = schema._zod.def;
+  // a format schema is its own first check, same rule as $ZodType init
+  const list: checks.$ZodCheck[] = schema._zod.traits.has("$ZodCheck")
+    ? [schema as unknown as checks.$ZodCheck, ...(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 as Omit<CheckAggregate, "multipleOf"> & { multipleOf?: number };
+  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 ??= 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 as CheckAggregate<N>;
+}
 
 const formatMap: Partial<Record<checks.$ZodStringFormats, string | undefined>> = {
   guid: "uuid",
@@ -29,11 +137,17 @@ const formatMap: Partial<Record<checks.$ZodStringFormats, string | undefined>> =
 
 // ==================== 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: Map<RegExp, RegExp> = new Map([
+  [base64Charset, regexes.base64],
+  [base64urlCharset, regexes.base64url],
+]);
+const exactPattern = (p: RegExp): RegExp => exactPatterns.get(p) ?? p;
+
 export const stringProcessor: Processor<schemas.$ZodString> = (schema, ctx, _json, _params) => {
   const json = _json as JSONSchema.StringSchema;
   json.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = schema._zod
-    .bag as schemas.$ZodStringInternals<unknown>["bag"];
+  const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number") json.minLength = minimum;
   if (typeof maximum === "number") json.maxLength = maximum;
   // custom pattern overrides format
@@ -48,7 +162,7 @@ export const stringProcessor: Processor<schemas.$ZodString> = (schema, ctx, _jso
   }
   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) {
       json.allOf = [
@@ -65,9 +179,8 @@ export const stringProcessor: Processor<schemas.$ZodString> = (schema, ctx, _jso
 
 export const numberProcessor: Processor<schemas.$ZodNumber> = (schema, ctx, _json, params) => {
   const json = _json as JSONSchema.NumberSchema | JSONSchema.IntegerSchema;
-  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<number>(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);
@@ -96,17 +209,24 @@ export const numberProcessor: Processor<schemas.$ZodNumber> = (schema, ctx, _jso
     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
-      handleUnrepresentable(
-        schema,
-        ctx,
-        json,
-        params,
-        `A multipleOf divisor of ${multipleOf} cannot be represented in JSON Schema`
-      );
+    const divisors = new Set<number>();
+    for (const divisor of multipleOf) {
+      if (Number.isFinite(divisor) && divisor !== 0) divisors.add(Math.abs(divisor));
+      else
+        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 }))];
   }
 };
 
@@ -229,26 +349,19 @@ export const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral> =
 
 export const fileProcessor: Processor<schemas.$ZodFile> = (schema, _ctx, json, _params) => {
   const _json = json as JSONSchema.StringSchema;
-  const file: JSONSchema.StringSchema = {
-    type: "string",
-    format: "binary",
-    contentEncoding: "binary",
-  };
+  _json.type = "string";
+  _json.format = "binary";
+  _json.contentEncoding = "binary";
 
-  const { minimum, maximum, mime } = schema._zod.bag as schemas.$ZodFileInternals["bag"];
-  if (minimum !== undefined) file.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);
-  }
+  const { minimum, maximum, mime } = aggregateChecks<number>(schema);
+  if (minimum !== undefined) _json.minLength = minimum;
+  if (maximum !== undefined) _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 }));
 };
 
 export const successProcessor: Processor<schemas.$ZodSuccess> = (_schema, _ctx, json, _params) => {
@@ -280,12 +393,12 @@ export const setProcessor: Processor<schemas.$ZodSet> = (schema, ctx, json, para
 export const arrayProcessor: Processor<schemas.$ZodArray> = (schema, ctx, _json, params) => {
   const json = _json as JSONSchema.ArraySchema;
   const def = schema._zod.def as schemas.$ZodArrayDef;
-  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 = process(def.element, ctx as any, {
+  json.items = processSchema(def.element, ctx as any, {
     ...params,
     path: [...params.path, "items"],
   });
@@ -329,7 +442,7 @@ export const objectProcessor: Processor<schemas.$ZodObject> = (schema, ctx, _jso
     assignProp(
       json.properties,
       key,
-      process(shape[key]!, ctx as any, {
+      processSchema(shape[key]!, ctx as any, {
         ...params,
         path: [...params.path, "properties", key],
       })
@@ -361,19 +474,67 @@ export const objectProcessor: Processor<schemas.$ZodObject> = (schema, ctx, _jso
     // regular
     if (ctx.io === "output") json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process(def.catchall, ctx as any, {
+    json.additionalProperties = processSchema(def.catchall, ctx as any, {
       ...params,
       path: [...params.path, "additionalProperties"],
     });
   }
 };
 
+// asserts named properties in place and passes everything else through, so no additionalProperties constraint is emitted
+export const propertiesProcessor: Processor<schemas.$ZodProperties> = (schema, ctx, _json, params) => {
+  const json = _json as JSONSchema.ObjectSchema;
+  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 &&
+    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 (
+        isTransforming(def.shape[key]!) &&
+        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) {
+    assignProp(
+      json.properties,
+      key,
+      processSchema(def.shape[key]!, ctx as any, {
+        ...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;
+};
+
 export const unionProcessor: Processor<schemas.$ZodUnion> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodUnionDef;
   // 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) =>
-    process(x, ctx as any, {
+    processSchema(x, ctx as any, {
       ...params,
       path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
     })
@@ -387,11 +548,11 @@ export const unionProcessor: Processor<schemas.$ZodUnion> = (schema, ctx, json,
 
 export const intersectionProcessor: Processor<schemas.$ZodIntersection> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodIntersectionDef;
-  const a = process(def.left, ctx as any, {
+  const a = processSchema(def.left, ctx as any, {
     ...params,
     path: [...params.path, "allOf", 0],
   });
-  const b = process(def.right, ctx as any, {
+  const b = processSchema(def.right, ctx as any, {
     ...params,
     path: [...params.path, "allOf", 1],
   });
@@ -416,13 +577,13 @@ export const tupleProcessor: Processor<schemas.$ZodTuple> = (schema, ctx, _json,
     ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
 
   const prefixItems = def.items.map((x, i) =>
-    process(x, ctx as any, {
+    processSchema(x, ctx as any, {
       ...params,
       path: [...params.path, prefixPath, i],
     })
   );
   const rest = def.rest
-    ? process(def.rest, ctx as any, {
+    ? processSchema(def.rest, ctx as any, {
         ...params,
         path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
       })
@@ -469,10 +630,7 @@ export const tupleProcessor: Processor<schemas.$ZodTuple> = (schema, ctx, _json,
   }
 
   // explicit user-defined length checks take precedence
-  const { minimum, maximum } = schema._zod.bag as {
-    minimum?: number;
-    maximum?: number;
-  };
+  const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number") json.minItems = minimum;
   if (typeof maximum === "number") json.maxItems = maximum;
 };
@@ -563,23 +721,22 @@ export const recordProcessor: Processor<schemas.$ZodRecord> = (schema, ctx, _jso
 
   // 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 as schemas.$ZodTypes;
-  const keyBag = keyType._zod.bag as schemas.$ZodStringInternals<unknown>["bag"] | undefined;
-  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 = process(def.valueType, ctx as any, {
+    const valueSchema = processSchema(def.valueType, ctx as any, {
       ...params,
       path: [...params.path, "patternProperties", "*"],
     });
     json.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json.patternProperties, pattern.source, valueSchema);
+      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 = process(def.keyType, ctx as any, {
+      json.propertyNames = processSchema(def.keyType, ctx as any, {
         ...params,
         path: [...params.path, "propertyNames"],
       });
@@ -591,7 +748,7 @@ export const recordProcessor: Processor<schemas.$ZodRecord> = (schema, ctx, _jso
       }
       pending.push(schema);
     }
-    json.additionalProperties = process(def.valueType, ctx as any, {
+    json.additionalProperties = processSchema(def.valueType, ctx as any, {
       ...params,
       path: [...params.path, "additionalProperties"],
     });
@@ -614,7 +771,7 @@ export const recordProcessor: Processor<schemas.$ZodRecord> = (schema, ctx, _jso
 
 export const nullableProcessor: Processor<schemas.$ZodNullable> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodNullableDef;
-  const inner = process(def.innerType, ctx as any, params);
+  const inner = processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -626,7 +783,7 @@ export const nullableProcessor: Processor<schemas.$ZodNullable> = (schema, ctx,
 
 export const nonoptionalProcessor: Processor<schemas.$ZodNonOptional> = (schema, ctx, _json, params) => {
   const def = schema._zod.def as schemas.$ZodNonOptionalDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
 };
@@ -655,7 +812,7 @@ function serializeDefaultValue(
 
 export const defaultProcessor: Processor<schemas.$ZodDefault> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodDefaultDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
   const value = serializeDefaultValue(def.defaultValue, schema, ctx as ToJSONSchemaContext, json, params);
@@ -664,7 +821,7 @@ export const defaultProcessor: Processor<schemas.$ZodDefault> = (schema, ctx, js
 
 export const prefaultProcessor: Processor<schemas.$ZodPrefault> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodPrefaultDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
   if (ctx.io !== "input") return;
@@ -674,7 +831,7 @@ export const prefaultProcessor: Processor<schemas.$ZodPrefault> = (schema, ctx,
 
 export const catchProcessor: Processor<schemas.$ZodCatch> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodCatchDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
   let catchValue: any;
@@ -691,14 +848,14 @@ export const pipeProcessor: Processor<schemas.$ZodPipe> = (schema, ctx, _json, p
   const def = schema._zod.def as schemas.$ZodPipeDef;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
-  process(innerType, ctx as any, params);
+  processSchema(innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = innerType;
 };
 
 export const readonlyProcessor: Processor<schemas.$ZodReadonly> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodReadonlyDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
   json.readOnly = true;
@@ -706,21 +863,21 @@ export const readonlyProcessor: Processor<schemas.$ZodReadonly> = (schema, ctx,
 
 export const promiseProcessor: Processor<schemas.$ZodPromise> = (schema, ctx, _json, params) => {
   const def = schema._zod.def as schemas.$ZodPromiseDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
 };
 
 export const optionalProcessor: Processor<schemas.$ZodOptional> = (schema, ctx, _json, params) => {
   const def = schema._zod.def as schemas.$ZodOptionalDef;
-  process(def.innerType, ctx as any, params);
+  processSchema(def.innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = def.innerType;
 };
 
 export const lazyProcessor: Processor<schemas.$ZodLazy> = (schema, ctx, _json, params) => {
   const innerType = (schema as schemas.$ZodLazy)._zod.innerType;
-  process(innerType, ctx as any, params);
+  processSchema(innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = innerType;
 };
@@ -747,6 +904,7 @@ export const allProcessors: Record<string, Processor<any>> = {
   file: fileProcessor,
   success: successProcessor,
   custom: customProcessor,
+  properties: propertiesProcessor,
   function: functionProcessor,
   transform: transformProcessor,
   map: mapProcessor,
@@ -792,7 +950,7 @@ export function toJSONSchema(
     // First pass: process all schemas to build the seen map
     for (const entry of registry._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx as any);
+      processSchema(schema, ctx as any);
     }
 
     const schemas: Record<string, JSONSchema.BaseSchema> = {};
@@ -824,7 +982,7 @@ export function toJSONSchema(
 
   // Single schema case
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx as any);
+  processSchema(input, ctx as any);
   extractDefs(ctx as any, input);
   return finalize(ctx as any, input);
 }