@temporary-name/json-schema 1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8 → 1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1

package/dist/index.d.mts

@@ -1,9 +1,6 @@
 import * as Draft07 from '@temporary-name/interop/json-schema-typed/draft-07';
 import * as Draft2019 from '@temporary-name/interop/json-schema-typed/draft-2019-09';
 import * as Draft2020 from '@temporary-name/interop/json-schema-typed/draft-2020-12';
-import { Context } from '@temporary-name/server';
-import { ConditionalSchemaConverter } from '@temporary-name/server/openapi';
-import { StandardHandlerPlugin, StandardHandlerOptions } from '@temporary-name/server/standard';
 
 type JsonSchema = Draft2020.JSONSchema | Draft2019.JSONSchema | Draft07.JSONSchema;
 declare enum JsonSchemaXNativeType {
@@ -23,17 +20,5 @@ declare class experimental_JsonSchemaCoercer {
     coerce(schema: JsonSchema, value: unknown, options?: experimental_JsonSchemaCoerceOptions): unknown;
 }
 
-interface experimental_SmartCoercionPluginOptions {
-    schemaConverters?: readonly ConditionalSchemaConverter[];
-}
-declare class experimental_SmartCoercionPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    #private;
-    private readonly converter;
-    private readonly coercer;
-    private readonly cache;
-    constructor(options?: experimental_SmartCoercionPluginOptions);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer, experimental_SmartCoercionPlugin };
-export type { JsonSchema, experimental_JsonSchemaCoerceOptions, experimental_SmartCoercionPluginOptions };
+export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer };
+export type { JsonSchema, experimental_JsonSchemaCoerceOptions };

package/dist/index.d.ts

@@ -1,9 +1,6 @@
 import * as Draft07 from '@temporary-name/interop/json-schema-typed/draft-07';
 import * as Draft2019 from '@temporary-name/interop/json-schema-typed/draft-2019-09';
 import * as Draft2020 from '@temporary-name/interop/json-schema-typed/draft-2020-12';
-import { Context } from '@temporary-name/server';
-import { ConditionalSchemaConverter } from '@temporary-name/server/openapi';
-import { StandardHandlerPlugin, StandardHandlerOptions } from '@temporary-name/server/standard';
 
 type JsonSchema = Draft2020.JSONSchema | Draft2019.JSONSchema | Draft07.JSONSchema;
 declare enum JsonSchemaXNativeType {
@@ -23,17 +20,5 @@ declare class experimental_JsonSchemaCoercer {
     coerce(schema: JsonSchema, value: unknown, options?: experimental_JsonSchemaCoerceOptions): unknown;
 }
 
-interface experimental_SmartCoercionPluginOptions {
-    schemaConverters?: readonly ConditionalSchemaConverter[];
-}
-declare class experimental_SmartCoercionPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    #private;
-    private readonly converter;
-    private readonly coercer;
-    private readonly cache;
-    constructor(options?: experimental_SmartCoercionPluginOptions);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer, experimental_SmartCoercionPlugin };
-export type { JsonSchema, experimental_JsonSchemaCoerceOptions, experimental_SmartCoercionPluginOptions };
+export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer };
+export type { JsonSchema, experimental_JsonSchemaCoerceOptions };

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import { isObject, toArray, guard } from '@temporary-name/shared';
-import { CompositeSchemaConverter } from '@temporary-name/server/openapi';
 
 var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
   JsonSchemaXNativeType2["BigInt"] = "bigint";
@@ -337,35 +336,4 @@ class experimental_JsonSchemaCoercer {
   }
 }
 
