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

package/dist/adapters/standard/codec.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -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.mjs";
+import type { ProcedureClientInterceptor } from "../../procedure-client.mjs";
+import type { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.mjs";
+import type { StandardHandlerPlugin } from "./plugin.mjs";
+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.mjs

@@ -0,0 +1,185 @@
+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 { ErrorEvent, flattenStandardHeader, parseStandardUrl } from "@standard-server/core";
+import { createProcedureClient } from "../../procedure-client.mjs";
+import { CompositeStandardHandlerPlugin } from "./plugin.mjs";
+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) {
+				
+				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;
+			
+			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)) {
+						
+						input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+					} else if (getTracer() && input instanceof ReadableStream) {
+						
+						input = override(input, traceReadableStream("consume_octet_stream_input", input));
+					}
+					const client = createProcedureClient(procedure, {
+						context,
+						path,
+						interceptors: this.clientInterceptors
+					});
+					
+					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) {
+				
+				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: [async ({ next, request }) => {
+				const tracer = getTracer();
+				if (!tracer) {
+					return next();
+				}
+				const parent = tracer.extract?.(request.headers);
+				
+				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,
+									
+									body: override(body, wrapAsyncIterator(body, {
+										runWith: (fn) => tracer.withActiveSpan(span, fn),
+										onError(error) {
+											
+											if (!(error instanceof ErrorEvent)) {
+												span.recordException("error", toTracingException(error));
+											}
+										},
+										onFinish() {
+											span.end();
+										}
+									}))
+								}
+							};
+						}
+						if (body instanceof ReadableStream) {
+							return {
+								...result,
+								response: {
+									...result.response,
+									
+									body: override(body, wrapReadableStream(body, {
+										runWith: (fn) => tracer.withActiveSpan(span, fn),
+										onError(error) {
+											
+											span.recordException("error", toTracingException(error));
+										},
+										onFinish() {
+											span.end();
+										}
+									}))
+								}
+							};
+						}
+						span.end();
+						return result;
+					} catch (e) {
+						
+						span.recordException("error", toTracingException(e));
+						span.end();
+						throw e;
+					}
+				});
+			}, ...toArray(options.routingInterceptors)]
+		};
+	}
+}

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

@@ -1,95 +1,6 @@
-import { R as ResolvedStandardHandlerHandleOptions, f as StandardHandlerCodec, g as StandardHandlerCodecResolvedProcedure } from '../../shared/server.9B1jEm5a.mjs';
-export { S as StandardHandler, a as StandardHandlerHandleOptions, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, e as StandardHandlerInterceptorOptions, c as StandardHandlerOptions, b as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, d as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.9B1jEm5a.mjs';
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Public, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { AnyProcedure, Context } from '../../index.mjs';
-import { AnyRouter } from '../../index.mjs';
-import { AnyProcedureContract } from '@orpc/contract';
-export { F as FriendlyStandardHandlerHandleOptions, r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.BvG3boBj.mjs';
-
-/**
- * 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}
- */
-declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
-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;
-}
-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;
-}
-
-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`.
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_SUCCESS_STATUS (200)
-     */
-    outputStatus?: Value<number | undefined | null, [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;
-}
-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>;
-}
-
-export { RPCHandlerCodec, RPCMatcher, RPC_DEFAULT_ALLOW_METHODS, ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure };
-export type { RPCHandlerCodecOptions, RPCMatcherOptions };
+export * from "./codec.mjs";
+export * from "./handler.mjs";
+export type { StandardHandlerPlugin } from "./plugin.mjs";
+export * from "./rpc-handler-codec.mjs";
+export * from "./rpc-matcher.mjs";
+export * from "./utils.mjs";

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,5 @@
-export { R as RPCHandlerCodec, a as RPCMatcher, b as RPC_DEFAULT_ALLOW_METHODS, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@orpc/shared';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
+export * from "./codec.mjs";
+export * from "./handler.mjs";
+export * from "./rpc-handler-codec.mjs";
+export * from "./rpc-matcher.mjs";
+export * from "./utils.mjs";

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

@@ -0,0 +1,32 @@
+import type { OrderablePlugin } from "@orpc/shared";
+import type { Context } from "../../context.mjs";
+import type { StandardHandlerOptions } from "./handler.mjs";
+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.mjs

@@ -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.mts

@@ -0,0 +1,42 @@
+import type { AnyORPCError } from "@orpc/client";
+import type { Promisable, Public, Value } from "@orpc/shared";
+import type { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+import type { Context } from "../../context.mjs";
+import type { AnyProcedure } from "../../procedure.mjs";
+import type { AnyRouter } from "../../router.mjs";
+import type { ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./index.mjs";
+import type { RPCMatcherOptions } from "./rpc-matcher.mjs";
+import { RPCSerializer } from "@orpc/client";
+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`.
+	* Return `undefined` or `null` to fallback to default
+	*
+	* @default DEFAULT_SUCCESS_STATUS (200)
+	*/
+	outputStatus?: Value<number | undefined | null, [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.mjs

@@ -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.mjs";
+import { RPCMatcher } from "./rpc-matcher.mjs";
+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;
+	}
+	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) ?? DEFAULT_SUCCESS_STATUS,
+			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.mts

@@ -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.mjs";
+import type { AnyRouter } from "../../router.mjs";
+/**
+* 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;
+}