@orpc/server 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/shared/{server.GDpX6Df8.mjs → server.BFEVk-EI.mjs}

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CrlKQucM.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BwHnWUuN.mjs';
+import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, wrapAsyncIterator, toTracingException, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.FEqy7Hrj.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BgvqVW_v.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -24,8 +24,8 @@ class StandardHandler {
   constructor(codec, options) {
     this.codec = codec;
     options = new CompositeStandardHandlerPlugin([
-      new OtelHandlerPlugin(),
-      ...toArray(options.plugins)
+      ...toArray(options.plugins),
+      new TracingHandlerPlugin()
     ]).init(options);
     this.routingInterceptors = options.routingInterceptors;
     this.interceptors = options.interceptors;
@@ -34,15 +34,17 @@ class StandardHandler {
   routingInterceptors;
   interceptors;
   clientInterceptors;
-  async handle(request, { context, prefix }) {
+  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: context2, prefix: prefix2, request: request2 }) => {
-        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+        const span = getTracer()?.getActiveSpan();
         let step;
         const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
         if (!matchedOrNot) {
@@ -63,8 +65,10 @@ class StandardHandler {
               step = "decode_input";
               let input = await runWithSpan("decode_input", decodeInput2);
               step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+              if (getTracer() && isAsyncIteratorObject(input)) {
+                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+              } else if (getTracer() && input instanceof ReadableStream) {
+                input = override(input, traceReadableStream("consume_octet_stream_input", input));
               }
               const client = createProcedureClient(procedure2, {
                 context: context3,
@@ -97,23 +101,80 @@ class StandardHandler {
     );
   }
 }
-class OtelHandlerPlugin {
-  name = "~opentelemetry";
+class TracingHandlerPlugin {
+  name = "~tracing";
   init(options) {
     return {
       ...options,
       routingInterceptors: [
-        // Should be placed before user-provided interceptors to help them access the current active context.
+        // Should be placed before user-provided interceptors to help them access the current active span.
         async ({ next, request }) => {
-          const otelConfig = getOpenTelemetryConfig();
-          let propagationContext;
-          if (otelConfig?.propagation) {
-            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+          const tracer = getTracer();
+          if (!tracer) {
+            return next();
           }
-          return runWithSpan(
-            { name: `${request.method} ${request.url}`, context: propagationContext },
-            () => next()
-          );
+          const parent = tracer.extract?.(request.headers);
+          const [pathname] = parseStandardUrl(request.url);
+          return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
+            try {
+              const result = await next();
+              if (!result.matched) {
+                span.end();
+                return result;
+              }
+              const body = result.response.body;
+              if (isAsyncIteratorObject(body)) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapAsyncIterator(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        if (!(error instanceof ErrorEvent)) {
+                          span.recordException("error", toTracingException(error));
+                        }
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
+                  }
+                };
+              }
+              if (body instanceof ReadableStream) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapReadableStream(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        span.recordException("error", toTracingException(error));
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
+                  }
+                };
+              }
+              span.end();
+              return result;
+            } catch (e) {
+              span.recordException("error", toTracingException(e));
+              span.end();
+              throw e;
+            }
+          });
         },
         ...toArray(options.routingInterceptors)
       ]
@@ -121,13 +182,22 @@ class OtelHandlerPlugin {
   }
 }
 
+const RPC_DEFAULT_ALLOW_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
 class RPCMatcher {
   filter;
+  allowMethodsSet;
+  allowMethodsFn;
   rootRouter;
   tree = /* @__PURE__ */ new Map();
-  pendingLazyRouters = [];
+  pendingLazyRouters = /* @__PURE__ */ new Map();
   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);
   }
@@ -136,30 +206,20 @@ class RPCMatcher {
       if (!value(this.filter, procedure, procedurePath)) {
         return;
       }
-      const httpPath = pathToHttpPath(procedurePath);
-      if (procedure instanceof Procedure) {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure,
-          procedure
-        });
-      } else {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure
-        });
-      }
+      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 : void 0
+      });
     }, path);
-    this.pendingLazyRouters.push(
-      ...lazyResults.map((result) => ({
-        ...result,
-        httpPathPrefix: pathToHttpPath(result.path)
-      }))
-    );
+    for (const result of lazyResults) {
+      this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
+    }
   }
-  async match(_method, pathname, prefix) {
-    if (pathname.length > 1 && pathname.endsWith("/")) {
-      pathname = pathname.slice(0, -1);
+  async match(method, pathname, prefix) {
+    if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
+      return void 0;
     }
     if (prefix) {
       if (!pathname.startsWith(prefix)) {
@@ -176,40 +236,74 @@ class RPCMatcher {
         return void 0;
       }
     }
-    const result = await this.matchPathname(pathname);
-    if (!result && pathname.includes("%")) {
-      return this.matchPathname(normalizeHttpPath(pathname));
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
     }
-    return result;
-  }
-  async matchPathname(pathname) {
-    await this.resolvePendingLazyRouters(pathname);
-    const entry = this.tree.get(pathname);
-    if (!entry) {
+    const loading = this.resolvePendingLazyRouters(pathname);
+    if (loading !== void 0) {
+      await loading;
+    }
+    let entry = this.tree.get(pathname);
+    if (entry === void 0 && pathname.includes("%")) {
+      const normalizedPathname = normalizeHttpPath(pathname);
+      const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+      if (normalizedLoading !== void 0) {
+        await normalizedLoading;
+      }
+      entry = this.tree.get(normalizedPathname);
+    }
+    if (entry === void 0) {
+      return void 0;
+    }
+    const procedure = entry.procedure ?? await this.resolveProcedure(entry);
+    if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
       return void 0;
     }
-    const procedure = await this.resolveProcedure(entry);
-    return { path: entry.path, procedure };
+    return {
+      path: entry.path,
+      procedure
+    };
   }
-  async resolvePendingLazyRouters(pathname) {
-    if (!this.pendingLazyRouters.length) {
+  resolvePendingLazyRouters(pathname) {
+    if (this.pendingLazyRouters.size === 0) {
       return;
     }
-    const stillPending = [];
-    for (const pending of this.pendingLazyRouters) {
-      if (pathname.startsWith(pending.httpPathPrefix)) {
-        const { default: router } = await unlazy(pending.router);
-        this.index(router, pending.path);
-      } else {
-        stillPending.push(pending);
+    let slashIndex = 0;
+    while (slashIndex !== -1) {
+      const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+      const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+      if (this.pendingLazyRouters.has(httpPathPrefix)) {
+        return this.loadPendingLazyRouters(pathname, slashIndex);
       }
+      slashIndex = nextSlashIndex;
     }
-    this.pendingLazyRouters = stillPending;
   }
-  async resolveProcedure(entry) {
-    if (entry.procedure) {
-      return entry.procedure;
+  async loadPendingLazyRouters(pathname, slashIndex) {
+    while (slashIndex !== -1) {
+      const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+      const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+      const pending = this.pendingLazyRouters.get(httpPathPrefix);
+      if (pending !== void 0) {
+        await this.loadPendingLazyRouter(httpPathPrefix, pending);
+      }
+      slashIndex = nextSlashIndex;
+    }
+  }
+  loadPendingLazyRouter(httpPathPrefix, pending) {
+    if (pending.loading === void 0) {
+      pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+        pending.loading = void 0;
+        throw error;
+      });
     }
+    return pending.loading;
+  }
+  async indexPendingLazyRouter(httpPathPrefix, pending) {
+    const { default: router } = await unlazy(pending.router);
+    this.index(router, pending.path);
+    this.pendingLazyRouters.delete(httpPathPrefix);
+  }
+  async resolveProcedure(entry) {
     const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
     if (!(maybeProcedure instanceof Procedure)) {
       throw new TypeError(
@@ -259,7 +353,7 @@ class RPCHandlerCodec {
     };
   }
   encodeError(error, _procedure, _path, _options) {
-    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
     return {
       headers: {},
       status,
@@ -268,4 +362,4 @@ class RPCHandlerCodec {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };
+export { CompositeStandardHandlerPlugin as C, RPCHandlerCodec as R, StandardHandler as S, TracingHandlerPlugin as T, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

package/dist/shared/{server.BwHnWUuN.mjs → server.BgvqVW_v.mjs}

@@ -1,6 +1,6 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CrlKQucM.mjs';
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.FEqy7Hrj.mjs';
 import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
-import { getOrBind, isTypescriptObject } from '@orpc/shared';
+import { omit, isTypescriptObject, getOwn } from '@orpc/shared';
 
 const DEFAULT_SUCCESS_STATUS = 200;
 const DEFAULT_ERROR_STATUS = 500;
@@ -44,7 +44,7 @@ function withHiddenRouterContract(router, contract) {
       if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
         return contract;
       }
-      return getOrBind(target, key);
+      return Reflect.get(target, key);
     }
   });
 }
@@ -77,6 +77,7 @@ function augmentRouter(router, options) {
       router["~orpc"].metaPlugins
     );
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
       ...router["~orpc"],
       meta,
       metaPlugins,
@@ -92,8 +93,8 @@ function augmentRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentRouter(child, options);
   }
   return enhanced;
 }
@@ -111,6 +112,7 @@ function augmentImplementedRouter(router, options) {
   }
   if (router instanceof Procedure) {
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares"]),
       ...router["~orpc"],
       orderedMiddlewares: [
         ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
@@ -123,8 +125,8 @@ function augmentImplementedRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentImplementedRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentImplementedRouter(child, options);
   }
   return enhanced;
 }
@@ -139,7 +141,7 @@ function getRouter(router, path) {
       return void 0;
     }
     if (!(current instanceof Lazy)) {
-      current = current[segment];
+      current = getOwn(current, segment);
       continue;
     }
     const lazied = current;
@@ -159,27 +161,31 @@ function getRouter(router, path) {
   return current;
 }
 function walkProcedureContractsSync(router, callback, path = []) {
+  const lazyResults = [];
+  walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
+  return lazyResults;
+}
+function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
   const hiddenContract = getHiddenRouterContract(router);
   if (hiddenContract !== void 0) {
     router = hiddenContract;
   }
   if (router instanceof ProcedureContract) {
-    callback(router, path);
-    return [];
+    callback(router, path.slice());
+    return;
   }
   if (!isTypescriptObject(router)) {
-    return [];
+    return;
   }
-  const lazyResults = [];
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
+    path.push(key);
     if (value instanceof Lazy) {
-      lazyResults.push({ router: value, path: [...path, key] });
+      lazyResults.push({ router: value, path: path.slice() });
     } else {
-      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
+      walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
     }
+    path.pop();
   }
-  return lazyResults;
 }
 async function walkProcedureContractsAsync(router, callback, path = []) {
   const hiddenContract = getHiddenRouterContract(router);
@@ -193,8 +199,7 @@ async function walkProcedureContractsAsync(router, callback, path = []) {
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     if (value instanceof Lazy) {
       const { default: router2 } = await unlazy(value);
       await walkProcedureContractsAsync(router2, callback, [...path, key]);
@@ -211,7 +216,7 @@ async function unlazyRouter(router) {
     return router;
   }
   const unlazied = {};
-  for (const key in router) {
+  for (const key of Object.keys(router)) {
     const item = router[key];
     const { default: unlaziedRouter } = await unlazy(item);
     unlazied[key] = await unlazyRouter(unlaziedRouter);

package/dist/shared/server.BllfVJLm.d.mts

@@ -0,0 +1,34 @@
+import { C as Context } from './server.BEdOJs6S.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.CVO0hWyj.mjs';
+
+interface RequestLimitHandlerPluginOptions {
+    /**
+     * The maximum allowed request body size in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * Rejects requests whose body exceeds `maxBodySize`.
+ *
+ * When used with the request compression plugin, the limit applies to the
+ * decompressed payload rather than the compressed wire size.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
+ */
+declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should limit the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    /**
+     * Should limit the final body size instead of the compressed one.
+     */
+    before: string[];
+    private readonly maxBodySize;
+    constructor(options: RequestLimitHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+export { RequestLimitHandlerPlugin as R };
+export type { RequestLimitHandlerPluginOptions as a };

package/dist/shared/server.COfbQ0D8.d.ts

@@ -0,0 +1,34 @@
+import { C as Context } from './server.BEdOJs6S.js';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.DJNkZPfD.js';
+
+interface RequestLimitHandlerPluginOptions {
+    /**
+     * The maximum allowed request body size in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * Rejects requests whose body exceeds `maxBodySize`.
+ *
+ * When used with the request compression plugin, the limit applies to the
+ * decompressed payload rather than the compressed wire size.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
+ */
+declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should limit the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    /**
+     * Should limit the final body size instead of the compressed one.
+     */
+    before: string[];
+    private readonly maxBodySize;
+    constructor(options: RequestLimitHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+export { RequestLimitHandlerPlugin as R };
+export type { RequestLimitHandlerPluginOptions as a };

package/dist/shared/{server.DBANIheG.d.ts → server.CVO0hWyj.d.mts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.js';
+import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BEdOJs6S.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -36,6 +36,17 @@ declare class CompositeStandardHandlerPlugin<T extends Context> implements Stand
 
 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.
+ */
+interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
     context: T;
 }
 type StandardHandlerHandleResult = {
@@ -45,11 +56,11 @@ type StandardHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
@@ -73,7 +84,7 @@ interface StandardHandlerOptions<TContext extends Context> {
      * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
      * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
      */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap, any>[];
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[];
     plugins?: StandardHandlerPlugin<TContext>[];
 }
 declare class StandardHandler<T extends Context> {
@@ -82,9 +93,9 @@ declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
-declare class OtelHandlerPlugin implements StandardHandlerPlugin<any> {
+declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
     name: string;
     init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
 }
@@ -95,10 +106,10 @@ interface StandardHandlerCodecResolvedProcedure {
     decodeInput: () => Promise<unknown>;
 }
 interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    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>;
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };