@orpc/zod 0.0.0-next.f81b4a2 → 0.0.0-next.fcb9d5a

package/README.md

@@ -21,28 +21,24 @@
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
 
-**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
 
 ---
 
 ## Highlights
 
-- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
-- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
-- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
-- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
-- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
-- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
-- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
-- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
-- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
-- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
-- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
-- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
-- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
-- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
-- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+- **🔗 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.
+- **🚀 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.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -53,6 +49,7 @@ 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/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).

package/dist/zod4/index.d.mts

@@ -0,0 +1,302 @@
+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 * as _zod_core from '@zod/core';
+import { $ZodType, $input, $output } from '@zod/core';
+
+declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
+    #private;
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface experimental_ZodToJsonSchemaOptions {
+    /**
+     * Max depth of lazy type, if it exceeds.
+     *
+     * Used anyJsonSchema (`{}`) when reach max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: 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>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+    interceptors?: Interceptor<{
+        schema: $ZodType;
+        options: SchemaConvertOptions;
+        lazyDepth: number;
+        isHandledCustomJSONSchema: boolean;
+    }, [
+        required: boolean,
+        jsonSchema: Exclude<JSONSchema, boolean>
+    ], ThrowableError>[];
+}
+declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    private readonly interceptors;
+    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    condition(schema: AnySchema | undefined): boolean;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+}
+
+/**
+ * Zod registry for customizing generated JSON schema, can use both for .input and .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | typeof $output | undefined;
+    contains?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    examples?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<unknown, unknown>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: "20" }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | undefined;
+    contains?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    examples?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<unknown, unknown>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * 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 }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $output | undefined;
+    contains?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    examples?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<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 };

package/dist/zod4/index.d.ts

@@ -0,0 +1,302 @@
+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 * as _zod_core from '@zod/core';
+import { $ZodType, $input, $output } from '@zod/core';
+
+declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
+    #private;
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface experimental_ZodToJsonSchemaOptions {
+    /**
+     * Max depth of lazy type, if it exceeds.
+     *
+     * Used anyJsonSchema (`{}`) when reach max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: 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>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+    interceptors?: Interceptor<{
+        schema: $ZodType;
+        options: SchemaConvertOptions;
+        lazyDepth: number;
+        isHandledCustomJSONSchema: boolean;
+    }, [
+        required: boolean,
+        jsonSchema: Exclude<JSONSchema, boolean>
+    ], ThrowableError>[];
+}
+declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    private readonly interceptors;
+    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    condition(schema: AnySchema | undefined): boolean;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+}
+
+/**
+ * Zod registry for customizing generated JSON schema, can use both for .input and .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | typeof $output | undefined;
+    contains?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    examples?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<unknown, unknown>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: "20" }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | undefined;
+    contains?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    examples?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<unknown, unknown>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod/zod4'
+ *
+ * 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 }],
+ * })
+ * ```
+ */
+declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $output | undefined;
+    contains?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    examples?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, _zod_core.$ZodType<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 };

package/dist/zod4/index.mjs

@@ -0,0 +1,653 @@
+import { isObject, guard, intercept } from '@orpc/shared';
+import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@orpc/openapi';
+import { registry, globalRegistry } from '@zod/core';
+
+class experimental_ZodSmartCoercionPlugin {
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.unshift((options2) => {
+      const inputSchema = options2.procedure["~orpc"].inputSchema;
+      if (!inputSchema || inputSchema["~standard"].vendor !== "zod") {
+        return options2.next();
+      }
+      const coercedInput = this.#coerce(inputSchema, options2.input);
+      return options2.next({ ...options2, input: coercedInput });
+    });
+  }
+  #coerce(schema, value) {
+    switch (schema._zod.def.type) {
+      case "number": {
+        if (typeof value === "string") {
+          return this.#stringToNumber(value);
+        }
+        return value;
+      }
+      case "bigint": {
+        if (typeof value === "string") {
+          return this.#stringToBigInt(value);
+        }
+        return value;
+      }
+      case "boolean":
+      case "success": {
+        if (typeof value === "string") {
+          return this.#stringToBoolean(value);
+        }
+        return value;
+      }
+      case "date": {
+        if (typeof value === "string") {
+          return this.#stringToDate(value);
+        }
+        return value;
+      }
+      case "literal":
+      case "enum": {
+        const literal = schema;
+        if (!literal._zod.values.has(value) && typeof value === "string") {
+          const num = this.#stringToNumber(value);
+          if (literal._zod.values.has(num)) {
+            return num;
+          }
+          const bool = this.#stringToBoolean(value);
+          if (literal._zod.values.has(bool)) {
+            return bool;
+          }
+          const bigint = this.#stringToBigInt(value);
+          if (literal._zod.values.has(bigint)) {
+            return bigint;
+          }
+        }
+        return value;
+      }
+      case "array": {
+        const array = schema;
+        if (value === void 0) {
+          return [];
+        }
+        if (Array.isArray(value)) {
+          return value.map((v) => this.#coerce(array._zod.def.element, v));
+        }
+        return value;
+      }
+      case "tuple": {
+        const tuple = schema;
+        if (value === void 0) {
+          return [];
+        }
+        if (Array.isArray(value)) {
+          return value.map((v, i) => {
+            const s = tuple._zod.def.items[i] ?? tuple._zod.def.rest;
+            return s ? this.#coerce(s, v) : v;
+          });
+        }
+        return value;
+      }
+      case "set": {
+        const set = schema;
+        if (value === void 0) {
+          return /* @__PURE__ */ new Set();
+        }
+        if (Array.isArray(value)) {
+          return new Set(
+            value.map((v) => this.#coerce(set._zod.def.valueType, v))
+          );
+        }
+        if (value instanceof Set) {
+          return new Set(
+            Array.from(value).map((v) => this.#coerce(set._zod.def.valueType, v))
+          );
+        }
+        return value;
+      }
+      case "object":
+      case "interface": {
+        const object = schema;
+        if (value === void 0) {
+          return {};
+        }
+        if (isObject(value)) {
+          const newObj = {};
+          const keys = /* @__PURE__ */ new Set([
+            ...Object.keys(value),
+            ...Object.keys(object._zod.def.shape)
+          ]);
+          for (const k of keys) {
+            const s = object._zod.def.shape[k] ?? object._zod.def.catchall;
+            newObj[k] = s ? this.#coerce(s, value[k]) : value[k];
+          }
+          return newObj;
+        }
+        return value;
+      }
+      case "record": {
+        const record = schema;
+        if (value === void 0) {
+          return {};
+        }
+        if (isObject(value)) {
+          const newObj = {};
+          for (const [k, v] of Object.entries(value)) {
+            const key = this.#coerce(record._zod.def.keyType, k);
+            const val = this.#coerce(record._zod.def.valueType, v);
+            newObj[key] = val;
+          }
+          return newObj;
+        }
+        return value;
+      }
+      case "map": {
+        const map = schema;
+        if (value === void 0) {
+          return /* @__PURE__ */ new Map();
+        }
+        if (Array.isArray(value) && value.every((i) => Array.isArray(i) && i.length <= 2)) {
+          return new Map(
+            value.map(([k, v]) => [
+              this.#coerce(map._zod.def.keyType, k),
+              this.#coerce(map._zod.def.valueType, v)
+            ])
+          );
+        }
+        if (value instanceof Map) {
+          return new Map(
+            Array.from(value).map(([k, v]) => [
+              this.#coerce(map._zod.def.keyType, k),
+              this.#coerce(map._zod.def.valueType, v)
+            ])
+          );
+        }
+        return value;
+      }
+      case "union": {
+        const union = schema;
+        if (union._zod.def.options.length === 1) {
+          return this.#coerce(union._zod.def.options[0], value);
+        }
+        if (isObject(value)) {
+          for (const option of union._zod.def.options) {
+            if (option._zod.disc && this.#matchDiscriminators(value, option._zod.disc)) {
+              return this.#coerce(option, value);
+            }
+          }
+        }
+        return value;
+      }
+      case "intersection": {
+        const intersection = schema;
+        return this.#coerce(
+          intersection._zod.def.right,
+          this.#coerce(intersection._zod.def.left, value)
+        );
+      }
+      case "optional": {
+        const optional = schema;
+        if (value === void 0) {
+          return void 0;
+        }
+        return this.#coerce(optional._zod.def.innerType, value);
+      }
+      case "nonoptional": {
+        const nonoptional = schema;
+        return this.#coerce(nonoptional._zod.def.innerType, value);
+      }
+      case "nullable": {
+        const nullable = schema;
+        if (value === null) {
+          return null;
+        }
+        return this.#coerce(nullable._zod.def.innerType, value);
+      }
+      case "readonly": {
+        const readonly_ = schema;
+        return this.#coerce(readonly_._zod.def.innerType, value);
+      }
+      case "pipe": {
+        const pipe = schema;
+        return this.#coerce(pipe._zod.def.in, value);
+      }
+      case "default":
+      case "catch": {
+        const default_ = schema;
+        return this.#coerce(default_._zod.def.innerType, value);
+      }
+      case "lazy": {
+        const lazy = schema;
+        if (value !== void 0) {
+          return this.#coerce(lazy._zod.def.getter(), value);
+        }
+        return value;
+      }
+      default: {
+        schema._zod.def.type;
+        return value;
+      }
+    }
+  }
+  #stringToNumber(value) {
+    const num = Number(value);
+    return Number.isNaN(num) || num.toString() !== value ? value : num;
+  }
+  #stringToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #stringToBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "false" || lower === "off" || lower === "f") {
+      return false;
+    }
+    if (lower === "true" || lower === "on" || lower === "t") {
+      return true;
+    }
+    return value;
+  }
+  #stringToDate(value) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {
+      return date;
+    }
+    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();
+
+class experimental_ZodToJsonSchemaConverter {
+  maxLazyDepth;
+  anyJsonSchema;
+  unsupportedJsonSchema;
+  undefinedJsonSchema;
+  interceptors;
+  constructor(options = {}) {
+    this.maxLazyDepth = options.maxLazyDepth ?? 2;
+    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";
+  }
+  convert(schema, options) {
+    return this.#convert(schema, options, 0);
+  }
+  #convert(schema, options, lazyDepth, isHandledCustomJSONSchema = false) {
+    return intercept(
+      this.interceptors,
+      { schema, options, lazyDepth, isHandledCustomJSONSchema },
+      async ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+        if (!isHandledCustomJSONSchema2) {
+          const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
+          if (customJSONSchema) {
+            const [required, json] = await this.#convert(schema2, options2, lazyDepth2, true);
+            return [required, { ...json, ...customJSONSchema }];
+          }
+        }
+        switch (schema2._zod.def.type) {
+          case "string": {
+            const string = schema2;
+            const json = { type: "string" };
+            const { minimum, maximum, format, pattern, contentEncoding } = string._zod.computed;
+            if (minimum !== void 0) {
+              json.minLength = minimum;
+            }
+            if (maximum !== void 0) {
+              json.maxLength = maximum;
+            }
+            if (contentEncoding !== void 0) {
+              json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+            }
+            if (format !== void 0 && 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 (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, inclusive } = number._zod.computed;
+            if (format?.includes("int")) {
+              json.type = "integer";
+            }
+            if (minimum !== void 0) {
+              if (inclusive) {
+                json.minimum = minimum;
+              } else {
+                json.exclusiveMinimum = minimum;
+              }
+            }
+            if (maximum !== void 0) {
+              if (inclusive) {
+                json.maximum = maximum;
+              } else {
+                json.exclusiveMaximum = maximum;
+              }
+            }
+            if (multipleOf !== void 0) {
+              json.multipleOf = multipleOf;
+            }
+            return [true, json];
+          }
+          case "boolean": {
+            return [true, { type: "boolean" }];
+          }
+          case "bigint": {
+            return [true, { type: "string", pattern: "^-?[0-9]+$" }];
+          }
+          case "date": {
+            return [true, { type: "string", format: JSONSchemaFormat.DateTime }];
+          }
+          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 = schema2;
+            const json = { type: "array" };
+            const { minimum, maximum } = array._zod.computed;
+            if (minimum !== void 0) {
+              json.minItems = minimum;
+            }
+            if (maximum !== void 0) {
+              json.maxItems = maximum;
+            }
+            json.items = this.#handleArrayItemJsonSchema(await this.#convert(array._zod.def.element, options2, lazyDepth2), 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);
+              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] = await this.#convert(object._zod.def.catchall, options2, lazyDepth2);
+                json.additionalProperties = addJson;
+              }
+            }
+            return [true, json];
+          }
+          case "union": {
+            const union = schema2;
+            const anyOf = [];
+            let required = true;
+            for (const item of union._zod.def.options) {
+              const [itemRequired, itemJson] = await this.#convert(item, options2, lazyDepth2);
+              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);
+                }
+              }
+            }
+            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] = await this.#convert(item, options2, lazyDepth2);
+              json.allOf.push(itemJson);
+              if (itemRequired) {
+                required = true;
+              }
+            }
+            return [required, json];
+          }
+          case "tuple": {
+            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));
+            }
+            if (tuple._zod.def.rest) {
+              json.items = this.#handleArrayItemJsonSchema(await this.#convert(tuple._zod.def.rest, options2, lazyDepth2), options2);
+            }
+            const { minimum, maximum } = tuple._zod.computed;
+            if (minimum !== void 0) {
+              json.minItems = minimum;
+            }
+            if (maximum !== void 0) {
+              json.maxItems = maximum;
+            }
+            return [true, json];
+          }
+          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];
+            return [true, json];
+          }
+          case "map": {
+            const map = schema2;
+            return [true, {
+              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)
+                ],
+                maxItems: 2,
+                minItems: 2
+              }
+            }];
+          }
+          case "set": {
+            const set = schema2;
+            return [true, {
+              type: "array",
+              uniqueItems: true,
+              items: this.#handleArrayItemJsonSchema(await this.#convert(set._zod.def.valueType, options2, lazyDepth2), options2)
+            }];
+          }
+          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.computed;
+            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] = await this.#convert(nullable._zod.def.innerType, options2, lazyDepth2);
+            return [required, { anyOf: [json, { type: "null" }] }];
+          }
+          case "nonoptional": {
+            const nonoptional = schema2;
+            const [, json] = await this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2);
+            return [true, json];
+          }
+          case "success": {
+            return [true, { type: "boolean" }];
+          }
+          case "default": {
+            const default_ = schema2;
+            const [, json] = await this.#convert(default_._zod.def.innerType, options2, lazyDepth2);
+            return [false, {
+              ...json,
+              default: default_._zod.def.defaultValue()
+            }];
+          }
+          case "catch": {
+            const catch_ = schema2;
+            const [, json] = await this.#convert(catch_._zod.def.innerType, options2, lazyDepth2);
+            return [false, json];
+          }
+          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);
+          }
+          case "readonly": {
+            const readonly_ = schema2;
+            const [required, json] = await this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2);
+            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] = await this.#convert(optional._zod.def.innerType, options2, lazyDepth2);
+            return [false, json];
+          }
+          case "lazy": {
+            const lazy = schema2;
+            if (lazyDepth2 >= this.maxLazyDepth) {
+              return [false, this.anyJsonSchema];
+            }
+            return await this.#convert(lazy._zod.def.getter(), options2, lazyDepth2 + 1);
+          }
+          default: {
+            schema2._zod.def.type;
+            return [true, this.unsupportedJsonSchema];
+          }
+        }
+      }
+    );
+  }
+  #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 === "output" && experimental_JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return experimental_JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    }
+    if (experimental_JSON_SCHEMA_REGISTRY.has(schema)) {
+      return experimental_JSON_SCHEMA_REGISTRY.get(schema);
+    }
+    const global = globalRegistry.get(schema);
+    if (global) {
+      return {
+        description: global.description,
+        examples: global.examples
+      };
+    }
+  }
+  #handleArrayItemJsonSchema([required, schema], options) {
+    if (required || options.strategy === "input") {
+      return schema;
+    }
+    if (schema === this.undefinedJsonSchema) {
+      return { type: "null" };
+    }
+    return {
+      anyOf: [
+        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf
+        schema,
+        { type: "null" }
+      ]
+    };
+  }
+  #handleStringFormat(format) {
+    if (format === "guid") {
+      return JSONSchemaFormat.UUID;
+    }
+    if (format === "url") {
+      return JSONSchemaFormat.URI;
+    }
+    if (format === "datetime") {
+      return JSONSchemaFormat.DateTime;
+    }
+    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;
+  }
+  #handleContentEncoding(contentEncoding) {
+    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
+  }
+}
+
+export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/zod",
   "type": "module",
-  "version": "0.0.0-next.f81b4a2",
+  "version": "0.0.0-next.fcb9d5a",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -18,24 +18,42 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
+    },
+    "./zod4": {
+      "types": "./dist/zod4/index.d.mts",
+      "import": "./dist/zod4/index.mjs",
+      "default": "./dist/zod4/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "peerDependencies": {
-    "zod": "^3.24.2",
-    "@orpc/contract": "0.0.0-next.f81b4a2",
-    "@orpc/server": "0.0.0-next.f81b4a2"
+    "@zod/core": ">=0.11.4",
+    "zod": ">=3.24.2",
+    "@orpc/contract": "0.0.0-next.fcb9d5a",
+    "@orpc/server": "0.0.0-next.fcb9d5a"
+  },
+  "peerDependenciesMeta": {
+    "@zod/core": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
   },
   "dependencies": {
     "escape-string-regexp": "^5.0.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/openapi": "0.0.0-next.f81b4a2",
-    "@orpc/shared": "0.0.0-next.f81b4a2"
+    "@orpc/openapi": "0.0.0-next.fcb9d5a",
+    "@orpc/shared": "0.0.0-next.fcb9d5a"
   },
   "devDependencies": {
-    "zod-to-json-schema": "^3.24.5"
+    "@zod/core": "^0.11.4",
+    "@zod/mini": "^4.0.0-beta.20250505T012514",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.5",
+    "zod4": "npm:zod@^4.0.0-beta.20250505T012514"
   },
   "scripts": {
     "build": "unbuild",