-class experimental_SmartCoercionPlugin {
-  converter;
-  coercer;
-  cache = /* @__PURE__ */ new WeakMap();
-  constructor(options = {}) {
-    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));
-    this.coercer = new experimental_JsonSchemaCoercer();
-  }
-  init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.unshift(async (options2) => {
-      const { bodySchema, pathSchema, querySchema } = options2.procedure["~orpc"].schemas;
-      const coercedBody = await this.#coerce(bodySchema, options2.input.body);
-      const coercedPath = await this.#coerce(pathSchema, options2.input.path);
-      const coercedQuery = await this.#coerce(querySchema, options2.input.query);
-      return options2.next({
-        ...options2,
-        input: { body: coercedBody, path: coercedPath, query: coercedQuery }
-      });
-    });
-  }
-  async #coerce(schema, value) {
-    let jsonSchema = this.cache.get(schema);
-    if (!jsonSchema) {
-      jsonSchema = (await this.converter.convert(schema, { strategy: "input" }))[1];
-      this.cache.set(schema, jsonSchema);
-    }
-    return this.coercer.coerce(jsonSchema, value);
-  }
-}
-
-export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer, experimental_SmartCoercionPlugin };
+export { JsonSchemaXNativeType, experimental_JsonSchemaCoercer };

package/dist/zod4/index.d.mts

@@ -1,8 +1,7 @@
-import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@temporary-name/server/openapi';
-import { Interceptor } from '@temporary-name/shared';
+import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@temporary-name/server/openapi';
 import { core } from '@temporary-name/zod';
 import * as zod_v4_core from 'zod/v4/core';
-import { $ZodType, $input, $output } from 'zod/v4/core';
+import { $input, $output } from 'zod/v4/core';
 
 interface ZodToJsonSchemaConverterOptions {
     /**
@@ -39,15 +38,6 @@ interface ZodToJsonSchemaConverterOptions {
      * @default { not: {} }
      */
     undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
-    interceptors?: Interceptor<{
-        schema: $ZodType;
-        options: SchemaConvertOptions;
-        lazyDepth: number;
-        isHandledCustomJSONSchema: boolean;
-    }, [
-        required: boolean,
-        jsonSchema: Exclude<JSONSchema, boolean>
-    ]>[];
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
@@ -56,7 +46,6 @@ declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
-    private readonly interceptors;
     constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: core.$ZodType | undefined): boolean;
     convert(schema: core.$ZodType | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];

package/dist/zod4/index.d.ts

@@ -1,8 +1,7 @@
-import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@temporary-name/server/openapi';
-import { Interceptor } from '@temporary-name/shared';
+import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@temporary-name/server/openapi';
 import { core } from '@temporary-name/zod';
 import * as zod_v4_core from 'zod/v4/core';
-import { $ZodType, $input, $output } from 'zod/v4/core';
+import { $input, $output } from 'zod/v4/core';
 
 interface ZodToJsonSchemaConverterOptions {
     /**
@@ -39,15 +38,6 @@ interface ZodToJsonSchemaConverterOptions {
      * @default { not: {} }
      */
     undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
-    interceptors?: Interceptor<{
-        schema: $ZodType;
-        options: SchemaConvertOptions;
-        lazyDepth: number;
-        isHandledCustomJSONSchema: boolean;
-    }, [
-        required: boolean,
-        jsonSchema: Exclude<JSONSchema, boolean>
-    ]>[];
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
@@ -56,7 +46,6 @@ declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
-    private readonly interceptors;
     constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: core.$ZodType | undefined): boolean;
     convert(schema: core.$ZodType | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];

package/dist/zod4/index.mjs

@@ -1,6 +1,6 @@
 import { JsonSchemaXNativeType } from '@temporary-name/json-schema';
 import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@temporary-name/server/openapi';
-import { intercept, toArray } from '@temporary-name/shared';
+import { toArray } from '@temporary-name/shared';
 import { registry, globalRegistry } from 'zod/v4/core';
 
 const JSON_SCHEMA_REGISTRY = registry();
