@orpc/server 2.0.0-beta.48 → 2.0.0-beta.49

package/dist/adapters/message-port/rpc-handler.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { MessagePortHandlerOptions } from './handler.ts';
+import { MessagePortHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/message-port/rpc-handler.js

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { MessagePortHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
+export class RPCHandler extends MessagePortHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions } from '@standard-server/node';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+export type NodeHttpHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+export interface NodeHttpHandlerOptions<_T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+export declare class NodeHttpHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
+}

package/dist/adapters/node/handler.js

@@ -0,0 +1,20 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/node';
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+export class NodeHttpHandler {
+    standardHandler;
+    sendStandardResponseOptions;
+    constructor(standardHandler, options = {}) {
+        this.standardHandler = standardHandler;
+        this.sendStandardResponseOptions = options.sendStandardResponse;
+    }
+    async handle(request, response, ...rest) {
+        const standardRequest = toStandardLazyRequest(request, response);
+        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+        if (!result.matched) {
+            return result;
+        }
+        await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+        return result;
+    }
+}

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

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.ts';
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/node/index.js

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.js';
+export * from './handler.js';
+export * from './rpc-handler.js';

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

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { NodeHttpHandlerOptions } from './handler.ts';
+import { NodeHttpHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/node/rpc-handler.js

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { NodeHttpHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
+export class RPCHandler extends NodeHttpHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { AnyORPCError } from '@orpc/client';
+import type { Promisable } from '@orpc/shared';
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { AnyProcedure } from '../../procedure.ts';
+import type { ResolvedStandardHandlerHandleOptions } from './handler.ts';
+export interface StandardHandlerCodecResolvedProcedure {
+    path: string[];
+    procedure: AnyProcedure;
+    decodeInput: () => Promise<unknown>;
+}
+export interface StandardHandlerCodec<T extends Context> {
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}

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

@@ -0,0 +1,68 @@
+import type { ErrorMap, Schema } from '@orpc/contract';
+import type { Interceptor, Promisable, Value } from '@orpc/shared';
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { ProcedureClientInterceptor } from '../../procedure-client.ts';
+import type { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from './codec.ts';
+import type { StandardHandlerPlugin } from './plugin.ts';
+export interface StandardHandlerHandleOptions<T extends Context> {
+    prefix?: `/${string}` | undefined;
+    /**
+     * The initial context, or a function (sync or async) that receives the request and returns it.
+     * The function only runs once the request passes the prefix check.
+     */
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+}
+/**
+ * `StandardHandlerHandleOptions` after the context has been resolved,
+ * this is what interceptors and codecs receive.
+ */
+export interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
+    context: T;
+}
+export type StandardHandlerHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response?: undefined;
+};
+export interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+export type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
+export interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+export type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
+export interface StandardHandlerOptions<TContext extends Context> {
+    /**
+     * Fired on every request before routing, useful when you want
+     * to intercept all requests regardless of whether they match a procedure or not.
+     *
+     * @examples
+     * - batch plugins - separate one request into multiple and call multiple next
+     * - openapi spec plugin - to intercept a request and early response
+     */
+    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
+    /**
+     * interceptor run after routing and before error handler,
+     * useful for error handling, logging, metrics, etc.
+     */
+    interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
+    /**
+     *
+     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
+     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
+     */
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
+    plugins?: StandardHandlerPlugin<TContext>[] | undefined;
+}
+export declare class StandardHandler<T extends Context> {
+    private readonly codec;
+    private readonly routingInterceptors;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+}

package/dist/adapters/standard/handler.js

@@ -0,0 +1,205 @@
+import { ORPCError, toORPCError } from '@orpc/client';
+import { getTracer, intercept, isAsyncIteratorObject, matchesHttpPathPrefix, ORPC_NAME, override, recordSpanError, runWithSpan, toArray, toTracingException, traceAsyncIterator, traceReadableStream, value, wrapAsyncIterator, wrapReadableStream, } from '@orpc/shared';
+import { EventStreamErrorEvent, flattenStandardHeader, parseStandardUrl, } from '@standard-server/core';
+import { createProcedureClient } from '../../procedure-client.js';
+import { CompositeStandardHandlerPlugin } from './plugin.js';
+export class StandardHandler {
+    codec;
+    routingInterceptors;
+    interceptors;
+    clientInterceptors;
+    constructor(codec, options) {
+        this.codec = codec;
+        options = new CompositeStandardHandlerPlugin([
+            ...toArray(options.plugins),
+            new TracingHandlerPlugin(),
+        ]).init(options);
+        this.routingInterceptors = options.routingInterceptors;
+        this.interceptors = options.interceptors;
+        this.clientInterceptors = options.clientInterceptors;
+    }
+    async handle(request, options) {
+        const { prefix } = options;
+        if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
+            return { matched: false, response: undefined };
+        }
+        const context = (await value(options.context, request));
+        return intercept(this.routingInterceptors, { context, prefix, request }, async ({ context, prefix, request }) => {
+            const span = getTracer()?.getActiveSpan();
+            let step;
+            const matchedOrNot = await runWithSpan('find_procedure', () => this.codec.resolveProcedure(request, { context, prefix }));
+            if (!matchedOrNot) {
+                /**
+                 * [Semantic conventions for HTTP spans](https://opentelemetry.io/docs/specs/semconv/http/http-spans/)
+                 */
+                span?.updateName(`${ORPC_NAME}_no_match`);
+                span?.setAttribute('http.request.method', request.method);
+                span?.setAttribute('url.path', request.url);
+                return { matched: false };
+            }
+            const { path, procedure, decodeInput } = matchedOrNot;
+            /**
+             * [Semantic conventions for RPC spans](https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/)
+             */
+            span?.updateName(`${ORPC_NAME}.${path.join('/')}`);
+            span?.setAttribute('rpc.system', ORPC_NAME);
+            span?.setAttribute('rpc.method', path.join('.'));
+            try {
+                const response = await intercept(this.interceptors, { context, prefix, request, path, procedure, decodeInput }, async ({ context, prefix, request, path, procedure, decodeInput }) => {
+                    step = 'decode_input';
+                    let input = await runWithSpan('decode_input', decodeInput);
+                    step = undefined;
+                    if (getTracer() && isAsyncIteratorObject(input)) {
+                        /**
+                         * @warning
+                         * Remember use `override` for AsyncIteratorObject to remain other special properties
+                         */
+                        input = override(input, traceAsyncIterator('consume_async_iterator_object_input', input));
+                    }
+                    else if (getTracer() && input instanceof ReadableStream) {
+                        /**
+                         * @warning
+                         * Remember use `override` for ReadableStream to remain other special properties
+                         */
+                        input = override(input, traceReadableStream('consume_octet_stream_input', input));
+                    }
+                    const client = createProcedureClient(procedure, {
+                        context,
+                        path,
+                        interceptors: this.clientInterceptors,
+                    });
+                    /**
+                     * No need to use `runWithSpan` here, because the client already has its own span.
+                     */
+                    step = 'call_procedure';
+                    const output = await client(input, {
+                        signal: request.signal,
+                        lastEventId: flattenStandardHeader(request.headers['last-event-id']),
+                    });
+                    step = undefined;
+                    const response = await this.codec.encodeOutput(output, procedure, path, {
+                        context,
+                        prefix,
+                    });
+                    return response;
+                });
+                return { matched: true, response };
+            }
+            catch (e) {
+                /**
+                 * Only errors that happen outside of the `call_procedure` step should be set as an error.
+                 * Because a business logic error should not be considered as a protocol-level error.
+                 */
+                if (step !== 'call_procedure') {
+                    recordSpanError(span, e);
+                }
+                const error = step === 'decode_input' && !(e instanceof ORPCError)
+                    ? new ORPCError('BAD_REQUEST', {
+                        message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+                        cause: e,
+                    })
+                    : toORPCError(e);
+                const response = await this.codec.encodeError(error, procedure, path, { context, prefix });
+                return { matched: true, response };
+            }
+        });
+    }
+}
+class TracingHandlerPlugin {
+    name = '~tracing';
+    init(options) {
+        return {
+            ...options,
+            routingInterceptors: [
+                // Should be placed before user-provided interceptors to help them access the current active span.
+                async ({ next, request }) => {
+                    const tracer = getTracer();
+                    if (!tracer) {
+                        return next();
+                    }
+                    const parent = tracer.extract?.(request.headers);
+                    /**
+                     * The search part is excluded because span names should have low cardinality.
+                     * The name is replaced with the procedure path once the request is routed.
+                     */
+                    const [pathname] = parseStandardUrl(request.url);
+                    return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
+                        try {
+                            const result = await next();
+                            if (!result.matched) {
+                                span.end();
+                                return result;
+                            }
+                            const body = result.response.body;
+                            if (isAsyncIteratorObject(body)) {
+                                return {
+                                    ...result,
+                                    response: {
+                                        ...result.response,
+                                        /**
+                                         * @remarks
+                                         * **Warning**: Remember use `override` for remaining special properties
+                                         */
+                                        body: override(body, wrapAsyncIterator(body, {
+                                            runWith: (fn) => tracer.withActiveSpan(span, fn),
+                                            onError(error) {
+                                                /**
+                                                 * Errors here are internal (interceptor/framework) failures,
+                                                 * except `EventStreamErrorEvent`: a business error the protocol delivers
+                                                 * inside the event stream, already logged by the client interceptor.
+                                                 */
+                                                if (!(error instanceof EventStreamErrorEvent)) {
+                                                    span.recordException('error', toTracingException(error));
+                                                }
+                                            },
+                                            onFinish() {
+                                                span.end();
+                                            },
+                                        })),
+                                    },
+                                };
+                            }
+                            if (body instanceof ReadableStream) {
+                                return {
+                                    ...result,
+                                    response: {
+                                        ...result.response,
+                                        /**
+                                         * @remarks
+                                         * **Warning**: Remember use `override` for remaining special properties
+                                         */
+                                        body: override(body, wrapReadableStream(body, {
+                                            runWith: (fn) => tracer.withActiveSpan(span, fn),
+                                            onError(error) {
+                                                /**
+                                                 * Any error here is internal (interceptor/framework), not business logic.
+                                                 * Indicates unexpected handler failure.
+                                                 */
+                                                span.recordException('error', toTracingException(error));
+                                            },
+                                            onFinish() {
+                                                span.end();
+                                            },
+                                        })),
+                                    },
+                                };
+                            }
+                            span.end();
+                            return result;
+                        }
+                        catch (e) {
+                            /**
+                             * Any error here is internal (interceptor/framework), not business logic.
+                             * Always recorded as an error, even when it is an abort error.
+                             */
+                            span.recordException('error', toTracingException(e));
+                            span.end();
+                            throw e;
+                        }
+                    });
+                },
+                ...toArray(options.routingInterceptors),
+            ],
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from './codec.ts';
+export * from './handler.ts';
+export type { StandardHandlerPlugin } from './plugin.ts';
+export * from './rpc-handler-codec.ts';
+export * from './rpc-matcher.ts';
+export * from './utils.ts';

package/dist/adapters/standard/index.js

@@ -0,0 +1,5 @@
+export * from './codec.js';
+export * from './handler.js';
+export * from './rpc-handler-codec.js';
+export * from './rpc-matcher.js';
+export * from './utils.js';

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

@@ -0,0 +1,32 @@
+import type { OrderablePlugin } from '@orpc/shared';
+import type { Context } from '../../context.ts';
+import type { StandardHandlerOptions } from './handler.ts';
+export interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform handler options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+export declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    readonly name = "~composite";
+    protected readonly plugins: StandardHandlerPlugin<T>[];
+    constructor(plugins?: StandardHandlerPlugin<T>[]);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/adapters/standard/plugin.js

@@ -0,0 +1,16 @@
+import { sortPlugins } from '@orpc/shared';
+export class CompositeStandardHandlerPlugin {
+    name = '~composite';
+    plugins;
+    constructor(plugins = []) {
+        this.plugins = sortPlugins(plugins);
+    }
+    init(options) {
+        for (const plugin of this.plugins) {
+            if (plugin.init) {
+                options = plugin.init(options);
+            }
+        }
+        return options;
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { AnyORPCError } from '@orpc/client';
+import { RPCSerializer } from '@orpc/client';
+import type { Promisable, Public, Value } from '@orpc/shared';
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { AnyProcedure } from '../../procedure.ts';
+import type { AnyRouter } from '../../router.ts';
+import type { ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from '../standard/index.ts';
+import type { RPCMatcherOptions } from './rpc-matcher.ts';
+export interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+    /**
+     * Override the default RPC serializer.
+     */
+    serializer?: Public<RPCSerializer> | undefined;
+    /**
+     * Resolve HTTP status for encoded successful outputs.
+     *
+     * Value should be in the `2xx` range and must be less than `400`.
+     *
+     * @default DEFAULT_SUCCESS_STATUS (200)
+     */
+    outputStatus?: Value<number, [
+        output: unknown,
+        procedure: AnyProcedure,
+        path: string[],
+        options: ResolvedStandardHandlerHandleOptions<T>
+    ]> | undefined;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
+     * Codes missing from the map fall back to `DEFAULT_ERROR_STATUS` (400).
+     *
+     * @default COMMON_ERROR_STATUS_MAP
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+export declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly outputStatus;
+    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}

package/dist/adapters/standard/rpc-handler-codec.js

@@ -0,0 +1,51 @@
+import { COMMON_ERROR_STATUS_MAP, RPCSerializer } from '@orpc/client';
+import { getOwn, parseEmptyableJSON, value } from '@orpc/shared';
+import { parseStandardUrl } from '@standard-server/core';
+import { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS } from '../../constants.js';
+import { RPCMatcher } from './rpc-matcher.js';
+export class RPCHandlerCodec {
+    matcher;
+    serializer;
+    errorStatusMap;
+    outputStatus;
+    constructor(router, options = {}) {
+        this.matcher = new RPCMatcher(router, options);
+        this.serializer = options.serializer ?? new RPCSerializer();
+        this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+        this.outputStatus = options.outputStatus ?? DEFAULT_SUCCESS_STATUS;
+    }
+    async resolveProcedure(request, options) {
+        const [pathname, query] = parseStandardUrl(request.url);
+        const matched = await this.matcher.match(request.method, pathname, options.prefix);
+        if (!matched) {
+            return undefined;
+        }
+        return {
+            procedure: matched.procedure,
+            path: matched.path,
+            decodeInput: async () => {
+                if (request.method === 'GET') {
+                    const dataString = new URLSearchParams(query).getAll('data').at(-1);
+                    return this.serializer.deserialize(parseEmptyableJSON(dataString));
+                }
+                const body = await request.resolveBody();
+                return this.serializer.deserialize(body);
+            },
+        };
+    }
+    encodeOutput(output, procedure, path, options) {
+        return {
+            headers: {},
+            status: value(this.outputStatus, output, procedure, path, options),
+            body: this.serializer.serialize(output),
+        };
+    }
+    encodeError(error, _procedure, _path, _options) {
+        const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
+        return {
+            headers: {},
+            status,
+            body: this.serializer.serialize(error.toJSON()),
+        };
+    }
+}

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

@@ -0,0 +1,53 @@
+import type { AnyProcedureContract } from '@orpc/contract';
+import type { Value } from '@orpc/shared';
+import type { StandardMethod } from '@standard-server/core';
+import type { AnyProcedure } from '../../procedure.ts';
+import type { AnyRouter } from '../../router.ts';
+/**
+ * Methods that can invoke procedures by default. Browsers cannot trigger them
+ * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+ * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+ * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+ * invoke a procedure that can modify data.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+ */
+export declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
+export interface RPCMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
+    /**
+     * Restricts which HTTP methods can invoke procedures, either with a list of allowed
+     * methods or decided per request via a function. Requests using a disallowed method
+     * are treated as unmatched. `GET` is excluded by default because it is exposed to
+     * Cross-Site Request Forgery (CSRF) attacks.
+     *
+     * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
+     * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+     */
+    allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
+}
+export declare class RPCMatcher {
+    private readonly filter;
+    private readonly allowMethodsSet;
+    private readonly allowMethodsFn;
+    private readonly rootRouter;
+    private readonly tree;
+    private readonly pendingLazyRouters;
+    /** segment count of the deepest pending key, never lowered so it stays an upper bound */
+    private maxPendingLazyRouterDepth;
+    constructor(router: AnyRouter, options?: RPCMatcherOptions);
+    private index;
+    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+    private resolvePendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
+    private resolveProcedure;
+}