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

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

@@ -1,95 +1,6 @@
-import { R as ResolvedStandardHandlerHandleOptions, f as StandardHandlerCodec, g as StandardHandlerCodecResolvedProcedure } from '../../shared/server.DOg7ke6y.js';
-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.DOg7ke6y.js';
-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.js';
-import { AnyRouter } from '../../index.js';
-import { AnyProcedureContract } from '@orpc/contract';
-export { F as FriendlyStandardHandlerHandleOptions, r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.BSYGskId.js';
-
-/**
- * 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.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;
+}

package/dist/adapters/standard/rpc-matcher.js

@@ -0,0 +1,152 @@
+import { normalizeHttpPath, pathToHttpPath, value } from '@orpc/shared';
+import { unlazy } from '../../lazy.js';
+import { Procedure } from '../../procedure.js';
+import { resolveContractProcedure, walkProcedureContractsSync } from '../../router-utils.js';
+/**
+ * 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 const RPC_DEFAULT_ALLOW_METHODS = [
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+];
+// `%` or a char `encodeURIComponent` encodes, meaning normalization may change the pathname
+const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
+export class RPCMatcher {
+    filter;
+    allowMethodsSet;
+    allowMethodsFn;
+    rootRouter;
+    tree = new Map();
+    pendingLazyRouters = new Map();
+    /** segment count of the deepest pending key, never lowered so it stays an upper bound */
+    maxPendingLazyRouterDepth = 0;
+    constructor(router, options = {}) {
+        this.filter = options.filter ?? true;
+        const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
+        if (typeof allowMethods !== 'function') {
+            this.allowMethodsSet = new Set(allowMethods);
+        }
+        else {
+            this.allowMethodsFn = allowMethods;
+        }
+        this.rootRouter = router;
+        this.index(router);
+    }
+    index(router, path = []) {
+        const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
+            if (!value(this.filter, procedure, procedurePath)) {
+                return;
+            }
+            this.tree.set(pathToHttpPath(procedurePath), {
+                path: procedurePath,
+                contract: procedure,
+                // contract-first entries have no implementation yet, resolveProcedure fills it in on demand
+                procedure: procedure instanceof Procedure ? procedure : undefined,
+            });
+        }, path);
+        for (const result of lazyResults) {
+            this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
+            this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
+        }
+    }
+    async match(method, pathname, prefix) {
+        if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
+            return undefined;
+        }
+        if (prefix) {
+            if (!pathname.startsWith(prefix)) {
+                return undefined;
+            }
+            const charAfterPrefix = pathname[prefix.length];
+            if (charAfterPrefix === '/') {
+                pathname = pathname.slice(prefix.length);
+            }
+            else if (charAfterPrefix === undefined) {
+                pathname = '/';
+            }
+            else if (prefix[prefix.length - 1] === '/') {
+                pathname = pathname.slice(prefix.length - 1);
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (pathname.length > 1 && pathname.endsWith('/')) {
+            pathname = pathname.slice(0, -1);
+        }
+        // most requests `await undefined` so conditionally await it to save a microtask turn
+        const loading = this.resolvePendingLazyRouters(pathname);
+        if (loading !== undefined) {
+            await loading;
+        }
+        let entry = this.tree.get(pathname);
+        if (entry === undefined && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
+            // Retry with a normalized path: users may percent-encode characters that we store
+            // unencoded ("a%62c" vs "abc"), or leave raw characters that we store encoded
+            // ("a^b" vs "a%5Eb"), so normalization handles both without duplicate entries.
+            const normalizedPathname = normalizeHttpPath(pathname);
+            // most requests `await undefined` so conditionally await it to save a microtask turn
+            const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+            if (normalizedLoading !== undefined) {
+                await normalizedLoading;
+            }
+            entry = this.tree.get(normalizedPathname);
+        }
+        if (entry === undefined) {
+            return undefined;
+        }
+        const procedure = entry.procedure ?? (await this.resolveProcedure(entry));
+        if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
+            return undefined;
+        }
+        return {
+            path: entry.path,
+            procedure,
+        };
+    }
+    resolvePendingLazyRouters(pathname) {
+        if (this.pendingLazyRouters.size === 0) {
+            return;
+        }
+        let slashIndex = 0;
+        // a pending key has as many segments as its path, so deeper prefixes can never match,
+        // and scanning them would cost quadratic time on slash-heavy pathnames
+        for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
+            const nextSlashIndex = pathname.indexOf('/', slashIndex + 1);
+            const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+            const pending = this.pendingLazyRouters.get(httpPathPrefix);
+            if (pending !== undefined) {
+                return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
+            }
+            slashIndex = nextSlashIndex;
+        }
+    }
+    loadPendingLazyRouter(httpPathPrefix, pending) {
+        if (pending.loading === undefined) {
+            pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+                pending.loading = undefined;
+                throw error;
+            });
+        }
+        return pending.loading;
+    }
+    async indexPendingLazyRouter(httpPathPrefix, pending) {
+        const { default: router } = await unlazy(pending.router);
+        this.index(router, pending.path);
+        // removed only once indexed, so a concurrent match never observes this router as
+        // neither pending nor indexed
+        this.pendingLazyRouters.delete(httpPathPrefix);
+    }
+    async resolveProcedure(entry) {
+        entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
+        return entry.procedure;
+    }
+}