@@ -13,14 +13,12 @@ class ZodToJsonSchemaConverter {
   anyJsonSchema;
   unsupportedJsonSchema;
   undefinedJsonSchema;
-  interceptors;
   constructor(options = {}) {
     this.maxLazyDepth = options.maxLazyDepth ?? 2;
     this.maxStructureDepth = options.maxStructureDepth ?? 10;
     this.anyJsonSchema = options.anyJsonSchema ?? {};
     this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
     this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
-    this.interceptors = options.interceptors ?? [];
   }
   condition(schema) {
     return schema !== void 0 && schema["~standard"].vendor === "zod" && "_zod" in schema;
@@ -29,409 +27,398 @@ class ZodToJsonSchemaConverter {
     return this.#convert(schema, options, 0, 0);
   }
   #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
-    return intercept(
-      this.interceptors,
-      { schema, options, lazyDepth, isHandledCustomJSONSchema },
-      ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
-        if (structureDepth > this.maxStructureDepth) {
-          return [false, this.anyJsonSchema];
+    if (structureDepth > this.maxStructureDepth) {
+      return [false, this.anyJsonSchema];
+    }
+    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
+      const components = toArray(options.components);
+      for (const component of components) {
+        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
+          return [component.required, { $ref: component.ref }];
         }
-        if (!options2.minStructureDepthForRef || options2.minStructureDepthForRef <= structureDepth) {
-          const components = toArray(options2.components);
-          for (const component of components) {
-            if (component.schema === schema2 && component.allowedStrategies.includes(options2.strategy)) {
-              return [component.required, { $ref: component.ref }];
-            }
-          }
+      }
+    }
+    if (!isHandledCustomJSONSchema) {
+      const customJSONSchema = this.#getCustomJsonSchema(schema, options);
+      if (customJSONSchema) {
+        const [required, json] = this.#convert(schema, options, lazyDepth, structureDepth, true);
+        return [required, { ...json, ...customJSONSchema }];
+      }
+    }
+    switch (schema._zod.def.type) {
+      case "string": {
+        const string = schema;
+        const json = { type: "string" };
+        const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+        if (typeof minimum === "number") {
+          json.minLength = minimum;
         }
-        if (!isHandledCustomJSONSchema2) {
-          const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
-          if (customJSONSchema) {
-            const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);
-            return [required, { ...json, ...customJSONSchema }];
-          }
+        if (typeof maximum === "number") {
+          json.maxLength = maximum;
         }
-        switch (schema2._zod.def.type) {
-          case "string": {
-            const string = schema2;
-            const json = { type: "string" };
-            const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
-            if (typeof minimum === "number") {
-              json.minLength = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxLength = maximum;
-            }
-            if (typeof contentEncoding === "string") {
-              json.contentEncoding = this.#handleContentEncoding(contentEncoding);
-            }
-            if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
-              json.format = this.#handleStringFormat(format);
-            }
-            if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
-              for (const pattern of patterns) {
-                if (json.pattern === void 0) {
-                  json.pattern = pattern.source;
-                } else {
-                  json.allOf ??= [];
-                  json.allOf.push({ pattern: pattern.source });
-                }
-              }
-            }
-            if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
-              json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
-            }
-            return [true, json];
-          }
-          case "number": {
-            const number = schema2;
-            const json = { type: "number" };
-            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
-            if (typeof format === "string" && format?.includes("int")) {
-              json.type = "integer";
-            }
-            if (typeof minimum === "number") {
-              json.minimum = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maximum = maximum;
-            }
-            if (typeof exclusiveMinimum === "number") {
-              json.exclusiveMinimum = exclusiveMinimum;
-            }
-            if (typeof exclusiveMaximum === "number") {
-              json.exclusiveMaximum = exclusiveMaximum;
-            }
-            if (typeof multipleOf === "number") {
-              json.multipleOf = multipleOf;
+        if (typeof contentEncoding === "string") {
+          json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+        }
+        if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
+          json.format = this.#handleStringFormat(format);
+        }
+        if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
+          for (const pattern of patterns) {
+            if (json.pattern === void 0) {
+              json.pattern = pattern.source;
+            } else {
+              json.allOf ??= [];
+              json.allOf.push({ pattern: pattern.source });
             }
-            return [true, json];
-          }
-          case "boolean": {
-            return [true, { type: "boolean" }];
           }
-          case "bigint": {
-            return [
-              true,
-              {
-                type: "string",
-                pattern: "^-?[0-9]+$",
-                "x-native-type": JsonSchemaXNativeType.BigInt
-              }
-            ];
-          }
-          case "date": {
-            return [
-              true,
-              {
-                type: "string",
-                format: JSONSchemaFormat.DateTime,
-                "x-native-type": JsonSchemaXNativeType.Date
-              }
-            ];
-          }
-          case "null": {
-            return [true, { type: "null" }];
-          }
-          case "undefined":
-          case "void": {
-            return [false, this.undefinedJsonSchema];
-          }
-          case "any": {
-            return [false, this.anyJsonSchema];
-          }
-          case "unknown": {
-            return [false, this.anyJsonSchema];
-          }
-          case "never": {
-            return [true, this.unsupportedJsonSchema];
+        }
+        if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
+          json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
+        }
+        return [true, json];
+      }
+      case "number": {
+        const number = schema;
+        const json = { type: "number" };
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+        if (typeof format === "string" && format?.includes("int")) {
+          json.type = "integer";
+        }
+        if (typeof minimum === "number") {
+          json.minimum = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maximum = maximum;
+        }
+        if (typeof exclusiveMinimum === "number") {
+          json.exclusiveMinimum = exclusiveMinimum;
+        }
+        if (typeof exclusiveMaximum === "number") {
+          json.exclusiveMaximum = exclusiveMaximum;
+        }
+        if (typeof multipleOf === "number") {
+          json.multipleOf = multipleOf;
+        }
+        return [true, json];
+      }
+      case "boolean": {
+        return [true, { type: "boolean" }];
+      }
+      case "bigint": {
+        return [
+          true,
+          {
+            type: "string",
+            pattern: "^-?[0-9]+$",
+            "x-native-type": JsonSchemaXNativeType.BigInt
+          }
+        ];
+      }
+      case "date": {
+        return [
+          true,
+          {
+            type: "string",
+            format: JSONSchemaFormat.DateTime,
+            "x-native-type": JsonSchemaXNativeType.Date
+          }
+        ];
+      }
+      case "null": {
+        return [true, { type: "null" }];
+      }
+      case "undefined":
+      case "void": {
+        return [false, this.undefinedJsonSchema];
+      }
+      case "any": {
+        return [false, this.anyJsonSchema];
+      }
+      case "unknown": {
+        return [false, this.anyJsonSchema];
+      }
+      case "never": {
+        return [true, this.unsupportedJsonSchema];
+      }
+      case "array": {
+        const array = schema;
+        const json = { type: "array" };
+        const { minimum, maximum } = array._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        json.items = this.#handleArrayItemJsonSchema(
+          this.#convert(array._zod.def.element, options, lazyDepth, structureDepth + 1),
+          options
+        );
+        return [true, json];
+      }
+      case "object": {
+        const object = schema;
+        const json = { type: "object" };
+        for (const [key, value] of Object.entries(object._zod.def.shape)) {
+          const [itemRequired, itemJson] = this.#convert(value, options, lazyDepth, structureDepth + 1);
+          json.properties ??= {};
+          json.properties[key] = itemJson;
+          if (itemRequired) {
+            json.required ??= [];
+            json.required.push(key);
           }
-          case "array": {
-            const array = schema2;
-            const json = { type: "array" };
-            const { minimum, maximum } = array._zod.bag;
-            if (typeof minimum === "number") {
-              json.minItems = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxItems = maximum;
-            }
-            json.items = this.#handleArrayItemJsonSchema(
-              this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1),
-              options2
+        }
+        if (object._zod.def.catchall) {
+          if (object._zod.def.catchall._zod.def.type === "never") {
+            json.additionalProperties = false;
+          } else {
+            const [_, addJson] = this.#convert(
+              object._zod.def.catchall,
+              options,
+              lazyDepth,
+              structureDepth + 1
             );
-            return [true, json];
+            json.additionalProperties = addJson;
           }
-          case "object": {
-            const object = schema2;
-            const json = { type: "object" };
-            for (const [key, value] of Object.entries(object._zod.def.shape)) {
-              const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);
-              json.properties ??= {};
-              json.properties[key] = itemJson;
-              if (itemRequired) {
-                json.required ??= [];
-                json.required.push(key);
-              }
-            }
-            if (object._zod.def.catchall) {
-              if (object._zod.def.catchall._zod.def.type === "never") {
-                json.additionalProperties = false;
-              } else {
-                const [_, addJson] = this.#convert(
-                  object._zod.def.catchall,
-                  options2,
-                  lazyDepth2,
-                  structureDepth + 1
-                );
-                json.additionalProperties = addJson;
-              }
+        }
+        return [true, json];
+      }
+      case "union": {
+        const union = schema;
+        const anyOf = [];
+        let required = true;
+        for (const item of union._zod.def.options) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          if (!itemRequired) {
+            required = false;
+          }
+          if (options.strategy === "input") {
+            if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
+              anyOf.push(itemJson);
             }
-            return [true, json];
-          }
-          case "union": {
-            const union = schema2;
-            const anyOf = [];
-            let required = true;
-            for (const item of union._zod.def.options) {
-              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
-              if (!itemRequired) {
-                required = false;
-              }
-              if (options2.strategy === "input") {
-                if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
-                  anyOf.push(itemJson);
-                }
-              } else {
-                if (itemJson !== this.undefinedJsonSchema) {
-                  anyOf.push(itemJson);
-                }
-              }
+          } else {
+            if (itemJson !== this.undefinedJsonSchema) {
+              anyOf.push(itemJson);
             }
-            return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
           }
