@orpc/zod 0.0.0-next.f4ed9ab → 0.0.0-next.f50512c

package/README.md

@@ -30,7 +30,7 @@
 - **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
 - **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
 - **📝 Contract-First Development**: Optionally define your API contract before implementation.
-- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
 - **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
 - **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
 - **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
@@ -49,14 +49,12 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
-- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
-- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
-- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
-- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
-- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
-- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
 - [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
 - [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
@@ -74,7 +72,7 @@ More schemas that [Zod](https://zod.dev/) doesn't support yet, and provides `Zod
 
 ```ts
 import { oz } from '@orpc/zod'
-import { z } from 'zod'
+import { z } from 'zod/v3'
 
 const Example = z.object({
   url: oz.url(),
@@ -88,7 +86,7 @@ const Example = z.object({
 
 ```ts
 import { OpenAPIGenerator } from '@orpc/openapi'
-import { ZodToJsonSchemaConverter } from '@orpc/zod'
+import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
 
 const openAPIGenerator = new OpenAPIGenerator({
   schemaConverters: [new ZodToJsonSchemaConverter()],
@@ -113,7 +111,7 @@ const specFromRouter = await openAPIGenerator.generate(router, {
 
 ```ts
 import { oz } from '@orpc/zod'
-import { z } from 'zod'
+import * as z from 'zod'
 
 const InputSchema = oz.openapi(
   z.object({

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
-import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod';
+import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod/v3';
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
@@ -40,34 +40,43 @@ declare class ZodSmartCoercionPlugin<TContext extends Context> implements Standa
 
 interface ZodToJsonSchemaOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type
      *
-     * Used `{}` when reach max depth
+     * Used `{}` when exceed max depth
      *
      * @default 3
      */
     maxLazyDepth?: number;
     /**
-     * The schema to be used when the Zod schema is unsupported.
+     * Max depth of nested types
      *
-     * @default { not: {} }
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
      */
-    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
      * @default { }
      */
     anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly unsupportedJsonSchema;
     private readonly anyJsonSchema;
     constructor(options?: ZodToJsonSchemaOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean, structureDepth?: number): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 
 declare const oz: {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
-import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod';
+import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod/v3';
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
@@ -40,34 +40,43 @@ declare class ZodSmartCoercionPlugin<TContext extends Context> implements Standa
 
 interface ZodToJsonSchemaOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type
      *
-     * Used `{}` when reach max depth
+     * Used `{}` when exceed max depth
      *
      * @default 3
      */
     maxLazyDepth?: number;
     /**
-     * The schema to be used when the Zod schema is unsupported.
+     * Max depth of nested types
      *
-     * @default { not: {} }
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
      */
-    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
      * @default { }
      */
     anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly unsupportedJsonSchema;
     private readonly anyJsonSchema;
     constructor(options?: ZodToJsonSchemaOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean, structureDepth?: number): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 
 declare const oz: {

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { custom, ZodFirstPartyTypeKind } from 'zod';
+import { custom, ZodFirstPartyTypeKind } from 'zod/v3';
 import wcmatch from 'wildcard-match';
-import { isObject, guard } from '@orpc/shared';
+import { isObject, guard, toArray } from '@orpc/shared';
+import { JsonSchemaXNativeType } from '@orpc/json-schema';
 import { JSONSchemaFormat } from '@orpc/openapi';
 import escapeStringRegexp from 'escape-string-regexp';
 
@@ -390,25 +391,39 @@ function safeToDate(value) {
 
 class ZodToJsonSchemaConverter {
   maxLazyDepth;
+  maxStructureDepth;
   unsupportedJsonSchema;
   anyJsonSchema;
   constructor(options = {}) {
     this.maxLazyDepth = options.maxLazyDepth ?? 3;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
     this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
     this.anyJsonSchema = options.anyJsonSchema ?? {};
   }
   condition(schema) {
     return schema !== void 0 && schema["~standard"].vendor === "zod";
   }
-  convert(schema, options, lazyDepth = 0, isHandledCustomJSONSchema = false, isHandledZodDescription = false) {
+  convert(schema, options, lazyDepth = 0, isHandledCustomJSONSchema = false, isHandledZodDescription = false, structureDepth = 0) {
     const def = schema._def;
+    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 (!isHandledZodDescription && "description" in def && typeof def.description === "string") {
       const [required, json] = this.convert(
         schema,
         options,
         lazyDepth,
         isHandledCustomJSONSchema,
-        true
+        true,
+        structureDepth
       );
       return [required, { ...json, description: def.description }];
     }
@@ -420,7 +435,8 @@ class ZodToJsonSchemaConverter {
           options,
           lazyDepth,
           true,
-          isHandledZodDescription
+          isHandledZodDescription,
+          structureDepth
         );
         return [required, { ...json, ...customJSONSchema }];
       }
@@ -548,7 +564,11 @@ class ZodToJsonSchemaConverter {
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodBigInt: {
-        const json = { type: "string", pattern: "^-?[0-9]+$" };
+        const json = {
+          "type": "string",
+          "pattern": "^-?[0-9]+$",
+          "x-native-type": JsonSchemaXNativeType.BigInt
+        };
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodNaN: {
@@ -558,7 +578,11 @@ class ZodToJsonSchemaConverter {
         return [true, { type: "boolean" }];
       }
       case ZodFirstPartyTypeKind.ZodDate: {
-        const schema2 = { type: "string", format: JSONSchemaFormat.DateTime };
+        const schema2 = {
+          "type": "string",
+          "format": JSONSchemaFormat.DateTime,
+          "x-native-type": JsonSchemaXNativeType.Date
+        };
         return [true, schema2];
       }
       case ZodFirstPartyTypeKind.ZodNull: {
@@ -591,7 +615,7 @@ class ZodToJsonSchemaConverter {
         const schema_ = schema;
         const def2 = schema_._def;
         const json = { type: "array" };
-        const [itemRequired, itemJson] = this.convert(def2.type, options, lazyDepth, false, false);
+        const [itemRequired, itemJson] = this.convert(def2.type, options, lazyDepth, false, false, structureDepth + 1);
         json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         if (def2.exactLength) {
           json.maxItems = def2.exactLength.value;
@@ -610,7 +634,7 @@ class ZodToJsonSchemaConverter {
         const prefixItems = [];
         const json = { type: "array" };
         for (const item of schema_._def.items) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth + 1);
           prefixItems.push(
             this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy)
           );
@@ -619,7 +643,7 @@ class ZodToJsonSchemaConverter {
           json.prefixItems = prefixItems;
         }
         if (schema_._def.rest) {
-          const [itemRequired, itemJson] = this.convert(schema_._def.rest, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(schema_._def.rest, options, lazyDepth, false, false, structureDepth + 1);
           json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         }
         return [true, json];
@@ -630,7 +654,7 @@ class ZodToJsonSchemaConverter {
         const properties = {};
         const required = [];
         for (const [key, value] of Object.entries(schema_.shape)) {
-          const [itemRequired, itemJson] = this.convert(value, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(value, options, lazyDepth, false, false, structureDepth + 1);
           properties[key] = itemJson;
           if (itemRequired) {
             required.push(key);
@@ -648,7 +672,7 @@ class ZodToJsonSchemaConverter {
             json.additionalProperties = false;
           }
         } else {
-          const [_, addJson] = this.convert(schema_._def.catchall, options, lazyDepth, false, false);
+          const [_, addJson] = this.convert(schema_._def.catchall, options, lazyDepth, false, false, structureDepth + 1);
           json.additionalProperties = addJson;
         }
         return [true, json];
@@ -656,28 +680,32 @@ class ZodToJsonSchemaConverter {
       case ZodFirstPartyTypeKind.ZodRecord: {
         const schema_ = schema;
         const json = { type: "object" };
-        const [__, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false);
+        const [__, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false, structureDepth + 1);
         if (Object.entries(keyJson).some(([k, v]) => k !== "type" || v !== "string")) {
           json.propertyNames = keyJson;
         }
-        const [_, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
+        const [_, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
         json.additionalProperties = itemJson;
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodSet: {
         const schema_ = schema;
-        const json = { type: "array", uniqueItems: true };
-        const [itemRequired, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
+        const json = {
+          "type": "array",
+          "uniqueItems": true,
+          "x-native-type": JsonSchemaXNativeType.Set
+        };
+        const [itemRequired, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
         json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodMap: {
         const schema_ = schema;
-        const [keyRequired, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false);
-        const [valueRequired, valueJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
-        return [true, {
-          type: "array",
-          items: {
+        const [keyRequired, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false, structureDepth + 1);
+        const [valueRequired, valueJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
+        const json = {
+          "type": "array",
+          "items": {
             type: "array",
             prefixItems: [
               this.#toArrayItemJsonSchema(keyRequired, keyJson, options.strategy),
@@ -685,8 +713,10 @@ class ZodToJsonSchemaConverter {
             ],
             maxItems: 2,
             minItems: 2
-          }
-        }];
+          },
+          "x-native-type": JsonSchemaXNativeType.Map
+        };
+        return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodUnion:
       case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
@@ -694,7 +724,7 @@ class ZodToJsonSchemaConverter {
         const anyOf = [];
         let required = true;
         for (const item of schema_._def.options) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           if (!itemRequired) {
             required = false;
             if (itemJson !== this.unsupportedJsonSchema) {
@@ -714,7 +744,7 @@ class ZodToJsonSchemaConverter {
         const allOf = [];
         let required = false;
         for (const item of [schema_._def.left, schema_._def.right]) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           allOf.push(itemJson);
           if (itemRequired) {
             required = true;
@@ -723,25 +753,26 @@ class ZodToJsonSchemaConverter {
         return [required, { allOf }];
       }
       case ZodFirstPartyTypeKind.ZodLazy: {
-        if (lazyDepth >= this.maxLazyDepth) {
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
           return [false, this.anyJsonSchema];
         }
         const schema_ = schema;
-        return this.convert(schema_._def.getter(), options, lazyDepth + 1, false, false);
+        return this.convert(schema_._def.getter(), options, currentLazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodOptional: {
         const schema_ = schema;
-        const [_, inner] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [_, inner] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [false, inner];
       }
       case ZodFirstPartyTypeKind.ZodReadonly: {
         const schema_ = schema;
-        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [required, { ...json, readOnly: true }];
       }
       case ZodFirstPartyTypeKind.ZodDefault: {
         const schema_ = schema;
-        const [_, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [_, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [false, { default: schema_._def.defaultValue(), ...json }];
       }
       case ZodFirstPartyTypeKind.ZodEffects: {
@@ -749,15 +780,15 @@ class ZodToJsonSchemaConverter {
         if (schema_._def.effect.type === "transform" && options.strategy === "output") {
           return [false, this.anyJsonSchema];
         }
-        return this.convert(schema_._def.schema, options, lazyDepth, false, false);
+        return this.convert(schema_._def.schema, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodCatch: {
         const schema_ = schema;
-        return this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        return this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodBranded: {
         const schema_ = schema;
-        return this.convert(schema_._def.type, options, lazyDepth, false, false);
+        return this.convert(schema_._def.type, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodPipeline: {
         const schema_ = schema;
@@ -766,13 +797,14 @@ class ZodToJsonSchemaConverter {
           options,
           lazyDepth,
           false,
-          false
+          false,
+          structureDepth
         );
       }
       case ZodFirstPartyTypeKind.ZodNullable: {
         const schema_ = schema;
-        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
-        return [required, { anyOf: [{ type: "null" }, json] }];
+        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
+        return [required, { anyOf: [json, { type: "null" }] }];
       }
     }
     return [true, this.unsupportedJsonSchema];
@@ -791,12 +823,17 @@ class ZodToJsonSchemaConverter {
       }
       case "regexp": {
         return {
-          type: "string",
-          pattern: "^\\/(.*)\\/([a-z]*)$"
+          "type": "string",
+          "pattern": "^\\/(.*)\\/([a-z]*)$",
+          "x-native-type": JsonSchemaXNativeType.RegExp
         };
       }
       case "url": {
-        return { type: "string", format: JSONSchemaFormat.URI };
+        return {
+          "type": "string",
+          "format": JSONSchemaFormat.URI,
+          "x-native-type": JsonSchemaXNativeType.Url
+        };
       }
     }
   }

package/dist/zod4/index.d.mts

@@ -2,24 +2,35 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
 import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@orpc/openapi';
-import { Interceptor, ThrowableError, Promisable } from '@orpc/shared';
+import { Interceptor } from '@orpc/shared';
 import * as zod_v4_core from 'zod/v4/core';
 import { $ZodType, $input, $output } from 'zod/v4/core';
 
+/**
+ * @deprecated Use [Smart Coercion Plugin](https://orpc.unnoq.com/docs/openapi/plugins/smart-coercion) instead.
+ */
 declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
     #private;
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
-interface experimental_ZodToJsonSchemaOptions {
+interface ZodToJsonSchemaConverterOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type.
      *
-     * Used anyJsonSchema (`{}`) when reach max depth
+     * Used anyJsonSchema (`{}`) when exceed max depth
      *
      * @default 2
      */
     maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
@@ -46,18 +57,19 @@ interface experimental_ZodToJsonSchemaOptions {
     }, [
         required: boolean,
         jsonSchema: Exclude<JSONSchema, boolean>
-    ], ThrowableError>[];
+    ]>[];
 }
-declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
     private readonly interceptors;
-    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 
 /**
@@ -77,7 +89,7 @@ declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchema
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -138,7 +150,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -156,7 +168,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -217,7 +229,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -235,7 +247,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -296,7 +308,7 @@ declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
-export type { experimental_ZodToJsonSchemaOptions };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };
+export type { ZodToJsonSchemaConverterOptions };

package/dist/zod4/index.d.ts

@@ -2,24 +2,35 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
 import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@orpc/openapi';
-import { Interceptor, ThrowableError, Promisable } from '@orpc/shared';
+import { Interceptor } from '@orpc/shared';
 import * as zod_v4_core from 'zod/v4/core';
 import { $ZodType, $input, $output } from 'zod/v4/core';
 
+/**
+ * @deprecated Use [Smart Coercion Plugin](https://orpc.unnoq.com/docs/openapi/plugins/smart-coercion) instead.
+ */
 declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
     #private;
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
-interface experimental_ZodToJsonSchemaOptions {
+interface ZodToJsonSchemaConverterOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type.
      *
-     * Used anyJsonSchema (`{}`) when reach max depth
+     * Used anyJsonSchema (`{}`) when exceed max depth
      *
      * @default 2
      */
     maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
@@ -46,18 +57,19 @@ interface experimental_ZodToJsonSchemaOptions {
     }, [
         required: boolean,
         jsonSchema: Exclude<JSONSchema, boolean>
-    ], ThrowableError>[];
+    ]>[];
 }
-declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
     private readonly interceptors;
-    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 
 /**
@@ -77,7 +89,7 @@ declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchema
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -138,7 +150,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -156,7 +168,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -217,7 +229,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -235,7 +247,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -296,7 +308,7 @@ declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, zod_v4_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
-export type { experimental_ZodToJsonSchemaOptions };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };
+export type { ZodToJsonSchemaConverterOptions };

package/dist/zod4/index.mjs

@@ -1,4 +1,5 @@
-import { isObject, guard, intercept } from '@orpc/shared';
+import { isObject, guard, intercept, toArray } from '@orpc/shared';
+import { JsonSchemaXNativeType } from '@orpc/json-schema';
 import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@orpc/openapi';
 import { registry, globalRegistry } from 'zod/v4/core';
 
@@ -100,8 +101,7 @@ class experimental_ZodSmartCoercionPlugin {
         }
         return value;
       }
-      case "object":
-      case "interface": {
+      case "object": {
         const object = schema;
         if (value === void 0) {
           return {};
@@ -165,9 +165,21 @@ class experimental_ZodSmartCoercionPlugin {
           return this.#coerce(union._zod.def.options[0], value);
         }
         if (isObject(value)) {
+          const discriminator = "discriminator" in union._zod.def && typeof union._zod.def.discriminator === "string" ? union._zod.def.discriminator : void 0;
           for (const option of union._zod.def.options) {
-            if (option._zod.disc && this.#matchDiscriminators(value, option._zod.disc)) {
-              return this.#coerce(option, value);
+            if (!option._zod.propValues) {
+              continue;
+            }
+            if (discriminator !== void 0) {
+              if (option._zod.propValues[discriminator]?.has(value[discriminator])) {
+                return this.#coerce(option, value);
+              }
+            } else {
+              for (const key in option._zod.propValues) {
+                if (option._zod.propValues[key]?.has(value[key])) {
+                  return this.#coerce(option, value);
+                }
+              }
             }
           }
         }
@@ -255,44 +267,22 @@ class experimental_ZodSmartCoercionPlugin {
     }
     return value;
   }
-  /**
-   * This function is inspired from Zod, because it's not exported
-   * https://github.com/colinhacks/zod/blob/v4/packages/core/src/schemas.ts#L1903C1-L1921C2
-   */
-  #matchDiscriminators(input, discs) {
-    for (const [key, value] of discs) {
-      const data = input[key];
-      if (value.values.size && !value.values.has(data)) {
-        return false;
-      }
-      if (value.maps.length === 0) {
-        continue;
-      }
-      if (!isObject(data)) {
-        return false;
-      }
-      for (const m of value.maps) {
-        if (!this.#matchDiscriminators(data, m)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
 }
 
-const experimental_JSON_SCHEMA_REGISTRY = registry();
-const experimental_JSON_SCHEMA_INPUT_REGISTRY = registry();
-const experimental_JSON_SCHEMA_OUTPUT_REGISTRY = registry();
+const JSON_SCHEMA_REGISTRY = registry();
+const JSON_SCHEMA_INPUT_REGISTRY = registry();
+const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
 
-class experimental_ZodToJsonSchemaConverter {
+class ZodToJsonSchemaConverter {
   maxLazyDepth;
+  maxStructureDepth;
   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: {} };
@@ -302,17 +292,28 @@ class experimental_ZodToJsonSchemaConverter {
     return schema !== void 0 && schema["~standard"].vendor === "zod";
   }
   convert(schema, options) {
-    return this.#convert(schema, options, 0);
+    return this.#convert(schema, options, 0, 0);
   }
-  #convert(schema, options, lazyDepth, isHandledCustomJSONSchema = false) {
+  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
     return intercept(
       this.interceptors,
       { schema, options, lazyDepth, isHandledCustomJSONSchema },
-      async ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+      ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+        if (structureDepth > this.maxStructureDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        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 (!isHandledCustomJSONSchema2) {
           const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
           if (customJSONSchema) {
-            const [required, json] = await this.#convert(schema2, options2, lazyDepth2, true);
+            const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);
             return [required, { ...json, ...customJSONSchema }];
           }
         }
@@ -320,21 +321,28 @@ class experimental_ZodToJsonSchemaConverter {
           case "string": {
             const string = schema2;
             const json = { type: "string" };
-            const { minimum, maximum, format, pattern, contentEncoding } = string._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+            if (typeof minimum === "number") {
               json.minLength = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxLength = maximum;
             }
-            if (contentEncoding !== void 0) {
+            if (typeof contentEncoding === "string") {
               json.contentEncoding = this.#handleContentEncoding(contentEncoding);
             }
-            if (format !== void 0 && format !== "regex" && json.contentEncoding === void 0) {
+            if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
               json.format = this.#handleStringFormat(format);
             }
-            if (pattern !== void 0 && json.contentEncoding === void 0 && json.format === void 0) {
-              json.pattern = pattern.source;
+            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;
@@ -344,25 +352,23 @@ class experimental_ZodToJsonSchemaConverter {
           case "number": {
             const number = schema2;
             const json = { type: "number" };
-            const { minimum, maximum, format, multipleOf, inclusive } = number._zod.computed;
-            if (format?.includes("int")) {
+            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+            if (typeof format === "string" && format?.includes("int")) {
               json.type = "integer";
             }
-            if (minimum !== void 0) {
-              if (inclusive) {
-                json.minimum = minimum;
-              } else {
-                json.exclusiveMinimum = minimum;
-              }
+            if (typeof minimum === "number") {
+              json.minimum = minimum;
             }
-            if (maximum !== void 0) {
-              if (inclusive) {
-                json.maximum = maximum;
-              } else {
-                json.exclusiveMaximum = maximum;
-              }
+            if (typeof maximum === "number") {
+              json.maximum = maximum;
+            }
+            if (typeof exclusiveMinimum === "number") {
+              json.exclusiveMinimum = exclusiveMinimum;
             }
-            if (multipleOf !== void 0) {
+            if (typeof exclusiveMaximum === "number") {
+              json.exclusiveMaximum = exclusiveMaximum;
+            }
+            if (typeof multipleOf === "number") {
               json.multipleOf = multipleOf;
             }
             return [true, json];
@@ -371,10 +377,18 @@ class experimental_ZodToJsonSchemaConverter {
             return [true, { type: "boolean" }];
           }
           case "bigint": {
-            return [true, { type: "string", pattern: "^-?[0-9]+$" }];
+            return [true, {
+              "type": "string",
+              "pattern": "^-?[0-9]+$",
+              "x-native-type": JsonSchemaXNativeType.BigInt
+            }];
           }
           case "date": {
-            return [true, { type: "string", format: JSONSchemaFormat.DateTime }];
+            return [true, {
+              "type": "string",
+              "format": JSONSchemaFormat.DateTime,
+              "x-native-type": JsonSchemaXNativeType.Date
+            }];
           }
           case "null": {
             return [true, { type: "null" }];
@@ -395,21 +409,21 @@ class experimental_ZodToJsonSchemaConverter {
           case "array": {
             const array = schema2;
             const json = { type: "array" };
-            const { minimum, maximum } = array._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum } = array._zod.bag;
+            if (typeof minimum === "number") {
               json.minItems = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxItems = maximum;
             }
-            json.items = this.#handleArrayItemJsonSchema(await this.#convert(array._zod.def.element, options2, lazyDepth2), options2);
+            json.items = this.#handleArrayItemJsonSchema(this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1), options2);
             return [true, json];
           }
           case "object": {
             const object = schema2;
             const json = { type: "object" };
             for (const [key, value] of Object.entries(object._zod.def.shape)) {
-              const [itemRequired, itemJson] = await this.#convert(value, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);
               json.properties ??= {};
               json.properties[key] = itemJson;
               if (itemRequired) {
@@ -421,7 +435,7 @@ class experimental_ZodToJsonSchemaConverter {
               if (object._zod.def.catchall._zod.def.type === "never") {
                 json.additionalProperties = false;
               } else {
-                const [_, addJson] = await this.#convert(object._zod.def.catchall, options2, lazyDepth2);
+                const [_, addJson] = this.#convert(object._zod.def.catchall, options2, lazyDepth2, structureDepth + 1);
                 json.additionalProperties = addJson;
               }
             }
@@ -432,7 +446,7 @@ class experimental_ZodToJsonSchemaConverter {
             const anyOf = [];
             let required = true;
             for (const item of union._zod.def.options) {
-              const [itemRequired, itemJson] = await this.#convert(item, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
               if (!itemRequired) {
                 required = false;
               }
@@ -453,7 +467,7 @@ class experimental_ZodToJsonSchemaConverter {
             const json = { allOf: [] };
             let required = false;
             for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
-              const [itemRequired, itemJson] = await this.#convert(item, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
               json.allOf.push(itemJson);
               if (itemRequired) {
                 required = true;
@@ -465,16 +479,16 @@ class experimental_ZodToJsonSchemaConverter {
             const tuple = schema2;
             const json = { type: "array", prefixItems: [] };
             for (const item of tuple._zod.def.items) {
-              json.prefixItems.push(this.#handleArrayItemJsonSchema(await this.#convert(item, options2, lazyDepth2), options2));
+              json.prefixItems.push(this.#handleArrayItemJsonSchema(this.#convert(item, options2, lazyDepth2, structureDepth + 1), options2));
             }
             if (tuple._zod.def.rest) {
-              json.items = this.#handleArrayItemJsonSchema(await this.#convert(tuple._zod.def.rest, options2, lazyDepth2), options2);
+              json.items = this.#handleArrayItemJsonSchema(this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1), options2);
             }
-            const { minimum, maximum } = tuple._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum } = tuple._zod.bag;
+            if (typeof minimum === "number") {
               json.minItems = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxItems = maximum;
             }
             return [true, json];
@@ -482,31 +496,33 @@ class experimental_ZodToJsonSchemaConverter {
           case "record": {
             const record = schema2;
             const json = { type: "object" };
-            json.propertyNames = (await this.#convert(record._zod.def.keyType, options2, lazyDepth2))[1];
-            json.additionalProperties = (await this.#convert(record._zod.def.valueType, options2, lazyDepth2))[1];
+            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",
+              "items": {
                 type: "array",
                 prefixItems: [
-                  this.#handleArrayItemJsonSchema(await this.#convert(map._zod.def.keyType, options2, lazyDepth2), options2),
-                  this.#handleArrayItemJsonSchema(await this.#convert(map._zod.def.valueType, options2, lazyDepth2), options2)
+                  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(await this.#convert(set._zod.def.valueType, options2, lazyDepth2), options2)
+              "type": "array",
+              "uniqueItems": true,
+              "items": this.#handleArrayItemJsonSchema(this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2),
+              "x-native-type": JsonSchemaXNativeType.Set
             }];
           }
           case "enum": {
@@ -530,12 +546,14 @@ class experimental_ZodToJsonSchemaConverter {
           case "file": {
             const file = schema2;
             const oneOf = [];
-            const { mime } = file._zod.computed;
-            for (const type of mime ?? ["*/*"]) {
-              oneOf.push({
-                type: "string",
-                contentMediaType: type
-              });
+            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 }];
           }
@@ -544,12 +562,12 @@ class experimental_ZodToJsonSchemaConverter {
           }
           case "nullable": {
             const nullable = schema2;
-            const [required, json] = await this.#convert(nullable._zod.def.innerType, options2, lazyDepth2);
+            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] = await this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [true, json];
           }
           case "success": {
@@ -558,7 +576,7 @@ class experimental_ZodToJsonSchemaConverter {
           case "default":
           case "prefault": {
             const default_ = schema2;
-            const [, json] = await this.#convert(default_._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [false, {
               ...json,
               default: default_._zod.def.defaultValue
@@ -566,18 +584,18 @@ class experimental_ZodToJsonSchemaConverter {
           }
           case "catch": {
             const catch_ = schema2;
-            return await this.#convert(catch_._zod.def.innerType, options2, lazyDepth2);
+            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 await this.#convert(options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out, options2, lazyDepth2);
+            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] = await this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2);
+            const [required, json] = this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [required, { ...json, readOnly: true }];
           }
           case "template_literal": {
@@ -589,15 +607,16 @@ class experimental_ZodToJsonSchemaConverter {
           }
           case "optional": {
             const optional = schema2;
-            const [, json] = await this.#convert(optional._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [false, json];
           }
           case "lazy": {
             const lazy = schema2;
-            if (lazyDepth2 >= this.maxLazyDepth) {
+            const currentLazyDepth = lazyDepth2 + 1;
+            if (currentLazyDepth > this.maxLazyDepth) {
               return [false, this.anyJsonSchema];
             }
-            return await this.#convert(lazy._zod.def.getter(), options2, lazyDepth2 + 1);
+            return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);
           }
           default: {
             schema2._zod.def.type;
@@ -608,20 +627,21 @@ class experimental_ZodToJsonSchemaConverter {
     );
   }
   #getCustomJsonSchema(schema, options) {
-    if (options.strategy === "input" && experimental_JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
     }
-    if (options.strategy === "output" && experimental_JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
     }
-    if (experimental_JSON_SCHEMA_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_REGISTRY.get(schema);
+    if (JSON_SCHEMA_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_REGISTRY.get(schema);
     }
     const global = globalRegistry.get(schema);
     if (global) {
       return {
+        title: global.title,
         description: global.description,
-        examples: global.examples
+        examples: Array.isArray(global.examples) ? global.examples : void 0
       };
     }
   }
@@ -657,4 +677,4 @@ class experimental_ZodToJsonSchemaConverter {
   }
 }
 
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/zod",
   "type": "module",
-  "version": "0.0.0-next.f4ed9ab",
+  "version": "0.0.0-next.f50512c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,19 +29,19 @@
     "dist"
   ],
   "peerDependencies": {
-    "zod": ">=3.24.2",
-    "@orpc/contract": "0.0.0-next.f4ed9ab",
-    "@orpc/server": "0.0.0-next.f4ed9ab"
+    "zod": ">=3.25.0",
+    "@orpc/contract": "0.0.0-next.f50512c",
+    "@orpc/server": "0.0.0-next.f50512c"
   },
   "dependencies": {
     "escape-string-regexp": "^5.0.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/openapi": "0.0.0-next.f4ed9ab",
-    "@orpc/shared": "0.0.0-next.f4ed9ab"
+    "@orpc/json-schema": "0.0.0-next.f50512c",
+    "@orpc/openapi": "0.0.0-next.f50512c",
+    "@orpc/shared": "0.0.0-next.f50512c"
   },
   "devDependencies": {
-    "zod": "3.25.0-beta.20250516T005923",
-    "zod-to-json-schema": "^3.24.5"
+    "zod": "^4.0.5"
   },
   "scripts": {
     "build": "unbuild",