@orpc/server 0.0.0-next.837ee14 → 0.0.0-next.854b646

package/dist/next.js

@@ -0,0 +1,39 @@
+import {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+} from "./chunk-3XSZ4GNO.js";
+import "./chunk-SD2T3J2Z.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
+
+// 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);
+    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 {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  serve,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,45 +1,175 @@
 import {
-  ORPCHandler
-} from "./chunk-B2EZJB7X.js";
-import "./chunk-6A7XHEBH.js";
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-SD2T3J2Z.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 
-// src/adapters/node/composite-handler.ts
-var CompositeHandler = class {
-  constructor(handlers) {
-    this.handlers = handlers;
-  }
-  async handle(req, res, ...opt) {
-    for (const handler of this.handlers) {
-      if (handler.condition(req)) {
-        return handler.handle(req, res, ...opt);
+// src/adapters/node/utils.ts
+import { Buffer, File } from "node:buffer";
+import { Readable } from "node:stream";
+import { once } from "@orpc/shared";
+import { contentDisposition, parse as parseContentDisposition } from "@tinyhttp/content-disposition";
+function nodeHttpToStandardRequest(req, res) {
+  const method = req.method ?? "GET";
+  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
+  return {
+    raw: { request: req, response: res },
+    method,
+    url,
+    headers: req.headers,
+    body: once(() => {
+      return nodeHttpRequestToStandardBody(req);
+    }),
+    get signal() {
+      const signal = nodeHttpResponseToAbortSignal(res);
+      Object.defineProperty(this, "signal", { value: signal, writable: true });
+      return signal;
+    },
+    set signal(value) {
+      Object.defineProperty(this, "signal", { value, writable: true });
+    }
+  };
+}
+function nodeHttpResponseSendStandardResponse(res, standardResponse) {
+  return new Promise((resolve, reject) => {
+    res.on("error", reject);
+    res.on("finish", resolve);
+    if (standardResponse.body === void 0) {
+      res.writeHead(standardResponse.status, standardResponse.headers);
+      res.end();
+      return;
+    }
+    if (standardResponse.body instanceof Blob) {
+      const resHeaders = {
+        ...standardResponse.headers,
+        "content-type": standardResponse.body.type,
+        "content-length": standardResponse.body.size.toString()
+      };
+      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
+        resHeaders["content-disposition"] = contentDisposition(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
       }
+      res.writeHead(standardResponse.status, resHeaders);
+      Readable.fromWeb(
+        standardResponse.body.stream()
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof FormData) {
+      const response = new Response(standardResponse.body);
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": response.headers.get("content-type")
+      });
+      Readable.fromWeb(
+        response.body
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof URLSearchParams) {
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": "application/x-www-form-urlencoded"
+      });
+      const string2 = standardResponse.body.toString();
+      res.end(string2);
+      return;
     }
-    res.statusCode = 404;
-    res.end("None of the handlers can handle the request.");
+    res.writeHead(standardResponse.status, {
+      ...standardResponse.headers,
+      "content-type": "application/json"
+    });
+    const string = JSON.stringify(standardResponse.body);
+    res.end(string);
+  });
+}
+async function nodeHttpRequestToStandardBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
   }
-};
+  const contentDisposition2 = req.headers["content-disposition"];
+  const fileName = contentDisposition2 ? parseContentDisposition(contentDisposition2).parameters.filename : void 0;
+  const contentType = req.headers["content-type"];
+  if (typeof fileName === "string") {
+    return await streamToFile(req, fileName, contentType || "application/octet-stream");
+  }
+  if (!contentType || contentType.startsWith("application/json")) {
+    const text = await streamToString(req);
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("multipart/form-data")) {
+    return await streamToFormData(req, contentType);
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    const text = await streamToString(req);
+    return new URLSearchParams(text);
+  }
+  if (contentType.startsWith("text/")) {
+    return await streamToString(req);
+  }
+  return streamToFile(req, "blob", contentType);
+}
+function streamToFormData(stream, contentType) {
+  const response = new Response(stream, {
+    // Conflict between types=node and lib=dom so we need to cast it
+    headers: {
+      "content-type": contentType
+    }
+  });
+  return response.formData();
+}
+async function streamToString(stream) {
+  let string = "";
+  for await (const chunk of stream) {
+    string += chunk.toString();
+  }
+  return string;
+}
+async function streamToFile(stream, fileName, contentType) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
+}
+function nodeHttpResponseToAbortSignal(res) {
+  const controller = new AbortController();
+  res.on("close", () => {
+    controller.abort();
+  });
+  return controller.signal;
+}
 
-// src/adapters/node/orpc-handler.ts
-import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
-import { ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE } from "@orpc/shared";
-var ORPCHandler2 = class {
-  orpcFetchHandler;
+// src/adapters/node/rpc-handler.ts
+var RPCHandler = class {
+  standardHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new ORPCHandler(router, options);
+    const codec = options?.codec ?? new RPCCodec();
+    const matcher = options?.matcher ?? new RPCMatcher();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
-  condition(request) {
-    return Boolean(request.headers[ORPC_HANDLER_HEADER]?.includes(ORPC_HANDLER_VALUE));
-  }
-  async handle(req, res, ...[options]) {
-    const request = createRequest(req, res, options);
-    const castedOptions = options ?? {};
-    const response = await this.orpcFetchHandler.fetch(request, castedOptions);
-    await options?.beforeSend?.(response, castedOptions.context);
-    return await sendResponse(res, response);
+  async handle(req, res, ...rest) {
+    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await nodeHttpResponseSendStandardResponse(res, result.response);
+    return { matched: true };
   }
 };
 export {
-  CompositeHandler,
-  ORPCHandler2 as ORPCHandler
+  RPCHandler,
+  nodeHttpResponseSendStandardResponse,
+  nodeHttpToStandardRequest
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -0,0 +1,11 @@
+import {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+} from "./chunk-XFBAK67J.js";
+export {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+};
+//# sourceMappingURL=plugins.js.map

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

@@ -1,7 +1,4 @@
-export * from './composite-handler';
-export * from './orpc-handler';
-export * from './orpc-payload-codec';
-export * from './orpc-procedure-matcher';
-export * as SuperJSON from './super-json';
+export * from './rpc-handler';
 export * from './types';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { FetchHandler, FetchHandleResult } from './types';
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,16 +1,13 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Context, WithSignal } from '../../types';
-export type FetchOptions<T extends Context> = WithSignal & {
-    prefix?: HTTPPath;
-} & (undefined extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
+export type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
 export interface FetchHandler<T extends Context> {
-    fetch: (request: Request, ...opt: [options: FetchOptions<T>] | (undefined extends T ? [] : never)) => Promise<Response>;
-}
-export interface ConditionalFetchHandler<T extends Context> extends FetchHandler<T> {
-    condition: (request: Request) => boolean;
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/fetch/utils.d.ts

@@ -0,0 +1,6 @@
+import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
+export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
+export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
+export declare function standardBodyToFetchBody(body: StandardBody): Blob | FormData | URLSearchParams | string | undefined;
+export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from '../fetch';
+export * from './middleware';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -0,0 +1,13 @@
+import type { Context as HonoContext, MiddlewareHandler } from 'hono';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+import { type Value } from '@orpc/shared';
+export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [HonoContext]>;
+} : {
+    context: Value<T, [HonoContext]>;
+});
+export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
+export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
+//# sourceMappingURL=middleware.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from '../fetch';
+export * from './serve';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -0,0 +1,20 @@
+import type { NextRequest } from 'next/server';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+import { type Value } from '@orpc/shared';
+export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
+export 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>;
+}
+export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
+//# sourceMappingURL=serve.d.ts.map

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

@@ -1,5 +1,4 @@
-export * from './composite-handler';
-export * from './orpc-handler';
-export * from './orpc-handler';
+export * from './rpc-handler';
 export * from './types';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
+export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,21 +1,21 @@
-import type { RequestOptions as BaseRequestOptions } from '@mjackson/node-fetch-server';
-import type { HTTPPath } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Context, WithSignal } from '../../types';
-export type RequestOptions<T extends Context> = BaseRequestOptions & WithSignal & {
-    prefix?: HTTPPath;
-} & (undefined extends T ? {
-    context?: T;
-} : {
-    context: T;
-}) & {
-    beforeSend?: (response: Response, context: T) => Promisable<void>;
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
+export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
 };