-          case "intersection": {
-            const intersection = schema2;
-            const json = { allOf: [] };
-            let required = false;
-            for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
-              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
-              json.allOf.push(itemJson);
-              if (itemRequired) {
-                required = true;
-              }
-            }
-            return [required, json];
+        }
+        return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
+      }
+      case "intersection": {
+        const intersection = schema;
+        const json = { allOf: [] };
+        let required = false;
+        for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          json.allOf.push(itemJson);
+          if (itemRequired) {
+            required = true;
           }
-          case "tuple": {
-            const tuple = schema2;
-            const json = { type: "array", prefixItems: [] };
-            for (const item of tuple._zod.def.items) {
-              json.prefixItems.push(
+        }
+        return [required, json];
+      }
+      case "tuple": {
+        const tuple = schema;
+        const json = { type: "array", prefixItems: [] };
+        for (const item of tuple._zod.def.items) {
+          json.prefixItems.push(
+            this.#handleArrayItemJsonSchema(
+              this.#convert(item, options, lazyDepth, structureDepth + 1),
+              options
+            )
+          );
+        }
+        if (tuple._zod.def.rest) {
+          json.items = this.#handleArrayItemJsonSchema(
+            this.#convert(tuple._zod.def.rest, options, lazyDepth, structureDepth + 1),
+            options
+          );
+        }
+        const { minimum, maximum } = tuple._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        return [true, json];
+      }
+      case "record": {
+        const record = schema;
+        const json = { type: "object" };
+        json.propertyNames = this.#convert(
+          record._zod.def.keyType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        json.additionalProperties = this.#convert(
+          record._zod.def.valueType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        return [true, json];
+      }
+      case "map": {
+        const map = schema;
+        return [
+          true,
+          {
+            type: "array",
+            items: {
+              type: "array",
+              prefixItems: [
                 this.#handleArrayItemJsonSchema(
-                  this.#convert(item, options2, lazyDepth2, structureDepth + 1),
-                  options2
-                )
-              );
-            }
-            if (tuple._zod.def.rest) {
-              json.items = this.#handleArrayItemJsonSchema(
-                this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1),
-                options2
-              );
-            }
-            const { minimum, maximum } = tuple._zod.bag;
-            if (typeof minimum === "number") {
-              json.minItems = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxItems = maximum;
-            }
-            return [true, json];
-          }
-          case "record": {
-            const record = schema2;
-            const json = { type: "object" };
-            json.propertyNames = this.#convert(
-              record._zod.def.keyType,
-              options2,
-              lazyDepth2,
-              structureDepth + 1
-            )[1];
-            json.additionalProperties = this.#convert(
-              record._zod.def.valueType,
-              options2,
-              lazyDepth2,
-              structureDepth + 1
-            )[1];
-            return [true, json];
-          }
-          case "map": {
-            const map = schema2;
-            return [
-              true,
-              {
-                type: "array",
-                items: {
-                  type: "array",
-                  prefixItems: [
-                    this.#handleArrayItemJsonSchema(
-                      this.#convert(map._zod.def.keyType, options2, lazyDepth2, structureDepth + 1),
-                      options2
-                    ),
-                    this.#handleArrayItemJsonSchema(
-                      this.#convert(map._zod.def.valueType, options2, lazyDepth2, structureDepth + 1),
-                      options2
-                    )
-                  ],
-                  maxItems: 2,
-                  minItems: 2
-                },
-                "x-native-type": JsonSchemaXNativeType.Map
-              }
-            ];
-          }
-          case "set": {
-            const set = schema2;
-            return [
-              true,
-              {
-                type: "array",
-                uniqueItems: true,
-                items: this.#handleArrayItemJsonSchema(
-                  this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1),
-                  options2
+                  this.#convert(map._zod.def.keyType, options, lazyDepth, structureDepth + 1),
+                  options
                 ),
-                "x-native-type": JsonSchemaXNativeType.Set
-              }
-            ];
-          }
-          case "enum": {
-            const enum_ = schema2;
-            return [true, { enum: Object.values(enum_._zod.def.entries) }];
-          }
-          case "literal": {
-            const literal = schema2;
-            let required = true;
-            const values = /* @__PURE__ */ new Set();
-            for (const value of literal._zod.def.values) {
-              if (value === void 0) {
-                required = false;
-              } else {
-                values.add(typeof value === "bigint" ? value.toString() : value);
-              }
-            }
-            const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
-            return [required, json];
-          }
-          case "file": {
-            const file = schema2;
-            const oneOf = [];
-            const { mime } = file._zod.bag;
-            if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
-              for (const type of mime ?? ["*/*"]) {
-                oneOf.push({
-                  type: "string",
-                  contentMediaType: type
-                });
-              }
-            }
-            return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
-          }
-          case "transform": {
-            return [false, this.anyJsonSchema];
-          }
-          case "nullable": {
-            const nullable = schema2;
-            const [required, json] = this.#convert(
-              nullable._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [required, { anyOf: [json, { type: "null" }] }];
-          }
-          case "nonoptional": {
-            const nonoptional = schema2;
-            const [, json] = this.#convert(
-              nonoptional._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [true, json];
-          }
-          case "success": {
-            return [true, { type: "boolean" }];
-          }
-          case "default":
-          case "prefault": {
-            const default_ = schema2;
-            const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);
-            return [
-              false,
-              {
-                ...json,
-                default: default_._zod.def.defaultValue
-              }
-            ];
-          }
-          case "catch": {
-            const catch_ = schema2;
-            return this.#convert(catch_._zod.def.innerType, options2, lazyDepth2, structureDepth);
-          }
-          case "nan": {
-            return [true, options2.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
-          }
-          case "pipe": {
-            const pipe = schema2;
-            return this.#convert(
-              options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-          }
-          case "readonly": {
-            const readonly_ = schema2;
-            const [required, json] = this.#convert(
-              readonly_._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [required, { ...json, readOnly: true }];
-          }
-          case "template_literal": {
-            const templateLiteral = schema2;
-            return [
-              true,
-              {
-                type: "string",
-                pattern: templateLiteral._zod.pattern.source
-              }
-            ];
-          }
-          case "optional": {
-            const optional = schema2;
-            const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);
-            return [false, json];
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+                  options
+                )
+              ],
+              maxItems: 2,
+              minItems: 2
+            },
+            "x-native-type": JsonSchemaXNativeType.Map
           }
