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

package/dist/adapters/standard/handler.js

@@ -1,205 +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),
-            ],
-        };
-    }
-}
+import { createProcedureClient } from "../../procedure-client.js";
+import { CompositeStandardHandlerPlugin } from "./plugin.js";
+import { ORPC_NAME, getTracer, intercept, isAsyncIteratorObject, matchesHttpPathPrefix, override, recordSpanError, runWithSpan, toArray, toTracingException, traceAsyncIterator, traceReadableStream, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
+import { ORPCError, toORPCError } from "@orpc/client";
+import { EventStreamErrorEvent, flattenStandardHeader, parseStandardUrl } from "@standard-server/core";
+// src/adapters/standard/handler.ts
+var StandardHandler = class {
+	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: void 0
+		};
+		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 {
+				return {
+					matched: true,
+					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 = void 0;
+						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 = void 0;
+						return await this.codec.encodeOutput(output, procedure, path, {
+							context,
+							prefix
+						});
+					})
+				};
+			} 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);
+				return {
+					matched: true,
+					response: await this.codec.encodeError(error, procedure, path, {
+						context,
+						prefix
+					})
+				};
+			}
+		});
+	}
+};
+var TracingHandlerPlugin = class {
+	name = "~tracing";
+	init(options) {
+		return {
+			...options,
+			routingInterceptors: [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)]
+		};
+	}
+};
+export { StandardHandler };

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

@@ -1,6 +1,7 @@
-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';
+import { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.js";
+import { ResolvedStandardHandlerHandleOptions, StandardHandler, StandardHandlerHandleOptions, StandardHandlerHandleResult, StandardHandlerInterceptor, StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerRoutingInterceptor, StandardHandlerRoutingInterceptorOptions } from "./handler.js";
+import { StandardHandlerPlugin } from "./plugin.js";
+import { RPCHandlerCodec, RPCHandlerCodecOptions } from "./rpc-handler-codec.js";
+import { RPCMatcher, RPCMatcherOptions, RPC_DEFAULT_ALLOW_METHODS } from "./rpc-matcher.js";
+import { FriendlyStandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions } from "./utils.js";
+export { FriendlyStandardHandlerHandleOptions, RPCHandlerCodec, RPCHandlerCodecOptions, RPCMatcher, RPCMatcherOptions, RPC_DEFAULT_ALLOW_METHODS, ResolvedStandardHandlerHandleOptions, StandardHandler, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions, StandardHandlerHandleResult, StandardHandlerInterceptor, StandardHandlerInterceptorOptions, StandardHandlerOptions, type StandardHandlerPlugin, StandardHandlerRoutingInterceptor, StandardHandlerRoutingInterceptorOptions, resolveFriendlyStandardHandlerHandleOptions };

package/dist/adapters/standard/index.js

@@ -1,5 +1,4 @@
-export * from './codec.js';
-export * from './handler.js';
-export * from './rpc-handler-codec.js';
-export * from './rpc-matcher.js';
-export * from './utils.js';
+export { StandardHandler } from "./handler.js";
+export { RPCHandlerCodec } from "./rpc-handler-codec.js";
+export { RPCMatcher, RPC_DEFAULT_ALLOW_METHODS } from "./rpc-matcher.js";
+export { resolveFriendlyStandardHandlerHandleOptions } from "./utils.js";

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

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

package/dist/adapters/standard/plugin.js

@@ -1,16 +1,14 @@
-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;
-    }
-}
+import { sortPlugins } from "@orpc/shared";
+// src/adapters/standard/plugin.ts
+var CompositeStandardHandlerPlugin = class {
+	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;
+	}
+};
+export { CompositeStandardHandlerPlugin };

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

@@ -1,46 +1,42 @@
-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';
+import { Context } from "../../context.js";
+import { AnyProcedure } from "../../procedure.js";
+import { ResolvedStandardHandlerHandleOptions } from "./handler.js";
+import { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.js";
+import { AnyRouter } from "../../router.js";
+import "./index.js";
+import { RPCMatcherOptions } from "./rpc-matcher.js";
+import { Promisable, Public, Value } from "@orpc/shared";
+import { AnyORPCError, RPCSerializer } from "@orpc/client";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
 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;
+  /**
+   * 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>;
-}
+  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>;
+}