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

package/dist/adapters/message-port/index.d.ts

@@ -1,74 +1,3 @@
-import { SupportedMessagePort } from '@orpc/client/message-port';
-import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
-interface MessagePortHandlerOptions<_T extends Context> {
-    /**
-     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
-     * Use this option to bypass encoding and leverage the full capabilities of the
-     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
-     *
-     * @remarks
-     * - Returning `null` or `undefined` disables this feature.
-     *
-     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
-     */
-    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class MessagePortHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly transfer;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
-     */
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
-    /**
-     * Handles a single message received from a message port.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
-     */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
-     */
-    close(port: SupportedMessagePort): Promise<void>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
-}
-declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { MessagePortHandler, RPCHandler };
-export type { MessagePortHandlerOptions, RPCHandlerOptions };
+import { MessagePortHandler, MessagePortHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { MessagePortHandler, MessagePortHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/message-port/index.js

@@ -0,0 +1,2 @@
+export { MessagePortHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

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

@@ -0,0 +1,16 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { MessagePortHandler, MessagePortHandlerOptions } from "./handler.js";
+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,18 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { MessagePortHandler } from "./handler.js";
+// src/adapters/message-port/rpc-handler.ts
+/**
+* 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}
+*/
+var RPCHandler = class extends MessagePortHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -0,0 +1,23 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions } from "@standard-server/node";
+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 { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/node";
+// src/adapters/node/handler.ts
+var NodeHttpHandler = class {
+	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;
+	}
+};
+export { NodeHttpHandler };

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

@@ -1,121 +1,4 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import compression from '@orpc/interop/compression';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new node HTTP handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform node HTTP handler options
-     * such as interceptors, or other configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initNodeHttpHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http-handler";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-type NodeHttpHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
-interface NodeHttpHandlerOptions<T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Node HTTP API,
-     * useful for extending Node HTTP request/response before handling, ...
-     */
-    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
-    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
-}
-declare class NodeHttpHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
-}
-
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
-    /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
-     */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
-}
-declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+import { RequestLimitHandlerPlugin } from "../../plugins/request-limit.js";
+import { NodeHttpHandler, NodeHttpHandlerHandleResult, NodeHttpHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { RequestLimitHandlerPlugin as BodyLimitPlugin, NodeHttpHandler, NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/node/index.js

@@ -0,0 +1,3 @@
+export { RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.js";
+export { NodeHttpHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

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

@@ -0,0 +1,16 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { NodeHttpHandler, NodeHttpHandlerOptions } from "./handler.js";
+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,18 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { NodeHttpHandler } from "./handler.js";
+// src/adapters/node/rpc-handler.ts
+/**
+* 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}
+*/
+var RPCHandler = class extends NodeHttpHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -0,0 +1,16 @@
+import { Context } from "../../context.js";
+import { AnyProcedure } from "../../procedure.js";
+import { ResolvedStandardHandlerHandleOptions } from "./handler.js";
+import { Promisable } from "@orpc/shared";
+import { AnyORPCError } from "@orpc/client";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+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 { Context } from "../../context.js";
+import { ProcedureClientInterceptor } from "../../procedure-client.js";
+import { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.js";
+import { StandardHandlerPlugin } from "./plugin.js";
+import { ErrorMap, Schema } from "@orpc/contract";
+import { Interceptor, Promisable, Value } from "@orpc/shared";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+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 { 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,19 +1,7 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.DBANIheG.js';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DBANIheG.js';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.d_2NS3g5.js';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
-import '@orpc/contract';
-import '../../shared/server.Pa0F03f_.js';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };
+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

@@ -0,0 +1,4 @@
+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";