-          case "lazy": {
-            const lazy = schema2;
-            const currentLazyDepth = lazyDepth2 + 1;
-            if (currentLazyDepth > this.maxLazyDepth) {
-              return [false, this.anyJsonSchema];
-            }
-            return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);
+        ];
+      }
+      case "set": {
+        const set = schema;
+        return [
+          true,
+          {
+            type: "array",
+            uniqueItems: true,
+            items: this.#handleArrayItemJsonSchema(
+              this.#convert(set._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+              options
+            ),
+            "x-native-type": JsonSchemaXNativeType.Set
+          }
+        ];
+      }
+      case "enum": {
+        const enum_ = schema;
+        return [true, { enum: Object.values(enum_._zod.def.entries) }];
+      }
+      case "literal": {
+        const literal = schema;
+        let required = true;
+        const values = /* @__PURE__ */ new Set();
+        for (const value of literal._zod.def.values) {
+          if (value === void 0) {
+            required = false;
+          } else {
+            values.add(typeof value === "bigint" ? value.toString() : value);
           }
-          default: {
-            schema2._zod.def.type;
-            return [true, this.unsupportedJsonSchema];
+        }
+        const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
+        return [required, json];
+      }
+      case "file": {
+        const file = schema;
+        const oneOf = [];
+        const { mime } = file._zod.bag;
+        if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
+          for (const type of mime ?? ["*/*"]) {
+            oneOf.push({
+              type: "string",
+              contentMediaType: type
+            });
           }
         }
+        return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
+      }
+      case "transform": {
+        return [false, this.anyJsonSchema];
       }
-    );
+      case "nullable": {
+        const nullable = schema;
+        const [required, json] = this.#convert(
+          nullable._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { anyOf: [json, { type: "null" }] }];
+      }
+      case "nonoptional": {
+        const nonoptional = schema;
+        const [, json] = this.#convert(nonoptional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [true, json];
+      }
+      case "success": {
+        return [true, { type: "boolean" }];
+      }
+      case "default":
+      case "prefault": {
+        const default_ = schema;
+        const [, json] = this.#convert(default_._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [
+          false,
+          {
+            ...json,
+            default: default_._zod.def.defaultValue
+          }
+        ];
+      }
+      case "catch": {
+        const catch_ = schema;
+        return this.#convert(catch_._zod.def.innerType, options, lazyDepth, structureDepth);
+      }
+      case "nan": {
+        return [true, options.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
+      }
+      case "pipe": {
+        const pipe = schema;
+        return this.#convert(
+          options.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+      }
+      case "readonly": {
+        const readonly_ = schema;
+        const [required, json] = this.#convert(
+          readonly_._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { ...json, readOnly: true }];
+      }
+      case "template_literal": {
+        const templateLiteral = schema;
+        return [
+          true,
+          {
+            type: "string",
+            pattern: templateLiteral._zod.pattern.source
+          }
+        ];
+      }
+      case "optional": {
+        const optional = schema;
+        const [, json] = this.#convert(optional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [false, json];
+      }
+      case "lazy": {
+        const lazy = schema;
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        return this.#convert(lazy._zod.def.getter(), options, currentLazyDepth, structureDepth);
+      }
+      default: {
+        schema._zod.def.type;
+        return [true, this.unsupportedJsonSchema];
+      }
+    }
   }
   #getCustomJsonSchema(schema, options) {
     if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/json-schema",
   "type": "module",
-  "version": "1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8",
+  "version": "1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
@@ -29,15 +29,16 @@
   ],
   "dependencies": {
     "zod": "^4.1.11",
-    "@temporary-name/interop": "1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8",
-    "@temporary-name/server": "1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8",
-    "@temporary-name/shared": "1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8",
-    "@temporary-name/zod": "1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8"
+    "@temporary-name/interop": "1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1",
+    "@temporary-name/server": "1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1",
+    "@temporary-name/shared": "1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1",
+    "@temporary-name/zod": "1.9.3-alpha.907c7c78d0193d34752279de92d699e50d6bc3a1"
   },
   "devDependencies": {},
   "scripts": {
     "build": "unbuild",
     "build:watch": "pnpm run build --watch",
+    "clean": "tsc -b --clean",
     "type:check": "tsc -b"
   }
 }