@orpc/server 0.33.0 → 0.35.0

package/dist/hono.js

@@ -1,30 +1,42 @@
-import "./chunk-WUOGVGWG.js";
 import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+} from "./chunk-EYGVJA7A.js";
+import "./chunk-CVIWJKJC.js";
+import "./chunk-NOA3GBJQ.js";
+import "./chunk-OXB4YX67.js";
 
 // 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"]);
+    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(c.req.raw, { ...options, context });
+    const { matched, response } = await handler.handle(request, { ...options, context });
     if (matched) {
-      c.res = response;
-      return;
+      return c.body(response.body, response);
     }
     await next();
   };
 }
 export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports as SuperJSON,
-  createMiddleware
+  createMiddleware,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -3,10 +3,14 @@ import {
   Procedure,
   adaptRouter,
   addMiddleware,
+  convertPathToHttpPath,
   createAccessibleLazyRouter,
+  createContractedProcedure,
   createLazyProcedureFormAnyLazy,
   createProcedureClient,
   deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
   flatLazy,
   getLazyRouterPrefix,
   getRouterChild,
@@ -17,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-KK4SDLC7.js";
+} from "./chunk-NOA3GBJQ.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
@@ -354,6 +358,7 @@ function createRouterClient(router, ...rest) {
 
 // src/index.ts
 import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {
   Builder,
   DecoratedProcedure,
@@ -363,12 +368,16 @@ export {
   ValidationError,
   adaptRouter,
   call,
+  convertPathToHttpPath,
   createAccessibleLazyRouter,
+  createContractedProcedure,
   createLazyProcedureFormAnyLazy,
   createProcedureClient,
   createRouterClient,
   decorateMiddleware,
   deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
   fallbackConfig,
   flatLazy,
   getLazyRouterPrefix,
@@ -382,6 +391,10 @@ export {
   lazy,
   mergeContext,
   middlewareOutputFn,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
   os,
   safe,
   setRouterContract,

package/dist/next.js

@@ -1,11 +1,13 @@
-import "./chunk-WUOGVGWG.js";
 import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+} from "./chunk-EYGVJA7A.js";
+import "./chunk-CVIWJKJC.js";
+import "./chunk-NOA3GBJQ.js";
+import "./chunk-OXB4YX67.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -27,10 +29,11 @@ function serve(handler, ...[options]) {
   };
 }
 export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports as SuperJSON,
-  serve
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  serve,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,87 +1,175 @@
 import {
-  RPCHandler
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-CVIWJKJC.js";
+import "./chunk-NOA3GBJQ.js";
+import "./chunk-OXB4YX67.js";
 
-// src/adapters/node/request-listener.ts
-function createRequest(req, res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
+// src/adapters/node/utils.ts
+import { Buffer, File } from "node:buffer";
+import { Readable } from "node:stream";
+import { once } from "@orpc/shared";
+import cd from "content-disposition";
+function nodeHttpToStandardRequest(req, res) {
   const method = req.method ?? "GET";
-  const headers = createHeaders(req);
   const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = headers.get("Host") ?? "localhost";
+  const host = req.headers.host ?? "localhost";
   const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  const init = { method, headers, signal: controller.signal };
-  if (method !== "GET" && method !== "HEAD") {
-    init.body = new ReadableStream({
-      start(controller2) {
-        req.on("data", (chunk) => {
-          controller2.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-        });
-        req.on("end", () => {
-          controller2.close();
-        });
+  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"] = cd(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.writeHead(standardResponse.status, {
+      ...standardResponse.headers,
+      "content-type": "application/json"
     });
-    init.duplex = "half";
-  }
-  return new Request(url, init);
+    const string = JSON.stringify(standardResponse.body);
+    res.end(string);
+  });
 }
-function createHeaders(req) {
-  const headers = new Headers();
-  const rawHeaders = req.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    headers.append(rawHeaders[i], rawHeaders[i + 1]);
+async function nodeHttpRequestToStandardBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
   }
-  return headers;
-}
-async function sendResponse(res, response) {
-  const headers = {};
-  for (const [key, value] of response.headers) {
-    if (key in headers) {
-      if (Array.isArray(headers[key])) {
-        headers[key].push(value);
-      } else {
-        headers[key] = [headers[key], value];
-      }
-    } else {
-      headers[key] = value;
+  const contentDisposition = req.headers["content-disposition"];
+  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+  const contentType = req.headers["content-type"];
+  if (fileName) {
+    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);
   }
-  res.writeHead(response.status, headers);
-  if (response.body != null && res.req.method !== "HEAD") {
-    for await (const chunk of response.body) {
-      res.write(chunk);
+  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();
   }
-  res.end();
+  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
-var RPCHandler2 = class {
-  orpcFetchHandler;
+// src/adapters/node/rpc-handler.ts
+var RPCHandler = class {
+  standardHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new RPCHandler(router, options);
+    const codec = options?.codec ?? new RPCCodec();
+    const matcher = options?.matcher ?? new RPCMatcher();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
   async handle(req, res, ...rest) {
-    const request = createRequest(req, res);
-    const result = await this.orpcFetchHandler.handle(request, ...rest);
-    if (result.matched === false) {
+    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
       return { matched: false };
     }
-    const context = rest[0]?.context ?? {};
-    await rest[0]?.beforeSend?.(result.response, context);
-    await sendResponse(res, result.response);
+    await nodeHttpResponseSendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  RPCHandler2 as RPCHandler,
-  createHeaders,
-  createRequest,
-  sendResponse
+  RPCHandler,
+  nodeHttpResponseSendStandardResponse,
+  nodeHttpToStandardRequest
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

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

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

@@ -1,6 +1,4 @@
-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,13 +1,5 @@
-import type { HTTPPath } from '@orpc/contract';
 import type { Context } from '../../context';
-export type FetchHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type FetchHandleRest<T extends Context> = [options: FetchHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+import type { StandardHandleRest } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -16,6 +8,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: FetchHandleRest<T>): Promise<FetchHandleResult>;
+    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/middleware.d.ts

@@ -1,8 +1,9 @@
 import type { Context as HonoContext, MiddlewareHandler } from 'hono';
 import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
 import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [HonoContext]>;
 } : {
     context: Value<T, [HonoContext]>;

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

@@ -1,8 +1,9 @@
 import type { NextRequest } from 'next/server';
 import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
 import { type Value } from '@orpc/shared';
-export type ServeOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [NextRequest]>;
 } : {
     context: Value<T, [NextRequest]>;

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

@@ -1,5 +1,4 @@
-export * from './orpc-handler';
-export * from './orpc-handler';
-export * from './request-listener';
+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,22 +1,21 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
 import type { Context } from '../../context';
-export type RequestHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-    beforeSend?(response: Response, context: T): Promisable<void>;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type RequestHandleRest<T extends Context> = [options: RequestHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
-export type RequestHandleResult = {
+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 type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+export type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-export interface RequestHandler<T extends Context> {
-    handle(req: IncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
+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,47 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { Interceptor } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Plugin } from '../../plugins';
+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 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;
+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