@orpc/zod 2.0.0-beta.47 → 2.0.0-beta.49

package/README.md

@@ -5,7 +5,7 @@
     <img alt="codecov" src="https://codecov.io/gh/middleapi/orpc/branch/main/graph/badge.svg">
   </a>
   <a href="https://www.npmjs.com/package/@orpc/zod">
-    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fzod?logo=npm" />
+    <img alt="monthly downloads" src="https://img.shields.io/npm/dm/%40orpc%2Fzod?logo=npm" />
   </a>
   <a href="https://app.codspeed.io/middleapi/orpc?utm_source=badge">
     <img alt="CodSpeed" src="https://img.shields.io/endpoint?url=https://codspeed.io/badge.json" />
@@ -41,10 +41,11 @@ export const router = {
 Then call them from a client that knows every input and output, without generating anything:
 
 ```ts
-import type { RouterClient } from '@orpc/server'
-import type { router } from './router'
 import { createORPCClient } from '@orpc/client'
 import { RPCLink } from '@orpc/client/fetch'
+import type { RouterClient } from '@orpc/server'
+
+import type { router } from './router'
 
 const link = new RPCLink({ origin: 'http://localhost:3000', url: '/rpc' })
 const client: RouterClient<typeof router> = createORPCClient(link)
@@ -191,15 +192,14 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
    <td align="center"><a href="https://kellychan.im/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Kelly Peilin Chan"><img src="https://avatars.githubusercontent.com/u/520852?u=6b0f7105f694e7b5cacf410a3f04c7044b469dc8&amp;v=4" width="139" alt="Kelly Peilin Chan"/><br />Kelly Peilin Chan</a></td>
    <td align="center"><a href="https://guyariely.com/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Guy Ariely"><img src="https://avatars.githubusercontent.com/u/42813496?u=edb6b7f563bf28e160a290832e7da57c0506f8ca&amp;v=4" width="139" alt="Guy Ariely"/><br />Guy Ariely</a></td>
    <td align="center"><a href="https://paulsenon.com/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="PaulSenon"><img src="https://avatars.githubusercontent.com/u/19531087?u=6385741eb91d200b8c513ec6045482e301767ca6&amp;v=4" width="139" alt="PaulSenon"/><br />PaulSenon</a></td>
-   <td align="center"><a href="https://nakasyou.how/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Shotaro Nakamura"><img src="https://avatars.githubusercontent.com/u/79000684?u=f644df3f29f0e8677a90967115774564f1d9d6ab&amp;v=4" width="139" alt="Shotaro Nakamura"/><br />Shotaro Nakamura</a></td>
+   <td align="center"><a href="https://piscis.dev/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Alex"><img src="https://avatars.githubusercontent.com/u/326163?u=b245f368bd940cf51d08c0b6bf55f8257f359437&amp;v=4" width="139" alt="Alex"/><br />Alex</a></td>
   </tr>
   <tr>
-   <td align="center"><a href="https://piscis.dev/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Alex"><img src="https://avatars.githubusercontent.com/u/326163?u=b245f368bd940cf51d08c0b6bf55f8257f359437&amp;v=4" width="139" alt="Alex"/><br />Alex</a></td>
    <td align="center"><a href="https://opensource.gubanov.eu/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Andrey Gubanov"><img src="https://avatars.githubusercontent.com/u/1082083?u=c5f2daf7ebece498e85c83367bb37b4e10e2649d&amp;v=4" width="139" alt="Andrey Gubanov"/><br />Andrey Gubanov</a></td>
   </tr>
 </table>
 
-With thanks to [39 past sponsors](https://orpc.dev/sponsors#past-sponsors) who helped get oRPC here.
+With thanks to [40 past sponsors](https://orpc.dev/sponsors#past-sponsors) who helped get oRPC here.
 
 ## Open Source Programs
 
@@ -209,7 +209,6 @@ With thanks to [39 past sponsors](https://orpc.dev/sponsors#past-sponsors) who h
   <tr>
    <td align="center"><a href="https://claude.com/contact-sales/claude-for-oss" target="_blank" rel="noopener" title="Claude for Open Source"><img src="https://cdn.simpleicons.org/claude" width="64" alt="Claude"/><br />Claude</a></td>
    <td align="center"><a href="https://pullfrog.com/for-oss" target="_blank" rel="noopener" title="Pullfrog for OSS"><img src="https://avatars.githubusercontent.com/in/1768019?s=128&amp;v=4" width="64" alt="Pullfrog"/><br />Pullfrog</a></td>
-   <td align="center"><a href="https://macroscope.com/open-source" target="_blank" rel="noopener" title="Macroscope for Open Source"><img src="https://avatars.githubusercontent.com/in/900172?s=128&amp;v=4" width="64" alt="Macroscope"/><br />Macroscope</a></td>
   </tr>
 </table>
 

package/dist/converter.d.ts

@@ -0,0 +1,30 @@
+import type { AnySchema, JsonSchema, JsonSchemaConverter, JsonSchemaConverterDirection } from '@orpc/json-schema';
+import type { ToJSONSchemaParams } from 'zod/v4/core';
+export interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams, 'target' | 'io'> {
+    /**
+     * Caches conversion results in a WeakMap keyed by the Zod schema instance,
+     * so converting the same schema again is free.
+     *
+     * When enabled, repeated conversions return the same JSON schema object,
+     * so treat returned schemas as immutable.
+     *
+     * @default false
+     */
+    cache?: boolean | undefined;
+}
+/**
+ * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
+ * with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export declare class ZodToJsonSchemaConverter implements JsonSchemaConverter {
+    private readonly toJSONSchemaParams;
+    private readonly cache;
+    constructor({ cache, ...toJSONSchemaParams }?: ZodToJsonSchemaConverterOptions);
+    condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
+    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
+    private convertUncached;
+    private convertZod;
+    private getCustomJsonSchema;
+}

package/dist/converter.js

@@ -0,0 +1,123 @@
+import { isStandardSchemaOptional, JsonSchemaFormat, JsonSchemaXNativeType, } from '@orpc/json-schema';
+import { process as processZodSchema, toJSONSchema } from 'zod/v4/core';
+import { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, } from './registries.js';
+/**
+ * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
+ * with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export class ZodToJsonSchemaConverter {
+    toJSONSchemaParams;
+    cache;
+    constructor({ cache, ...toJSONSchemaParams } = {}) {
+        this.toJSONSchemaParams = toJSONSchemaParams;
+        if (cache) {
+            this.cache = { input: new WeakMap(), output: new WeakMap() };
+        }
+    }
+    condition(schema, _direction) {
+        return schema?.['~standard'].vendor === 'zod';
+    }
+    convert(schema, direction) {
+        const zodSchema = schema;
+        if (this.cache) {
+            const cached = this.cache[direction].get(zodSchema);
+            if (cached) {
+                return cached;
+            }
+        }
+        const result = this.convertUncached(zodSchema, direction);
+        if (this.cache) {
+            this.cache[direction].set(zodSchema, result);
+        }
+        return result;
+    }
+    convertUncached(zodSchema, direction) {
+        const jsonSchema = this.convertZod(zodSchema, direction);
+        return [jsonSchema, isStandardSchemaOptional(zodSchema, direction)];
+    }
+    convertZod(schema, direction) {
+        const { unrepresentable = 'any' } = this.toJSONSchemaParams;
+        const jsonSchema = toJSONSchema(schema, {
+            ...this.toJSONSchemaParams,
+            target: 'draft-2020-12',
+            io: direction,
+            unrepresentable(info) {
+                return (convertNativeType(this, info.zodSchema, info.path) ??
+                    (typeof unrepresentable === 'function' ? unrepresentable(info) : unrepresentable));
+            },
+            override: (ctx) => {
+                const customJsonSchema = this.getCustomJsonSchema(ctx.zodSchema, direction);
+                if (customJsonSchema) {
+                    Object.assign(ctx.jsonSchema, customJsonSchema);
+                }
+                this.toJSONSchemaParams.override?.(ctx);
+            },
+        });
+        // Since the default oRPC format is always draft/2020-12,
+        // `$schema` can be safely omitted here.
+        const { $schema: _schema, ...rest } = jsonSchema;
+        return rest;
+    }
+    getCustomJsonSchema(schema, direction) {
+        const general = JSON_SCHEMA_REGISTRY.get(schema);
+        const directional = direction === 'input'
+            ? JSON_SCHEMA_INPUT_REGISTRY.get(schema)
+            : JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+        if (general === undefined && directional === undefined) {
+            return undefined;
+        }
+        return { ...general, ...directional };
+    }
+}
+function convertNativeType(ctx, zodSchema, path) {
+    const def = zodSchema._zod.def;
+    switch (def.type) {
+        case 'bigint':
+            return {
+                'type': 'string',
+                'pattern': '^-?[0-9]+$',
+                'x-native-type': JsonSchemaXNativeType.BigInt,
+            };
+        case 'date':
+            return {
+                'type': 'string',
+                'format': JsonSchemaFormat.DateTime,
+                'x-native-type': JsonSchemaXNativeType.Date,
+            };
+        case 'set':
+        case 'map': {
+            const schemaPath = [];
+            for (const [seenSchema, seen] of ctx.seen) {
+                if (seen.path &&
+                    seen.path.length <= path.length &&
+                    seen.path.every((segment, i) => segment === path[i])) {
+                    schemaPath.push(seenSchema);
+                }
+            }
+            const processItems = (schema, ...segments) => processZodSchema(schema, ctx, { path: [...path, 'items', ...segments], schemaPath });
+            return def.type === 'set'
+                ? {
+                    'type': 'array',
+                    'uniqueItems': true,
+                    'items': processItems(def.valueType),
+                    'x-native-type': JsonSchemaXNativeType.Set,
+                }
+                : {
+                    'type': 'array',
+                    'items': {
+                        type: 'array',
+                        prefixItems: [
+                            processItems(def.keyType, 'prefixItems', 0),
+                            processItems(def.valueType, 'prefixItems', 1),
+                        ],
+                        maxItems: 2,
+                        minItems: 2,
+                    },
+                    'x-native-type': JsonSchemaXNativeType.Map,
+                };
+        }
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -1,98 +1,3 @@
-import { JsonSchemaConverter, AnySchema, JsonSchemaConverterDirection, JsonSchema } from '@orpc/json-schema';
-export { JsonSchema } from '@orpc/json-schema';
-import * as zod_v4_core from 'zod/v4/core';
-import { ToJSONSchemaParams, $input, $output } from 'zod/v4/core';
-import * as _openapi_spec_types_v3_2 from '@openapi-spec/types/v3.2';
-
-interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams, 'target' | 'io'> {
-    /**
-     * Caches conversion results in a WeakMap keyed by the Zod schema instance,
-     * so converting the same schema again is free.
-     *
-     * When enabled, repeated conversions return the same JSON schema object,
-     * so treat returned schemas as immutable.
-     *
-     * @default false
-     */
-    cache?: boolean | undefined;
-}
-/**
- * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
- * with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare class ZodToJsonSchemaConverter implements JsonSchemaConverter {
-    private readonly toJSONSchemaParams;
-    private readonly cache;
-    constructor({ cache, ...toJSONSchemaParams }?: ZodToJsonSchemaConverterOptions);
-    condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
-    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
-    private convertUncached;
-    private convertZod;
-    private getCustomJsonSchema;
-}
-
-/**
- * Zod registry for customizing generated JSON schema, can use both for .input and .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * })
- *
- * JSON_SCHEMA_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $input | typeof $output>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * Zod registry for customizing generated JSON schema, only useful for .input
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_INPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: "20" }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $input>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * Zod registry for customizing generated JSON schema, only useful for .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $output>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-
-export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter };
-export type { ZodToJsonSchemaConverterOptions };
+export * from './converter.ts';
+export * from './registries.ts';
+export type { JsonSchema } from '@orpc/json-schema';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './converter.js';
+export * from './registries.js';

package/dist/registries.d.ts

@@ -0,0 +1,62 @@
+import type { JsonSchema } from '@orpc/json-schema';
+import type { $input, $output, $ZodRegistry } from 'zod/v4/core';
+/**
+ * Zod registry for customizing generated JSON schema, can use both for .input and .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export declare const JSON_SCHEMA_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input | $output>, boolean>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_INPUT_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: "20" }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export declare const JSON_SCHEMA_INPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input>, boolean>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export declare const JSON_SCHEMA_OUTPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$output>, boolean>>;

package/dist/registries.js

@@ -0,0 +1,64 @@
+import { registry } from 'zod/v4/core';
+/**
+ * Zod registry for customizing generated JSON schema, can use both for .input and .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export const JSON_SCHEMA_REGISTRY = 
+/* @__PURE__ */ registry();
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_INPUT_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: "20" }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export const JSON_SCHEMA_INPUT_REGISTRY = 
+/* @__PURE__ */ registry();
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+ */
+export const JSON_SCHEMA_OUTPUT_REGISTRY = 
+/* @__PURE__ */ registry();

package/package.json

@@ -1,51 +1,48 @@
 {
   "name": "@orpc/zod",
-  "type": "module",
-  "version": "2.0.0-beta.47",
+  "version": "2.0.0-beta.49",
   "description": "Zod integration for oRPC: convert Zod schemas into JSON Schema for OpenAPI generation",
-  "license": "MIT",
-  "funding": [
-    "https://github.com/sponsors/dinwwwh",
-    "https://opencollective.com/middleapi"
+  "keywords": [
+    "json-schema",
+    "openapi",
+    "orpc",
+    "typesafe",
+    "typescript",
+    "validation",
+    "zod"
   ],
   "homepage": "https://orpc.dev",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/middleapi/orpc.git",
     "directory": "packages/zod"
   },
-  "keywords": [
-    "orpc",
-    "zod",
-    "json-schema",
-    "openapi",
-    "validation",
-    "typescript",
-    "typesafe"
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
   ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
-  "files": [
-    "dist"
-  ],
-  "peerDependencies": {
-    "zod": ">=4.5.0"
-  },
   "dependencies": {
-    "@openapi-spec/types": "~0.4.0",
-    "@orpc/json-schema": "2.0.0-beta.47"
+    "@orpc/json-schema": "2.0.0-beta.49"
   },
   "devDependencies": {
     "zod": "^4.6.7"
   },
-  "scripts": {
-    "type:check": "tsc -b"
-  }
+  "peerDependencies": {
+    "zod": ">=4.5.0"
+  },
+  "scripts": {}
 }

package/dist/index.d.mts

@@ -1,98 +0,0 @@
-import { JsonSchemaConverter, AnySchema, JsonSchemaConverterDirection, JsonSchema } from '@orpc/json-schema';
-export { JsonSchema } from '@orpc/json-schema';
-import * as zod_v4_core from 'zod/v4/core';
-import { ToJSONSchemaParams, $input, $output } from 'zod/v4/core';
-import * as _openapi_spec_types_v3_2 from '@openapi-spec/types/v3.2';
-
-interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams, 'target' | 'io'> {
-    /**
-     * Caches conversion results in a WeakMap keyed by the Zod schema instance,
-     * so converting the same schema again is free.
-     *
-     * When enabled, repeated conversions return the same JSON schema object,
-     * so treat returned schemas as immutable.
-     *
-     * @default false
-     */
-    cache?: boolean | undefined;
-}
-/**
- * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
- * with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare class ZodToJsonSchemaConverter implements JsonSchemaConverter {
-    private readonly toJSONSchemaParams;
-    private readonly cache;
-    constructor({ cache, ...toJSONSchemaParams }?: ZodToJsonSchemaConverterOptions);
-    condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
-    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
-    private convertUncached;
-    private convertZod;
-    private getCustomJsonSchema;
-}
-
-/**
- * Zod registry for customizing generated JSON schema, can use both for .input and .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * })
- *
- * JSON_SCHEMA_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $input | typeof $output>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * Zod registry for customizing generated JSON schema, only useful for .input
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_INPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: "20" }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $input>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-/**
- * Zod registry for customizing generated JSON schema, only useful for .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<_openapi_spec_types_v3_2.SchemaObjectFields<typeof $output>, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-
-export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter };
-export type { ZodToJsonSchemaConverterOptions };

package/dist/index.mjs

@@ -1,97 +0,0 @@
-import { isStandardSchemaOptional, JsonSchemaXNativeType, JsonSchemaFormat } from '@orpc/json-schema';
-import { registry, toJSONSchema, process } from 'zod/v4/core';
-
-const JSON_SCHEMA_REGISTRY = registry();
-const JSON_SCHEMA_INPUT_REGISTRY = registry();
-const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
-
-class ZodToJsonSchemaConverter {
-  toJSONSchemaParams;
-  cache;
-  constructor({ cache, ...toJSONSchemaParams } = {}) {
-    this.toJSONSchemaParams = toJSONSchemaParams;
-    if (cache) {
-      this.cache = { input: /* @__PURE__ */ new WeakMap(), output: /* @__PURE__ */ new WeakMap() };
-    }
-  }
-  condition(schema, _direction) {
-    return schema?.["~standard"].vendor === "zod";
-  }
-  convert(schema, direction) {
-    const zodSchema = schema;
-    if (this.cache) {
-      const cached = this.cache[direction].get(zodSchema);
-      if (cached) {
-        return cached;
-      }
-    }
-    const result = this.convertUncached(zodSchema, direction);
-    if (this.cache) {
-      this.cache[direction].set(zodSchema, result);
-    }
-    return result;
-  }
-  convertUncached(zodSchema, direction) {
-    const jsonSchema = this.convertZod(zodSchema, direction);
-    return [jsonSchema, isStandardSchemaOptional(zodSchema, direction)];
-  }
-  convertZod(schema, direction) {
-    const { unrepresentable = "any" } = this.toJSONSchemaParams;
-    const jsonSchema = toJSONSchema(schema, {
-      ...this.toJSONSchemaParams,
-      target: "draft-2020-12",
-      io: direction,
-      unrepresentable(info) {
-        return convertNativeType(this, info.zodSchema, info.path) ?? (typeof unrepresentable === "function" ? unrepresentable(info) : unrepresentable);
-      },
-      override: (ctx) => {
-        const customJsonSchema = this.getCustomJsonSchema(ctx.zodSchema, direction);
-        if (customJsonSchema) {
-          Object.assign(ctx.jsonSchema, customJsonSchema);
-        }
-        this.toJSONSchemaParams.override?.(ctx);
-      }
-    });
-    const { $schema, ...rest } = jsonSchema;
-    return rest;
-  }
-  getCustomJsonSchema(schema, direction) {
-    const general = JSON_SCHEMA_REGISTRY.get(schema);
-    const directional = direction === "input" ? JSON_SCHEMA_INPUT_REGISTRY.get(schema) : JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
-    if (general === void 0 && directional === void 0) {
-      return void 0;
-    }
-    return { ...general, ...directional };
-  }
-}
-function convertNativeType(ctx, zodSchema, path) {
-  const def = zodSchema._zod.def;
-  switch (def.type) {
-    case "bigint":
-      return { "type": "string", "pattern": "^-?[0-9]+$", "x-native-type": JsonSchemaXNativeType.BigInt };
-    case "date":
-      return { "type": "string", "format": JsonSchemaFormat.DateTime, "x-native-type": JsonSchemaXNativeType.Date };
-    case "set":
-    case "map": {
-      const schemaPath = [];
-      for (const [seenSchema, seen] of ctx.seen) {
-        if (seen.path && seen.path.length <= path.length && seen.path.every((segment, i) => segment === path[i])) {
-          schemaPath.push(seenSchema);
-        }
-      }
-      const processItems = (schema, ...segments) => process(schema, ctx, { path: [...path, "items", ...segments], schemaPath });
-      return def.type === "set" ? { "type": "array", "uniqueItems": true, "items": processItems(def.valueType), "x-native-type": JsonSchemaXNativeType.Set } : {
-        "type": "array",
-        "items": {
-          type: "array",
-          prefixItems: [processItems(def.keyType, "prefixItems", 0), processItems(def.valueType, "prefixItems", 1)],
-          maxItems: 2,
-          minItems: 2
-        },
-        "x-native-type": JsonSchemaXNativeType.Map
-      };
-    }
-  }
-}
-
-export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter };