@orpc/contract 0.0.0-next.ff5907c → 0.0.0-next.ff68fdb

package/README.md

@@ -0,0 +1,103 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/contract">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fcontract?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<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.
+
+---
+
+## 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.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@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/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/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/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/contract`
+
+Build your API contract. Read the [documentation](https://orpc.unnoq.com/docs/contract-first/define-contract) for more information.
+
+```ts
+export const PlanetSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string(),
+  description: z.string().optional(),
+})
+
+export const listPlanetContract = oc
+  .input(
+    z.object({
+      limit: z.number().int().min(1).max(100).optional(),
+      cursor: z.number().int().min(0).default(0),
+    }),
+  )
+  .output(z.array(PlanetSchema))
+
+export const findPlanetContract = oc
+  .input(PlanetSchema.pick({ id: true }))
+  .output(PlanetSchema)
+
+export const createPlanetContract = oc
+  .input(PlanetSchema.omit({ id: true }))
+  .output(PlanetSchema)
+
+export const contract = {
+  planet: {
+    list: listPlanetContract,
+    find: findPlanetContract,
+    create: createPlanetContract,
+  },
+}
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,236 @@
+import { ORPCErrorCode, ORPCError, ClientContext, Client } from '@orpc/client';
+export { ORPCError } from '@orpc/client';
+import { Promisable, IsEqual } from '@orpc/shared';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): Schema<TInput, TOutput>;
+
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+}
+declare class ValidationError extends Error {
+    readonly issues: readonly SchemaIssue[];
+    constructor(options: ValidationErrorOptions);
+}
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown, unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+
+type Meta = Record<string, any>;
+declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type InputStructure = 'compact' | 'detailed';
+type OutputStructure = 'compact' | 'detailed';
+interface Route {
+    method?: HTTPMethod;
+    path?: HTTPPath;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * Includes only the body data, encoded directly in the response.
+     *
+     * @option 'detailed'
+     * Separates the output into `headers` and `body` fields.
+     * - `headers`: Custom headers to merge with the response headers.
+     * - `body`: The response data.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+}
+declare function mergeRoute(a: Route, b: Route): Route;
+declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+interface EnhanceRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+declare function enhanceRoute(route: Route, options: EnhanceRouteOptions): Route;
+
+interface ContractProcedureDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema?: TInputSchema;
+    outputSchema?: TOutputSchema;
+    errorMap: TErrorMap;
+}
+declare class ContractProcedure<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
+
+type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
+};
+type AnyContractRouter = ContractRouter<any>;
+type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
+};
+type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
+};
+type InferContractRouterErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterErrorMap<T[K]> : never;
+}[keyof T];
+type InferContractRouterMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
+
+declare function getContractRouter(router: AnyContractRouter, path: readonly string[]): AnyContractRouter | undefined;
+type EnhancedContractRouter<T extends AnyContractRouter, TErrorMap extends ErrorMap> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? EnhancedContractRouter<T[K], TErrorMap> : never;
+};
+interface EnhanceContractRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    errorMap: TErrorMap;
+}
+declare function enhanceContractRouter<T extends AnyContractRouter, TErrorMap extends ErrorMap>(router: T, options: EnhanceContractRouterOptions<TErrorMap>): EnhancedContractRouter<T, TErrorMap>;
+
+interface ContractProcedureBuilder<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithInput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+}
+interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': EnhanceContractRouterOptions<TErrorMap>;
+    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
+    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    'router'<T extends ContractRouter<TMeta>>(router: T): EnhancedContractRouter<T, TErrorMap>;
+}
+
+interface ContractBuilderDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, EnhanceContractRouterOptions<TErrorMap> {
+}
+declare class ContractBuilder<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    /**
+     * Reset initial meta
+     */
+    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
+    /**
+     * Reset initial route
+     */
+    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    router<T extends ContractRouter<TMeta>>(router: T): EnhancedContractRouter<T, TErrorMap>;
+}
+declare const oc: ContractBuilder<Schema<unknown, unknown>, Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+
+interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: OutputStructure;
+}
+declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
+
+interface EventIteratorSchemaDetails {
+    yields: AnySchema;
+    returns?: AnySchema;
+}
+declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: Schema<TYieldIn, TYieldOut>, returns?: Schema<TReturnIn, TReturnOut>): Schema<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
+declare function getEventIteratorSchemaDetails(schema: AnySchema | undefined): undefined | EventIteratorSchemaDetails;
+
+type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+
+type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
+};
+
+export { type AnyContractProcedure, type AnyContractRouter, type AnySchema, ContractBuilder, type ContractBuilderDef, type ContractConfig, ContractProcedure, type ContractProcedureBuilder, type ContractProcedureBuilderWithInput, type ContractProcedureBuilderWithInputOutput, type ContractProcedureBuilderWithOutput, type ContractProcedureClient, type ContractProcedureDef, type ContractRouter, type ContractRouterBuilder, type ContractRouterClient, type EnhanceContractRouterOptions, type EnhanceRouteOptions, type EnhancedContractRouter, type ErrorFromErrorMap, type ErrorMap, type ErrorMapItem, type EventIteratorSchemaDetails, type HTTPMethod, type HTTPPath, type InferContractRouterErrorMap, type InferContractRouterInputs, type InferContractRouterMeta, type InferContractRouterOutputs, type InferSchemaInput, type InferSchemaOutput, type InputStructure, type MergedErrorMap, type Meta, type ORPCErrorFromErrorMap, type OutputStructure, type Route, type Schema, type SchemaIssue, type TypeRest, ValidationError, type ValidationErrorOptions, enhanceContractRouter, enhanceRoute, eventIterator, fallbackContractConfig, getContractRouter, getEventIteratorSchemaDetails, isContractProcedure, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, oc, prefixRoute, type, unshiftTagRoute };

package/dist/index.d.ts

@@ -0,0 +1,236 @@
+import { ORPCErrorCode, ORPCError, ClientContext, Client } from '@orpc/client';
+export { ORPCError } from '@orpc/client';
+import { Promisable, IsEqual } from '@orpc/shared';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): Schema<TInput, TOutput>;
+
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+}
+declare class ValidationError extends Error {
+    readonly issues: readonly SchemaIssue[];
+    constructor(options: ValidationErrorOptions);
+}
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown, unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+
+type Meta = Record<string, any>;
+declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type InputStructure = 'compact' | 'detailed';
+type OutputStructure = 'compact' | 'detailed';
+interface Route {
+    method?: HTTPMethod;
+    path?: HTTPPath;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * Includes only the body data, encoded directly in the response.
+     *
+     * @option 'detailed'
+     * Separates the output into `headers` and `body` fields.
+     * - `headers`: Custom headers to merge with the response headers.
+     * - `body`: The response data.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+}
+declare function mergeRoute(a: Route, b: Route): Route;
+declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+interface EnhanceRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+declare function enhanceRoute(route: Route, options: EnhanceRouteOptions): Route;
+
+interface ContractProcedureDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema?: TInputSchema;
+    outputSchema?: TOutputSchema;
+    errorMap: TErrorMap;
+}
+declare class ContractProcedure<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
+
+type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
+};
+type AnyContractRouter = ContractRouter<any>;
+type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
+};
+type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
+};
+type InferContractRouterErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterErrorMap<T[K]> : never;
+}[keyof T];
+type InferContractRouterMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
+
+declare function getContractRouter(router: AnyContractRouter, path: readonly string[]): AnyContractRouter | undefined;
+type EnhancedContractRouter<T extends AnyContractRouter, TErrorMap extends ErrorMap> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? EnhancedContractRouter<T[K], TErrorMap> : never;
+};
+interface EnhanceContractRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    errorMap: TErrorMap;
+}
+declare function enhanceContractRouter<T extends AnyContractRouter, TErrorMap extends ErrorMap>(router: T, options: EnhanceContractRouterOptions<TErrorMap>): EnhancedContractRouter<T, TErrorMap>;
+
+interface ContractProcedureBuilder<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithInput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
+}
+interface ContractProcedureBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+}
+interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': EnhanceContractRouterOptions<TErrorMap>;
+    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
+    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    'router'<T extends ContractRouter<TMeta>>(router: T): EnhancedContractRouter<T, TErrorMap>;
+}
+
+interface ContractBuilderDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, EnhanceContractRouterOptions<TErrorMap> {
+}
+declare class ContractBuilder<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    /**
+     * Reset initial meta
+     */
+    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
+    /**
+     * Reset initial route
+     */
+    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends AnySchema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends AnySchema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    router<T extends ContractRouter<TMeta>>(router: T): EnhancedContractRouter<T, TErrorMap>;
+}
+declare const oc: ContractBuilder<Schema<unknown, unknown>, Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+
+interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: OutputStructure;
+}
+declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
+
+interface EventIteratorSchemaDetails {
+    yields: AnySchema;
+    returns?: AnySchema;
+}
+declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: Schema<TYieldIn, TYieldOut>, returns?: Schema<TReturnIn, TReturnOut>): Schema<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
+declare function getEventIteratorSchemaDetails(schema: AnySchema | undefined): undefined | EventIteratorSchemaDetails;
+
+type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+
+type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
+};
+
+export { type AnyContractProcedure, type AnyContractRouter, type AnySchema, ContractBuilder, type ContractBuilderDef, type ContractConfig, ContractProcedure, type ContractProcedureBuilder, type ContractProcedureBuilderWithInput, type ContractProcedureBuilderWithInputOutput, type ContractProcedureBuilderWithOutput, type ContractProcedureClient, type ContractProcedureDef, type ContractRouter, type ContractRouterBuilder, type ContractRouterClient, type EnhanceContractRouterOptions, type EnhanceRouteOptions, type EnhancedContractRouter, type ErrorFromErrorMap, type ErrorMap, type ErrorMapItem, type EventIteratorSchemaDetails, type HTTPMethod, type HTTPPath, type InferContractRouterErrorMap, type InferContractRouterInputs, type InferContractRouterMeta, type InferContractRouterOutputs, type InferSchemaInput, type InferSchemaOutput, type InputStructure, type MergedErrorMap, type Meta, type ORPCErrorFromErrorMap, type OutputStructure, type Route, type Schema, type SchemaIssue, type TypeRest, ValidationError, type ValidationErrorOptions, enhanceContractRouter, enhanceRoute, eventIterator, fallbackContractConfig, getContractRouter, getEventIteratorSchemaDetails, isContractProcedure, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, oc, prefixRoute, type, unshiftTagRoute };

package/dist/{index.js → index.mjs}

@@ -1,22 +1,23 @@
-// src/error.ts
-var ValidationError = class extends Error {
+import { mapEventIterator, ORPCError } from '@orpc/client';
+export { ORPCError } from '@orpc/client';
+import { isAsyncIteratorObject } from '@orpc/shared';
+
+class ValidationError extends Error {
   issues;
   constructor(options) {
     super(options.message, options);
     this.issues = options.issues;
   }
-};
+}
 function mergeErrorMap(errorMap1, errorMap2) {
   return { ...errorMap1, ...errorMap2 };
 }
 
-// src/meta.ts
 function mergeMeta(meta1, meta2) {
   return { ...meta1, ...meta2 };
 }
 
-// src/procedure.ts
-var ContractProcedure = class {
+class ContractProcedure {
   "~orpc";
   constructor(def) {
     if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
@@ -27,15 +28,14 @@ var ContractProcedure = class {
     }
     this["~orpc"] = def;
   }
-};
+}
 function isContractProcedure(item) {
   if (item instanceof ContractProcedure) {
     return true;
   }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "inputSchema" in item["~orpc"] && "outputSchema" in item["~orpc"] && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
 }
 
-// src/route.ts
 function mergeRoute(a, b) {
   return { ...a, ...b };
 }
@@ -60,36 +60,48 @@ function mergePrefix(a, b) {
 function mergeTags(a, b) {
   return a ? [...a, ...b] : b;
 }
-function adaptRoute(route, options) {
+function enhanceRoute(route, options) {
   let router = route;
   if (options.prefix) {
     router = prefixRoute(router, options.prefix);
   }
-  if (options.tags) {
+  if (options.tags?.length) {
     router = unshiftTagRoute(router, options.tags);
   }
   return router;
 }
 
-// src/router.ts
-function adaptContractRouter(contract, options) {
-  if (isContractProcedure(contract)) {
-    const adapted2 = new ContractProcedure({
-      ...contract["~orpc"],
-      errorMap: mergeErrorMap(options.errorMap, contract["~orpc"].errorMap),
-      route: adaptRoute(contract["~orpc"].route, options)
+function getContractRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isContractProcedure(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function enhanceContractRouter(router, options) {
+  if (isContractProcedure(router)) {
+    const enhanced2 = new ContractProcedure({
+      ...router["~orpc"],
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      route: enhanceRoute(router["~orpc"].route, options)
     });
-    return adapted2;
+    return enhanced2;
   }
-  const adapted = {};
-  for (const key in contract) {
-    adapted[key] = adaptContractRouter(contract[key], options);
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceContractRouter(router[key], options);
   }
-  return adapted;
+  return enhanced;
 }
 
-// src/builder.ts
-var ContractBuilder = class _ContractBuilder extends ContractProcedure {
+class ContractBuilder extends ContractProcedure {
   constructor(def) {
     super(def);
     this["~orpc"].prefix = def.prefix;
@@ -99,7 +111,7 @@ var ContractBuilder = class _ContractBuilder extends ContractProcedure {
    * Reset initial meta
    */
   $meta(initialMeta) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       meta: initialMeta
     });
@@ -108,67 +120,64 @@ var ContractBuilder = class _ContractBuilder extends ContractProcedure {
    * Reset initial route
    */
   $route(initialRoute) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       route: initialRoute
     });
   }
   errors(errors) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   meta(meta) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       route: mergeRoute(this["~orpc"].route, route)
     });
   }
   input(schema) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       inputSchema: schema
     });
   }
   output(schema) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       outputSchema: schema
     });
   }
   prefix(prefix) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new _ContractBuilder({
+    return new ContractBuilder({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return adaptContractRouter(router, this["~orpc"]);
+    return enhanceContractRouter(router, this["~orpc"]);
   }
-};
-var oc = new ContractBuilder({
+}
+const oc = new ContractBuilder({
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   route: {},
   meta: {}
 });
 
-// src/config.ts
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
   defaultMethod: "POST",
   defaultSuccessStatus: 200,
   defaultSuccessDescription: "OK",
@@ -182,19 +191,16 @@ function fallbackContractConfig(key, value) {
   return value;
 }
 
-// src/event-iterator.ts
-import { mapEventIterator, ORPCError } from "@orpc/client";
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_DETAILS");
 function eventIterator(yields, returns) {
   return {
     "~standard": {
-      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
+      [EVENT_ITERATOR_DETAILS_SYMBOL]: { yields, returns },
       vendor: "orpc",
       version: 1,
       validate(iterator) {
         if (!isAsyncIteratorObject(iterator)) {
-          return { issues: [{ message: "Expect event source iterator", path: [] }] };
+          return { issues: [{ message: "Expect event iterator", path: [] }] };
         }
         const mapped = mapEventIterator(iterator, {
           async value(value, done) {
@@ -205,10 +211,10 @@ function eventIterator(yields, returns) {
             const result = await schema["~standard"].validate(value);
             if (result.issues) {
               throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
-                message: "Event source iterator validation failed",
+                message: "Event iterator validation failed",
                 cause: new ValidationError({
                   issues: result.issues,
-                  message: "Event source iterator validation failed"
+                  message: "Event iterator validation failed"
                 })
               });
             }
@@ -225,10 +231,9 @@ function getEventIteratorSchemaDetails(schema) {
   if (schema === void 0) {
     return void 0;
   }
-  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
+  return schema["~standard"][EVENT_ITERATOR_DETAILS_SYMBOL];
 }
 
-// src/schema.ts
 function type(...[map]) {
   return {
     "~standard": {
@@ -244,27 +249,4 @@ function type(...[map]) {
   };
 }
 
-// src/index.ts
-import { ORPCError as ORPCError2 } from "@orpc/client";
-export {
-  ContractBuilder,
-  ContractProcedure,
-  ORPCError2 as ORPCError,
-  ValidationError,
-  adaptContractRouter,
-  adaptRoute,
-  eventIterator,
-  fallbackContractConfig,
-  getEventIteratorSchemaDetails,
-  isContractProcedure,
-  mergeErrorMap,
-  mergeMeta,
-  mergePrefix,
-  mergeRoute,
-  mergeTags,
-  oc,
-  prefixRoute,
-  type,
-  unshiftTagRoute
-};
-//# sourceMappingURL=index.js.map
+export { ContractBuilder, ContractProcedure, ValidationError, enhanceContractRouter, enhanceRoute, eventIterator, fallbackContractConfig, getContractRouter, getEventIteratorSchemaDetails, isContractProcedure, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, oc, prefixRoute, type, unshiftTagRoute };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.ff5907c",
+  "version": "0.0.0-next.ff68fdb",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,32 +15,27 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
     "@standard-schema/spec": "^1.0.0",
-    "@orpc/client": "0.0.0-next.ff5907c",
-    "@orpc/shared": "0.0.0-next.ff5907c"
+    "@orpc/client": "0.0.0-next.ff68fdb",
+    "@orpc/shared": "0.0.0-next.ff68fdb",
+    "@orpc/standard-server": "0.0.0-next.ff68fdb"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",
     "valibot": "1.0.0-beta.9",
-    "zod": "^3.24.1"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/builder-variants.d.ts

@@ -1,38 +0,0 @@
-import type { ErrorMap, MergedErrorMap } from './error';
-import type { Meta } from './meta';
-import type { ContractProcedure } from './procedure';
-import type { HTTPPath, Route } from './route';
-import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
-import type { Schema } from './schema';
-export interface ContractProcedureBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithInput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithInputOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-}
-export interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': AdaptContractRouterOptions<TErrorMap>;
-    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
-    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
-    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
-    'router'<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-//# sourceMappingURL=builder-variants.d.ts.map

package/dist/src/builder.d.ts

@@ -1,32 +0,0 @@
-import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants';
-import type { ContractProcedureDef } from './procedure';
-import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
-import type { Schema } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error';
-import { type Meta } from './meta';
-import { ContractProcedure } from './procedure';
-import { type HTTPPath, type Route } from './route';
-export interface ContractBuilderDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, AdaptContractRouterOptions<TErrorMap> {
-}
-export declare class ContractBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
-    /**
-     * Reset initial meta
-     */
-    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
-    /**
-     * Reset initial route
-     */
-    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
-    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
-    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
-    router<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-export declare const oc: ContractBuilder<undefined, undefined, {}, {}>;
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/config.d.ts

@@ -1,10 +0,0 @@
-import type { HTTPMethod, InputStructure } from './route';
-export interface ContractConfig {
-    defaultMethod: HTTPMethod;
-    defaultSuccessStatus: number;
-    defaultSuccessDescription: string;
-    defaultInputStructure: InputStructure;
-    defaultOutputStructure: InputStructure;
-}
-export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
-//# sourceMappingURL=config.d.ts.map

package/dist/src/error.d.ts

@@ -1,27 +0,0 @@
-import type { ORPCError, ORPCErrorCode } from '@orpc/client';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Schema, SchemaOutput } from './schema';
-export interface ValidationErrorOptions extends ErrorOptions {
-    message: string;
-    issues: readonly StandardSchemaV1.Issue[];
-}
-export declare class ValidationError extends Error {
-    readonly issues: readonly StandardSchemaV1.Issue[];
-    constructor(options: ValidationErrorOptions);
-}
-export type ErrorMapItem<TDataSchema extends Schema> = {
-    status?: number;
-    message?: string;
-    description?: string;
-    data?: TDataSchema;
-};
-export type ErrorMap = {
-    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
-};
-export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
-export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
-export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
-    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
-}[keyof TErrorMap];
-export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
-//# sourceMappingURL=error.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -1,8 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { Schema } from './schema';
-export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
-export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {
-    yields: Schema;
-    returns: Schema;
-};
-//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,15 +0,0 @@
-/** unnoq */
-export * from './builder';
-export * from './builder-variants';
-export * from './config';
-export * from './error';
-export * from './event-iterator';
-export * from './meta';
-export * from './procedure';
-export * from './procedure-client';
-export * from './route';
-export * from './router';
-export * from './router-client';
-export * from './schema';
-export { ORPCError } from '@orpc/client';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/meta.d.ts

@@ -1,3 +0,0 @@
-export type Meta = Record<string, any>;
-export declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
-//# sourceMappingURL=meta.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,5 +0,0 @@
-import type { Client, ClientContext } from '@orpc/client';
-import type { ErrorFromErrorMap, ErrorMap } from './error';
-import type { Schema, SchemaInput, SchemaOutput } from './schema';
-export type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-//# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,18 +0,0 @@
-import type { ErrorMap } from './error';
-import type { Meta } from './meta';
-import type { Route } from './route';
-import type { Schema } from './schema';
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    meta: TMeta;
-    route: Route;
-    inputSchema: TInputSchema;
-    outputSchema: TOutputSchema;
-    errorMap: TErrorMap;
-}
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
-}
-export type AnyContractProcedure = ContractProcedure<any, any, any, any>;
-export declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -1,79 +0,0 @@
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type InputStructure = 'compact' | 'detailed';
-export type OutputStructure = 'compact' | 'detailed';
-export interface Route {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    /**
-     * The status code of the response when the procedure is successful.
-     *
-     * @default 200
-     */
-    successStatus?: number;
-    /**
-     * The description of the response when the procedure is successful.
-     *
-     * @default 'OK'
-     */
-    successDescription?: string;
-    /**
-     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
-     *
-     * @option 'compact'
-     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
-     *
-     * @option 'detailed'
-     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
-     *
-     * Example:
-     * ```ts
-     * const input = {
-     *   params: { id: 1 },
-     *   query: { search: 'hello' },
-     *   headers: { 'Content-Type': 'application/json' },
-     *   body: { name: 'John' },
-     * }
-     * ```
-     *
-     * @default 'compact'
-     */
-    inputStructure?: InputStructure;
-    /**
-     * Determines how the response should be structured based on the output.
-     *
-     * @option 'compact'
-     * Includes only the body data, encoded directly in the response.
-     *
-     * @option 'detailed'
-     * Separates the output into `headers` and `body` fields.
-     * - `headers`: Custom headers to merge with the response headers.
-     * - `body`: The response data.
-     *
-     * Example:
-     * ```ts
-     * const output = {
-     *   headers: { 'x-custom-header': 'value' },
-     *   body: { message: 'Hello, world!' },
-     * };
-     * ```
-     *
-     * @default 'compact'
-     */
-    outputStructure?: OutputStructure;
-}
-export declare function mergeRoute(a: Route, b: Route): Route;
-export declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
-export declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
-export declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
-export declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
-export interface AdaptRouteOptions {
-    prefix?: HTTPPath;
-    tags?: readonly string[];
-}
-export declare function adaptRoute(route: Route, options: AdaptRouteOptions): Route;
-//# sourceMappingURL=route.d.ts.map

package/dist/src/router-client.d.ts

@@ -1,8 +0,0 @@
-import type { ClientContext } from '@orpc/client';
-import type { ContractProcedure } from './procedure';
-import type { ContractProcedureClient } from './procedure-client';
-import type { AnyContractRouter } from './router';
-export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
-};
-//# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,29 +0,0 @@
-import type { Meta } from './meta';
-import type { SchemaInput, SchemaOutput } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error';
-import { ContractProcedure } from './procedure';
-import { type HTTPPath } from './route';
-export type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
-    [k: string]: ContractRouter<TMeta>;
-};
-export type AnyContractRouter = ContractRouter<any>;
-export type AdaptedContractRouter<TContract extends AnyContractRouter, TErrorMap extends ErrorMap> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : TContract[K] extends AnyContractRouter ? AdaptedContractRouter<TContract[K], TErrorMap> : never;
-};
-export interface AdaptContractRouterOptions<TErrorMap extends ErrorMap> {
-    errorMap: TErrorMap;
-    prefix?: HTTPPath;
-    tags?: readonly string[];
-}
-export declare function adaptContractRouter<TRouter extends ContractRouter<any>, TErrorMap extends ErrorMap>(contract: TRouter, options: AdaptContractRouterOptions<TErrorMap>): AdaptedContractRouter<TRouter, TErrorMap>;
-export type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
-};
-export type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
-};
-export type ContractRouterToErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? ContractRouterToErrorMap<T[K]> : never;
-}[keyof T];
-export type ContractRouterToMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
-//# sourceMappingURL=router.d.ts.map

package/dist/src/schema.d.ts

@@ -1,8 +0,0 @@
-import type { IsEqual, Promisable } from '@orpc/shared';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type Schema = StandardSchemaV1 | undefined;
-export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
-export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
-export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
-export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
-//# sourceMappingURL=schema.d.ts.map