@orpc/server 0.0.0-next.905e81c → 0.0.0-next.910f96e

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>
@@ -32,7 +32,7 @@
 - **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), Pinia Colada, 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.
@@ -53,11 +53,16 @@ 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/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
 - [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
+- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
 - [@orpc/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/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
 
 ## `@orpc/server`
 
@@ -113,6 +118,14 @@ export const createPlanet = os
 export const router = { planet: { list: listPlanet, find: findPlanet, create: createPlanet } }
 ```
 
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
 ## License
 
 Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,54 @@
+import { C as Context, R as Router } from '../../shared/server.DLt5njUb.mjs';
+import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/server.CzxlqYZL.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGnN7q3R.mjs';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.B77ImKAP.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
+}
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: Request;
+    toFetchResponseOptions: ToFetchResponseOptions;
+}
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, FetchHandleResult, ThrowableError>[];
+    plugins?: FetchHandlerPlugin<T>[];
+}
+declare class FetchHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly toFetchResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T> & StandardRPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, type BodyLimitPluginOptions, type FetchHandleResult, FetchHandler, type FetchHandlerInterceptorOptions, type FetchHandlerOptions, type FetchHandlerPlugin, RPCHandler };

package/dist/adapters/fetch/index.d.ts

@@ -0,0 +1,54 @@
+import { C as Context, R as Router } from '../../shared/server.DLt5njUb.js';
+import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/server.BHlRCrf_.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.Cud5qk0c.js';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DUF89eb-.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
+}
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: Request;
+    toFetchResponseOptions: ToFetchResponseOptions;
+}
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, FetchHandleResult, ThrowableError>[];
+    plugins?: FetchHandlerPlugin<T>[];
+}
+declare class FetchHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly toFetchResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T> & StandardRPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, type BodyLimitPluginOptions, type FetchHandleResult, FetchHandler, type FetchHandlerInterceptorOptions, type FetchHandlerOptions, type FetchHandlerPlugin, RPCHandler };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,9 @@
+export { B as BodyLimitPlugin, F as FetchHandler, R as RPCHandler } from '../../shared/server.T5WmDoWQ.mjs';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '../../shared/server.Dfx1jV-K.mjs';
+import '@orpc/shared';
+import '../../shared/server.e3W6AG3-.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BVwwTHyO.mjs';

package/dist/adapters/hono/index.d.mts

@@ -0,0 +1,22 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { BodyLimitPlugin, BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandler } from '../fetch/index.mjs';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { Context as Context$1, MiddlewareHandler } from 'hono';
+import { C as Context } from '../../shared/server.DLt5njUb.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CzxlqYZL.mjs';
+import '../../shared/server.DGnN7q3R.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.B77ImKAP.mjs';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [Context$1]>;
+} : {
+    context: Value<T, [Context$1]>;
+});
+declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
+
+export { type CreateMiddlewareOptions, FetchHandler, createMiddleware };

package/dist/adapters/hono/index.d.ts

@@ -0,0 +1,22 @@
+import { FetchHandler } from '../fetch/index.js';
+export { BodyLimitPlugin, BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandler } from '../fetch/index.js';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { Context as Context$1, MiddlewareHandler } from 'hono';
+import { C as Context } from '../../shared/server.DLt5njUb.js';
+import { S as StandardHandleOptions } from '../../shared/server.BHlRCrf_.js';
+import '../../shared/server.Cud5qk0c.js';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.DUF89eb-.js';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [Context$1]>;
+} : {
+    context: Value<T, [Context$1]>;
+});
+declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
+
+export { type CreateMiddlewareOptions, FetchHandler, createMiddleware };

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

@@ -1,12 +1,13 @@
-import {
-  RPCHandler
-} from "./chunk-47YYO5JS.js";
-import "./chunk-77FU7QSO.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-WQNNSBXW.js";
+export { B as BodyLimitPlugin, F as FetchHandler, R as RPCHandler } from '../../shared/server.T5WmDoWQ.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '../../shared/server.Dfx1jV-K.mjs';
+import '../../shared/server.e3W6AG3-.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BVwwTHyO.mjs';
 
-// src/adapters/hono/middleware.ts
-import { value } from "@orpc/shared";
 function createMiddleware(handler, ...[options]) {
   return async (c, next) => {
     const bodyProps = /* @__PURE__ */ new Set(["arrayBuffer", "blob", "formData", "json", "text"]);
@@ -27,8 +28,5 @@ function createMiddleware(handler, ...[options]) {
     await next();
   };
 }
-export {
-  RPCHandler,
-  createMiddleware
-};
-//# sourceMappingURL=hono.js.map
+
+export { createMiddleware };

package/dist/adapters/next/index.d.mts

@@ -0,0 +1,29 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { BodyLimitPlugin, BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandler } from '../fetch/index.mjs';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.DLt5njUb.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CzxlqYZL.mjs';
+import '../../shared/server.DGnN7q3R.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.B77ImKAP.mjs';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+interface ServeResult {
+    GET(req: NextRequest): Promise<Response>;
+    POST(req: NextRequest): Promise<Response>;
+    PUT(req: NextRequest): Promise<Response>;
+    PATCH(req: NextRequest): Promise<Response>;
+    DELETE(req: NextRequest): Promise<Response>;
+}
+declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
+
+export { FetchHandler, type ServeOptions, type ServeResult, serve };

package/dist/adapters/next/index.d.ts

@@ -0,0 +1,29 @@
+import { FetchHandler } from '../fetch/index.js';
+export { BodyLimitPlugin, BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandler } from '../fetch/index.js';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.DLt5njUb.js';
+import { S as StandardHandleOptions } from '../../shared/server.BHlRCrf_.js';
+import '../../shared/server.Cud5qk0c.js';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.DUF89eb-.js';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+interface ServeResult {
+    GET(req: NextRequest): Promise<Response>;
+    POST(req: NextRequest): Promise<Response>;
+    PUT(req: NextRequest): Promise<Response>;
+    PATCH(req: NextRequest): Promise<Response>;
+    DELETE(req: NextRequest): Promise<Response>;
+}
+declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
+
+export { FetchHandler, type ServeOptions, type ServeResult, serve };

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

@@ -1,12 +1,13 @@
-import {
-  RPCHandler
-} from "./chunk-47YYO5JS.js";
-import "./chunk-77FU7QSO.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-WQNNSBXW.js";
+export { B as BodyLimitPlugin, F as FetchHandler, R as RPCHandler } from '../../shared/server.T5WmDoWQ.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '../../shared/server.Dfx1jV-K.mjs';
+import '../../shared/server.e3W6AG3-.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BVwwTHyO.mjs';
 
-// src/adapters/next/serve.ts
-import { value } from "@orpc/shared";
 function serve(handler, ...[options]) {
   const main = async (req) => {
     const context = await value(options?.context ?? {}, req);
@@ -24,8 +25,5 @@ function serve(handler, ...[options]) {
     DELETE: main
   };
 }
-export {
-  RPCHandler,
-  serve
-};
-//# sourceMappingURL=next.js.map
+
+export { serve };

package/dist/adapters/node/index.d.mts

@@ -0,0 +1,53 @@
+import { C as Context, R as Router } from '../../shared/server.DLt5njUb.mjs';
+import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/server.CzxlqYZL.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGnN7q3R.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.B77ImKAP.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+}
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: NodeHttpRequest;
+    response: NodeHttpResponse;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, NodeHttpHandleResult, ThrowableError>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
+}
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T> & NodeHttpHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, type BodyLimitPluginOptions, type NodeHttpHandleResult, NodeHttpHandler, type NodeHttpHandlerInterceptorOptions, type NodeHttpHandlerOptions, type NodeHttpHandlerPlugin, RPCHandler };

package/dist/adapters/node/index.d.ts

@@ -0,0 +1,53 @@
+import { C as Context, R as Router } from '../../shared/server.DLt5njUb.js';
+import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/server.BHlRCrf_.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.Cud5qk0c.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DUF89eb-.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+}
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: NodeHttpRequest;
+    response: NodeHttpResponse;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, NodeHttpHandleResult, ThrowableError>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
+}
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T> & NodeHttpHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, type BodyLimitPluginOptions, type NodeHttpHandleResult, NodeHttpHandler, type NodeHttpHandlerInterceptorOptions, type NodeHttpHandlerOptions, type NodeHttpHandlerPlugin, RPCHandler };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,85 @@
+import { ORPCError } from '@orpc/client';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import { StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
+import { S as StandardHandler, b as StandardRPCMatcher, a as StandardRPCCodec } from '../../shared/server.Dfx1jV-K.mjs';
+import '../../shared/server.e3W6AG3-.mjs';
+import '@orpc/contract';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      let isHeaderChecked = false;
+      const checkHeader = () => {
+        if (!isHeaderChecked && Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+          throw new ORPCError("PAYLOAD_TOO_LARGE");
+        }
+        isHeaderChecked = true;
+      };
+      const originalEmit = options2.request.emit.bind(options2.request);
+      let currentBodySize = 0;
+      options2.request.emit = (event, ...args) => {
+        if (event === "data") {
+          checkHeader();
+          currentBodySize += args[0].length;
+          if (currentBodySize > this.maxBodySize) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+        }
+        return originalEmit(event, ...args);
+      };
+      return options2.next();
+    });
+  }
+}
+
+class NodeHttpHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    for (const plugin of toArray(options.plugins)) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
+  }
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  async handle(request, response, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        response,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, response2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return { matched: false };
+        }
+        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
+        return { matched: true };
+      }
+    );
+  }
+}
+
+class RPCHandler extends NodeHttpHandler {
+  constructor(router, options = {}) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const matcher = new StandardRPCMatcher();
+    const codec = new StandardRPCCodec(serializer);
+    super(new StandardHandler(router, matcher, codec, options), options);
+  }
+}
+
+export { BodyLimitPlugin, NodeHttpHandler, RPCHandler };

package/dist/adapters/standard/index.d.mts

@@ -0,0 +1,26 @@
+import { d as StandardCodec, e as StandardParams, f as StandardMatcher, g as StandardMatchResult } from '../../shared/server.CzxlqYZL.mjs';
+export { S as StandardHandleOptions, h as StandardHandleResult, i as StandardHandler, b as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, c as StandardHandlerPlugin } from '../../shared/server.CzxlqYZL.mjs';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure, a as AnyRouter } from '../../shared/server.DLt5njUb.mjs';
+export { S as StandardRPCHandlerOptions } from '../../shared/server.B77ImKAP.mjs';
+import '@orpc/contract';
+import '@orpc/shared';
+
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams, StandardRPCCodec, StandardRPCMatcher };

package/dist/adapters/standard/index.d.ts

@@ -0,0 +1,26 @@
+import { d as StandardCodec, e as StandardParams, f as StandardMatcher, g as StandardMatchResult } from '../../shared/server.BHlRCrf_.js';
+export { S as StandardHandleOptions, h as StandardHandleResult, i as StandardHandler, b as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, c as StandardHandlerPlugin } from '../../shared/server.BHlRCrf_.js';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure, a as AnyRouter } from '../../shared/server.DLt5njUb.js';
+export { S as StandardRPCHandlerOptions } from '../../shared/server.DUF89eb-.js';
+import '@orpc/contract';
+import '@orpc/shared';
+
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams, StandardRPCCodec, StandardRPCMatcher };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,6 @@
+export { S as StandardHandler, a as StandardRPCCodec, b as StandardRPCMatcher } from '../../shared/server.Dfx1jV-K.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.e3W6AG3-.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';