-export interface RequestHandler<T extends Context> {
-    handle: (req: IncomingMessage, res: ServerResponse, ...opt: [options: RequestOptions<T>] | (undefined extends T ? [] : never)) => void;
-}
-export interface ConditionalRequestHandler<T extends Context> extends RequestHandler<T> {
-    condition: (request: IncomingMessage) => boolean;
+export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+export type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+export interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -0,0 +1,5 @@
+import type { StandardRequest, StandardResponse } from '../standard';
+import type { NodeHttpRequest, NodeHttpResponse } from './types';
+export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
+export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -0,0 +1,51 @@
+import type { ErrorMap, HTTPPath, Meta, Schema } from '@orpc/contract';
+import type { Interceptor } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Plugin } from '../../plugins';
+import type { CreateProcedureClientOptions } from '../../procedure-client';
+import type { Router } from '../../router';
+import type { StandardCodec, StandardMatcher, StandardRequest, StandardResponse } from './types';
+export type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
+export type StandardHandleRest<T extends Context> = [options: StandardHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+export type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+    request: StandardRequest;
+};
+export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, unknown> & {
+    context: TContext;
+};
+export interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: Plugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the response
+     */
+    interceptorsRoot?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+}
+export declare class StandardHandler<TContext extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<TContext, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<TContext>>);
+    handle(request: StandardRequest, ...[options]: StandardHandleRest<TContext>): Promise<StandardHandleResult>;
+}
+//# sourceMappingURL=handler.d.ts.map

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

@@ -0,0 +1,7 @@
+export * from './handler';
+export * from './rpc-codec';
+export * from './rpc-handler';
+export * from './rpc-matcher';
+export * from './rpc-serializer';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -0,0 +1,15 @@
+import type { ORPCError } from '@orpc/contract';
+import type { AnyProcedure } from '../../procedure';
+import type { StandardCodec, StandardParams, StandardRequest, StandardResponse } from './types';
+import { RPCSerializer } from './rpc-serializer';
+export interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+export declare class RPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(options?: StandardCodecOptions);
+    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=rpc-codec.d.ts.map

package/dist/src/adapters/standard/rpc-handler.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { StandardHandlerOptions } from './handler';
+import type { StandardCodec, StandardMatcher } from './types';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
+    matcher?: StandardMatcher;
+    codec?: StandardCodec;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/standard/rpc-matcher.d.ts

@@ -0,0 +1,10 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardMatcher, StandardMatchResult } from './types';
+import { type AnyRouter } from '../../router';
+export declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=rpc-matcher.d.ts.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -0,0 +1,16 @@
+import type { Segment } from '@orpc/shared';
+export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
+export type RPCSerialized = {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+} | FormData | Blob | undefined;
+export type RPCSerializedFormDataMaps = Segment[][];
+export declare class RPCSerializer {
+    serialize(data: unknown): RPCSerialized;
+    deserialize(serialized: RPCSerialized): unknown;
+}
+export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+};
+//# sourceMappingURL=rpc-serializer.d.ts.map

package/dist/src/adapters/standard/types.d.ts

@@ -0,0 +1,44 @@
+import type { AbortSignal, HTTPPath, ORPCError } from '@orpc/contract';
+import type { JsonValue } from '@orpc/shared';
+import type { AnyProcedure } from '../../procedure';
+import type { AnyRouter } from '../../router';
+export interface StandardHeaders {
+    [key: string]: string | string[] | undefined;
+}
+export type StandardBody = undefined | JsonValue | Blob | URLSearchParams | FormData;
+export interface StandardRequest {
+    /**
+     * Can be { request: Request } or { request: IncomingMessage, response: ServerResponse } based on the adapter.
+     */
+    raw: Record<string, unknown>;
+    method: string;
+    url: URL;
+    headers: StandardHeaders;
+    /**
+     * The body has been parsed base on the content-type header.
+     * This method can safely call multiple times (cached).
+     */
+    body(): Promise<StandardBody>;
+    signal?: AbortSignal;
+}
+export interface StandardResponse {
+    status: number;
+    headers: StandardHeaders;
+    body: StandardBody;
+}
+export type StandardParams = Record<string, string>;
+export type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+export interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+export interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+//# sourceMappingURL=types.d.ts.map