@orpc/server 2.0.0-beta.34 → 2.0.0-beta.36

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

@@ -1,16 +1,11 @@
-import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { Context } from '../../index.js';
-import { StandardHandlerHandleOptions, StandardHandler } from '../standard/index.js';
+import { StandardHandler } from '../standard/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
+import '@orpc/shared';
 
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
 
 export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };

package/dist/adapters/standard-peer/index.mjs

@@ -1,2 +1,10 @@
-export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import '@orpc/shared';
+import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+
+function createStandardPeerRequestHandler(handler, options) {
+  return async (request) => {
+    const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createStandardPeerRequestHandler };

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

@@ -2,7 +2,7 @@ import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.mjs';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @param ws The WebSocket instance. Use the same instance for all messages.
      * @param data The received message. Binary data should already be loaded (not a `Blob`).
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

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

@@ -2,7 +2,7 @@ import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.js';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @param ws The WebSocket instance. Use the same instance for all messages.
      * @param data The received message. Binary data should already be loaded (not a `Blob`).
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

package/dist/adapters/websocket/index.mjs

@@ -1,12 +1,13 @@
 import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.ozO1TILY.mjs';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@standard-server/core';
-import '../../shared/server.CDOFCg6A.mjs';
+import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.gXC5UaAH.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class WebSocketHandler {
   constructor(handler, options = {}) {

package/dist/extensions/callable.mjs

@@ -1,5 +1,5 @@
-import { c as createProcedureClient } from '../shared/server.CDOFCg6A.mjs';
-import { D as DecoratedProcedure } from '../shared/server.BNfuzVqH.mjs';
+import { c as createProcedureClient } from '../shared/server.Djb_ebJT.mjs';
+import { D as DecoratedProcedure } from '../shared/server.24nXyhbl.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/shared';

package/dist/index.mjs

@@ -2,11 +2,11 @@ import { mergeErrorMap, resolveMetaPlugins, getHiddenMetaPlugins, ProcedureContr
 export { ValidationError, asyncIteratorObject, defineMeta, error, eventIterator, reconcileORPCError, type } from '@orpc/contract';
 import { toArray, bindMethods, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
 export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
-import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.CDOFCg6A.mjs';
-export { u as unlazy } from './shared/server.CDOFCg6A.mjs';
-import { D as DecoratedProcedure } from './shared/server.BNfuzVqH.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.gXC5UaAH.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.gXC5UaAH.mjs';
+import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.Djb_ebJT.mjs';
+export { u as unlazy } from './shared/server.Djb_ebJT.mjs';
+import { D as DecoratedProcedure } from './shared/server.24nXyhbl.mjs';
+import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BynNaBBA.mjs';
+export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BynNaBBA.mjs';
 import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
 export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, safe, toORPCError } from '@orpc/client';
 export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
@@ -388,13 +388,11 @@ function createRouterImplementerInternal(contract, config, middlewares) {
     });
   }
   const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
+  for (const [key, child] of Object.entries(contract)) {
     implementer[key] = createRouterImplementerInternal(child, config, middlewares);
   }
   const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
+  for (const [key, method] of Object.entries(shared)) {
     if (key in implementer) {
       const child = implementer[key];
       implementer[key] = new Proxy(method, {

package/dist/plugins/index.d.mts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.mjs';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.mjs';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.CGQ3M7fX.mjs';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.C7xllBNN.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 
@@ -76,7 +76,7 @@ interface BatchHandlerPluginOptions<T extends Context> {
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     name: string;
     /**
-     * Run batch interceptors before OpenTelemetry interceptors
+     * Run batch interceptors inside the tracing interceptors
      * so each subrequest gets its own span instead of sharing one batch-level span.
      */
     after: string[];

package/dist/plugins/index.d.ts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.js';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.js';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.C-hqoApz.js';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.D0dr-F8u.js';
 import '@orpc/client';
 import '@orpc/contract';
 
@@ -76,7 +76,7 @@ interface BatchHandlerPluginOptions<T extends Context> {
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     name: string;
     /**
-     * Run batch interceptors before OpenTelemetry interceptors
+     * Run batch interceptors inside the tracing interceptors
      * so each subrequest gets its own span instead of sharing one batch-level span.
      */
     after: string[];

package/dist/plugins/index.mjs

@@ -9,10 +9,10 @@ const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
 class BatchHandlerPlugin {
   name = "~batch";
   /**
-   * Run batch interceptors before OpenTelemetry interceptors
+   * Run batch interceptors inside the tracing interceptors
    * so each subrequest gets its own span instead of sharing one batch-level span.
    */
-  after = ["~opentelemetry"];
+  after = ["~tracing"];
   maxSize;
   mapSubrequest;
   successStatus;
@@ -217,7 +217,7 @@ class CORSHandlerPlugin {
    * - Run CORS interceptors before batch interceptors so headers are applied to
    *  the actual response rather than sub-responses.
    */
-  after = ["~opentelemetry", "~batch"];
+  after = ["~tracing", "~batch"];
   constructor(options = {}) {
     const defaults = {
       origin: "*",

package/dist/shared/{server.BNfuzVqH.mjs → server.24nXyhbl.mjs}

@@ -1,5 +1,5 @@
 import { resolveMetaPlugins, mergeErrorMap, getHiddenMetaPlugins } from '@orpc/contract';
-import { P as Procedure } from './server.CDOFCg6A.mjs';
+import { P as Procedure } from './server.Djb_ebJT.mjs';
 
 class DecoratedProcedure extends Procedure {
   meta(...plugins) {

package/dist/shared/{server.BrURRtO7.d.mts → server.B5K1CViq.d.mts}

@@ -1,5 +1,5 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+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.BsujoJoF.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
@@ -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>>;
@@ -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 b };
-export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure 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 };

package/dist/shared/{server.gXC5UaAH.mjs → server.BynNaBBA.mjs}

@@ -1,4 +1,4 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CDOFCg6A.mjs';
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.Djb_ebJT.mjs';
 import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
 import { omit, isTypescriptObject } from '@orpc/shared';
 
@@ -93,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;
 }
@@ -125,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;
 }
@@ -177,8 +177,7 @@ function walkProcedureContractsSyncInternal(router, callback, path, lazyResults)
   if (!isTypescriptObject(router)) {
     return;
   }
-  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.slice() });
@@ -200,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]);
@@ -218,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.CGQ3M7fX.d.mts → server.C7xllBNN.d.mts}

@@ -1,5 +1,5 @@
 import { C as Context } from './server.BsujoJoF.mjs';
-import { S as StandardHandlerPlugin, a as StandardHandlerOptions } from './server.BrURRtO7.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.B5K1CViq.mjs';
 
 interface RequestLimitHandlerPluginOptions {
     /**

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

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BsujoJoF.mjs';
+import { a as StandardHandlerHandleOptions } from './server.B5K1CViq.mjs';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/dist/shared/{server.D23TTT5i.d.ts → server.Cxranw-8.d.ts}

@@ -1,5 +1,5 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+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.BsujoJoF.js';
 import { Schema, ErrorMap } from '@orpc/contract';
@@ -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>>;
@@ -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 b };
-export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure 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 };

package/dist/shared/{server.C-hqoApz.d.ts → server.D0dr-F8u.d.ts}

@@ -1,5 +1,5 @@
 import { C as Context } from './server.BsujoJoF.js';
-import { S as StandardHandlerPlugin, a as StandardHandlerOptions } from './server.D23TTT5i.js';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.Cxranw-8.js';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/{server.CDOFCg6A.mjs → server.Djb_ebJT.mjs}

@@ -1,6 +1,6 @@
 import { wrapAsyncIteratorPreservingEventMeta, ORPCError } from '@orpc/client';
 import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
-import { getConstructor, isTypescriptObject, resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, isPlainObject, mergeTwoLevels } from '@orpc/shared';
+import { getConstructor, isTypescriptObject, resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, getTracer, traceAsyncIterator, traceReadableStream, isPlainObject, mergeTwoLevels } from '@orpc/shared';
 
 class Lazy {
   "~orpc";
@@ -59,11 +59,10 @@ function createProcedureClient(lazyableProcedure, ...rest) {
       });
       if (isAsyncIteratorObject(output)) {
         return override(output, wrapAsyncIteratorPreservingEventMeta(
-          traceAsyncIterator("consume_async_iterator_object_output", output),
+          getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output,
           { mapError: reconcileError }
         ));
-      }
-      if (output instanceof ReadableStream) {
+      } else if (getTracer() && output instanceof ReadableStream) {
         return override(output, traceReadableStream("consume_octet_stream_output", output));
       }
       return output;

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

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BsujoJoF.js';
+import { a as StandardHandlerHandleOptions } from './server.Cxranw-8.js';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };