@orpc/server 0.0.0-next.cba521d → 0.0.0-next.cc8802c

package/README.md

@@ -0,0 +1,118 @@
+<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/server">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fserver?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), 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/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/server`
+
+Build your API or implement API contract. Read the [documentation](https://orpc.unnoq.com/docs/getting-started) for more information.
+
+```ts
+import type { IncomingHttpHeaders } from 'node:http'
+import { ORPCError, os } from '@orpc/server'
+import { z } from 'zod'
+
+const PlanetSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string(),
+  description: z.string().optional(),
+})
+
+export const listPlanet = os
+  .input(
+    z.object({
+      limit: z.number().int().min(1).max(100).optional(),
+      cursor: z.number().int().min(0).default(0),
+    }),
+  )
+  .handler(async ({ input }) => {
+    // your list code here
+    return [{ id: 1, name: 'name' }]
+  })
+
+export const findPlanet = os
+  .input(PlanetSchema.pick({ id: true }))
+  .handler(async ({ input }) => {
+    // your find code here
+    return { id: 1, name: 'name' }
+  })
+
+export const createPlanet = os
+  .$context<{ headers: IncomingHttpHeaders }>()
+  .use(({ context, next }) => {
+    const user = parseJWT(context.headers.authorization?.split(' ')[1])
+
+    if (user) {
+      return next({ context: { user } })
+    }
+
+    throw new ORPCError('UNAUTHORIZED')
+  })
+  .input(PlanetSchema.omit({ id: true }))
+  .handler(async ({ input, context }) => {
+    // your create code here
+    return { id: 1, name: 'name' }
+  })
+
+export const router = { planet: { list: listPlanet, find: findPlanet, create: createPlanet } }
+```
+
+## 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,26 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { C as Context, R as Router } from '../../shared/server.CPteJIPP.mjs';
+import { S as StandardHandleOptions, b as StandardHandlerOptions } from '../../shared/server.CM3tWr3C.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandler<T extends Context> {
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: Request, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { type FetchHandleResult, type FetchHandler, RPCHandler };

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

@@ -0,0 +1,26 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { C as Context, R as Router } from '../../shared/server.CPteJIPP.js';
+import { S as StandardHandleOptions, b as StandardHandlerOptions } from '../../shared/server.DmW25ynm.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandler<T extends Context> {
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: Request, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { type FetchHandleResult, type FetchHandler, RPCHandler };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,9 @@
+export { R as RPCHandler } from '../../shared/server.Cq3B6PoL.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.CSZRzcSW.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.CMrS28Go.mjs';
+import '@orpc/contract';

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

@@ -0,0 +1,19 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { FetchHandleResult, 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.CPteJIPP.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CM3tWr3C.mjs';
+import '@orpc/standard-server-fetch';
+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,19 @@
+import { FetchHandler } from '../fetch/index.js';
+export { FetchHandleResult, 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.CPteJIPP.js';
+import { S as StandardHandleOptions } from '../../shared/server.DmW25ynm.js';
+import '@orpc/standard-server-fetch';
+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.mjs

@@ -0,0 +1,32 @@
+export { R as RPCHandler } from '../../shared/server.Cq3B6PoL.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/client/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.CSZRzcSW.mjs';
+import '@orpc/client';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.CMrS28Go.mjs';
+import '@orpc/contract';
+
+function createMiddleware(handler, ...[options]) {
+  return async (c, next) => {
+    const bodyProps = /* @__PURE__ */ new Set(["arrayBuffer", "blob", "formData", "json", "text"]);
+    const request = c.req.method === "GET" || c.req.method === "HEAD" ? c.req.raw : new Proxy(c.req.raw, {
+      // https://github.com/honojs/middleware/blob/main/packages/trpc-server/src/index.ts#L39
+      get(target, prop) {
+        if (bodyProps.has(prop)) {
+          return () => c.req[prop]();
+        }
+        return Reflect.get(target, prop, target);
+      }
+    });
+    const context = await value(options?.context ?? {}, c);
+    const { matched, response } = await handler.handle(request, { ...options, context });
+    if (matched) {
+      return c.newResponse(response.body, response);
+    }
+    await next();
+  };
+}
+
+export { createMiddleware };

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

@@ -0,0 +1,26 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.mjs';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.CPteJIPP.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CM3tWr3C.mjs';
+import '@orpc/standard-server-fetch';
+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,26 @@
+import { FetchHandler } from '../fetch/index.js';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.js';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.CPteJIPP.js';
+import { S as StandardHandleOptions } from '../../shared/server.DmW25ynm.js';
+import '@orpc/standard-server-fetch';
+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.mjs

@@ -0,0 +1,29 @@
+export { R as RPCHandler } from '../../shared/server.Cq3B6PoL.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/client/standard';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.CSZRzcSW.mjs';
+import '@orpc/client';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.CMrS28Go.mjs';
+import '@orpc/contract';
+
+function serve(handler, ...[options]) {
+  const main = async (req) => {
+    const context = await value(options?.context ?? {}, req);
+    const { matched, response } = await handler.handle(req, { ...options, context });
+    if (matched) {
+      return response;
+    }
+    return new Response(`Cannot find a matching procedure for ${req.url}`, { status: 404 });
+  };
+  return {
+    GET: main,
+    POST: main,
+    PUT: main,
+    PATCH: main,
+    DELETE: main
+  };
+}
+
+export { serve };

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

@@ -0,0 +1,34 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { C as Context, R as Router } from '../../shared/server.CPteJIPP.mjs';
+import { S as StandardHandleOptions, b as StandardHandlerOptions } from '../../shared/server.CM3tWr3C.mjs';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { type NodeHttpHandleResult, type NodeHttpHandler, type NodeHttpRequest, type NodeHttpResponse, RPCHandler };

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

@@ -0,0 +1,34 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { C as Context, R as Router } from '../../shared/server.CPteJIPP.js';
+import { S as StandardHandleOptions, b as StandardHandlerOptions } from '../../shared/server.DmW25ynm.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...[options,]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { type NodeHttpHandleResult, type NodeHttpHandler, type NodeHttpRequest, type NodeHttpResponse, RPCHandler };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,31 @@
+import { RPCSerializer } from '@orpc/client/standard';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { S as StandardHandler, a as RPCMatcher, R as RPCCodec } from '../../shared/server.CSZRzcSW.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.CMrS28Go.mjs';
+import '@orpc/contract';
+
+class RPCHandler {
+  standardHandler;
+  constructor(router, options = {}) {
+    const serializer = new RPCSerializer();
+    const matcher = new RPCMatcher();
+    const codec = new RPCCodec(serializer);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(req, res, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(res, result.response, options);
+    return { matched: true };
+  }
+}
+
+export { RPCHandler };

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

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

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

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

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,6 @@
+export { R as RPCCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.CSZRzcSW.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.CMrS28Go.mjs';
+import '@orpc/contract';