@orpc/server 0.0.0-next.33ca37d → 0.0.0-next.350a165

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
 export { ValidationError, eventIterator, type } from '@orpc/contract';
-import { P as Procedure, d as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, f as isLazy, h as createAssertedLazyProcedure, g as getRouter } from './shared/server.BtxZnWJ9.mjs';
-export { L as LAZY_SYMBOL, q as call, w as createAccessibleLazyRouter, b as createContractedProcedure, j as createORPCErrorConstructorMap, r as getHiddenRouterContract, k as getLazyMeta, o as isStartWithMiddlewares, m as mergeCurrentContext, p as mergeMiddlewares, n as middlewareOutputFn, x as resolveContractProcedures, a as toHttpPath, t as traverseContractProcedures, u as unlazy, y as unlazyRouter, v as validateORPCError } from './shared/server.BtxZnWJ9.mjs';
+import { P as Procedure, b as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, d as isLazy, f as createAssertedLazyProcedure, g as getRouter } from './shared/server.C37gDhSZ.mjs';
+export { L as LAZY_SYMBOL, p as call, r as createAccessibleLazyRouter, a as createContractedProcedure, h as createORPCErrorConstructorMap, q as getHiddenRouterContract, j as getLazyMeta, n as isStartWithMiddlewares, m as mergeCurrentContext, o as mergeMiddlewares, k as middlewareOutputFn, w as resolveContractProcedures, t as traverseContractProcedures, u as unlazy, x as unlazyRouter, v as validateORPCError } from './shared/server.C37gDhSZ.mjs';
+import { toORPCError } from '@orpc/client';
 export { ORPCError, isDefinedError, safe } from '@orpc/client';
 export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { getEventMeta, withEventMeta } from '@orpc/standard-server';
@@ -44,6 +45,17 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
+function createActionableClient(client) {
+  const action = async (input) => {
+    try {
+      return [null, await client(input)];
+    } catch (error) {
+      return [toORPCError(error).toJSON(), void 0];
+    }
+  };
+  return action;
+}
+
 class DecoratedProcedure extends Procedure {
   errors(errors) {
     return new DecoratedProcedure({
@@ -74,7 +86,8 @@ class DecoratedProcedure extends Procedure {
    * Make this procedure callable (works like a function while still being a procedure).
    */
   callable(...rest) {
-    return new Proxy(createProcedureClient(this, ...rest), {
+    const client = createProcedureClient(this, ...rest);
+    return new Proxy(client, {
       get: (target, key) => {
         return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
       },
@@ -84,10 +97,18 @@ class DecoratedProcedure extends Procedure {
     });
   }
   /**
-   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   * Make this procedure compatible with server action.
    */
   actionable(...rest) {
-    return this.callable(...rest);
+    const action = createActionableClient(createProcedureClient(this, ...rest));
+    return new Proxy(action, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
+    });
   }
 }
 
@@ -339,4 +360,4 @@ function createRouterClient(router, ...[options]) {
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, addMiddleware, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -1,31 +1,68 @@
-import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.BeJithK4.mjs';
-export { C as CompositePlugin } from '../shared/server.BeJithK4.mjs';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.BYTulgUc.mjs';
-import '@orpc/contract';
-import '@orpc/standard-server';
+import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
+import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
+import { g as StandardHandlerInterceptorOptions, i as StandardHandlerPlugin, a as StandardHandlerOptions } from '../shared/server.Dm5DEJl5.mjs';
+import { C as Context } from '../shared/server.DLt5njUb.mjs';
 import '@orpc/client';
+import '@orpc/contract';
+
+interface BatchHandlerOptions<T extends Context> {
+    /**
+     * The max size of the batch allowed.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Map the request before processing it.
+     *
+     * @default merged back batch request headers into the request
+     */
+    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
+    /**
+     * Success batch response status code.
+     *
+     * @default 207
+     */
+    successStatus?: Value<number, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * success batch response headers.
+     *
+     * @default {}
+     */
+    headers?: Value<StandardHeaders, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+}
+declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly maxSize;
+    private readonly mapRequestItem;
+    private readonly successStatus;
+    private readonly headers;
+    order: number;
+    constructor(options?: BatchHandlerOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
+}
 
-interface CORSOptions<TContext extends Context> {
-    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+interface CORSOptions<T extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
     allowMethods?: readonly string[];
     allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
     exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly options;
-    constructor(options?: CORSOptions<TContext>);
-    init(options: StandardHandlerOptions<TContext>): void;
+    order: number;
+    constructor(options?: CORSOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
-    init(options: StandardHandlerOptions<TContext>): void;
+declare class ResponseHeadersPlugin<T extends ResponseHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
 }
 
-export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type BatchHandlerOptions, BatchHandlerPlugin, type CORSOptions, CORSPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -1,31 +1,68 @@
-import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.B3Tm0IXY.js';
-export { C as CompositePlugin } from '../shared/server.B3Tm0IXY.js';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.BYTulgUc.js';
-import '@orpc/contract';
-import '@orpc/standard-server';
+import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
+import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
+import { g as StandardHandlerInterceptorOptions, i as StandardHandlerPlugin, a as StandardHandlerOptions } from '../shared/server.DfyOFejj.js';
+import { C as Context } from '../shared/server.DLt5njUb.js';
 import '@orpc/client';
+import '@orpc/contract';
+
+interface BatchHandlerOptions<T extends Context> {
+    /**
+     * The max size of the batch allowed.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Map the request before processing it.
+     *
+     * @default merged back batch request headers into the request
+     */
+    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
+    /**
+     * Success batch response status code.
+     *
+     * @default 207
+     */
+    successStatus?: Value<number, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * success batch response headers.
+     *
+     * @default {}
+     */
+    headers?: Value<StandardHeaders, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+}
+declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly maxSize;
+    private readonly mapRequestItem;
+    private readonly successStatus;
+    private readonly headers;
+    order: number;
+    constructor(options?: BatchHandlerOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
+}
 
-interface CORSOptions<TContext extends Context> {
-    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+interface CORSOptions<T extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
     allowMethods?: readonly string[];
     allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
     exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly options;
-    constructor(options?: CORSOptions<TContext>);
-    init(options: StandardHandlerOptions<TContext>): void;
+    order: number;
+    constructor(options?: CORSOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
-    init(options: StandardHandlerOptions<TContext>): void;
+declare class ResponseHeadersPlugin<T extends ResponseHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
 }
 
-export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type BatchHandlerOptions, BatchHandlerPlugin, type CORSOptions, CORSPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.mjs

@@ -1,8 +1,98 @@
-export { C as CompositePlugin } from '../shared/server.Q6ZmnTgO.mjs';
 import { value } from '@orpc/shared';
+import { parseBatchRequest, toBatchResponse } from '@orpc/standard-server/batch';
+
+class BatchHandlerPlugin {
+  maxSize;
+  mapRequestItem;
+  successStatus;
+  headers;
+  order = 5e6;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 10;
+    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
+      ...request,
+      headers: {
+        ...batchRequest.headers,
+        ...request.headers
+      }
+    }));
+    this.successStatus = options.successStatus ?? 207;
+    this.headers = options.headers ?? {};
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (options2) => {
+      if (options2.request.headers["x-orpc-batch"] !== "1") {
+        return options2.next();
+      }
+      let isParsing = false;
+      try {
+        isParsing = true;
+        const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
+        isParsing = false;
+        const maxSize = await value(this.maxSize, options2);
+        if (parsed.length > maxSize) {
+          return {
+            matched: true,
+            response: {
+              status: 413,
+              headers: {},
+              body: "Batch request size exceeds the maximum allowed size"
+            }
+          };
+        }
+        const responses = parsed.map(
+          (request, index) => {
+            const mapped = this.mapRequestItem(request, options2);
+            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
+              if (matched) {
+                return { ...response2, index };
+              }
+              return { index, status: 404, headers: {}, body: "No procedure matched" };
+            }).catch(() => {
+              return { index, status: 500, headers: {}, body: "Internal server error" };
+            });
+          }
+        );
+        await Promise.race(responses);
+        const status = await value(this.successStatus, responses, options2);
+        const headers = await value(this.headers, responses, options2);
+        const response = toBatchResponse({
+          status,
+          headers,
+          body: async function* () {
+            const promises = [...responses];
+            while (true) {
+              const handling = promises.filter((p) => p !== void 0);
+              if (handling.length === 0) {
+                return;
+              }
+              const result = await Promise.race(handling);
+              promises[result.index] = void 0;
+              yield result;
+            }
+          }()
+        });
+        return {
+          matched: true,
+          response
+        };
+      } catch (cause) {
+        if (isParsing) {
+          return {
+            matched: true,
+            response: { status: 400, headers: {}, body: "Invalid batch request, this could be caused by a malformed request body or a missing header" }
+          };
+        }
+        throw cause;
+      }
+    });
+  }
+}
 
 class CORSPlugin {
   options;
+  order = 9e6;
   constructor(options = {}) {
     const defaults = {
       origin: (origin) => origin,
@@ -79,14 +169,19 @@ class ResponseHeadersPlugin {
   init(options) {
     options.rootInterceptors ??= [];
     options.rootInterceptors.push(async (interceptorOptions) => {
-      const headers = new Headers();
-      interceptorOptions.context.resHeaders = headers;
-      const result = await interceptorOptions.next();
+      const resHeaders = interceptorOptions.context.resHeaders ?? new Headers();
+      const result = await interceptorOptions.next({
+        ...interceptorOptions,
+        context: {
+          ...interceptorOptions.context,
+          resHeaders
+        }
+      });
       if (!result.matched) {
         return result;
       }
       const responseHeaders = result.response.headers;
-      for (const [key, value] of headers) {
+      for (const [key, value] of resHeaders) {
         if (Array.isArray(responseHeaders[key])) {
           responseHeaders[key].push(value);
         } else if (responseHeaders[key] !== void 0) {
@@ -100,4 +195,4 @@ class ResponseHeadersPlugin {
   }
 }
 
-export { CORSPlugin, ResponseHeadersPlugin };
+export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin };

package/dist/shared/server.BVwwTHyO.mjs

@@ -0,0 +1,9 @@
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options?.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+
+export { resolveFriendlyStandardHandleOptions as r };

package/dist/shared/{server.BtxZnWJ9.mjs → server.C37gDhSZ.mjs}

@@ -1,6 +1,6 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept, toError } from '@orpc/shared';
+import { value, intercept } from '@orpc/shared';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -127,7 +127,7 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
       );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
-        throw toError(e);
+        throw e;
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
       throw validated;
@@ -169,35 +169,29 @@ async function executeProcedureInternal(procedure, options) {
   const middlewares = procedure["~orpc"].middlewares;
   const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
   const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
-  let currentIndex = 0;
-  let currentContext = options.context;
-  let currentInput = options.input;
-  const next = async (...[nextOptions]) => {
-    const index = currentIndex;
-    const midContext = nextOptions?.context ?? {};
-    currentIndex += 1;
-    currentContext = mergeCurrentContext(currentContext, midContext);
+  const next = async (index, context, input) => {
+    let currentInput = input;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const result = mid ? {
-      context: midContext,
-      output: (await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn)).output
-    } : {
-      context: midContext,
-      output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput })
-    };
+    const output = mid ? (await mid({
+      ...options,
+      context,
+      next: async (...[nextOptions]) => {
+        const nextContext = nextOptions?.context ?? {};
+        return {
+          output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+          context: nextContext
+        };
+      }
+    }, currentInput, middlewareOutputFn)).output : await procedure["~orpc"].handler({ ...options, context, input: currentInput });
     if (index === outputValidationIndex) {
-      const validatedOutput = await validateOutput(procedure, result.output);
-      return {
-        context: result.context,
-        output: validatedOutput
-      };
+      return await validateOutput(procedure, output);
     }
-    return result;
+    return output;
   };
-  return (await next()).output;
+  return next(0, options.context, options.input);
 }
 
 const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
@@ -367,8 +361,4 @@ function call(procedure, input, ...rest) {
   return createProcedureClient(procedure, ...rest)(input);
 }
 
-function toHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
-}
-
-export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, createORPCErrorConstructorMap as j, getLazyMeta as k, lazy as l, mergeCurrentContext as m, middlewareOutputFn as n, isStartWithMiddlewares as o, mergeMiddlewares as p, call as q, getHiddenRouterContract as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, createAccessibleLazyRouter as w, resolveContractProcedures as x, unlazyRouter as y };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

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

@@ -0,0 +1,10 @@
+import { C as Context } from './server.DLt5njUb.mjs';
+import { S as StandardHandleOptions } from './server.Dm5DEJl5.mjs';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/{server.jG7ZuX3S.mjs → server.C78d5yfh.mjs}

@@ -1,51 +1,66 @@
 import { ORPCError, toORPCError } from '@orpc/client';
-import { intercept, trim, parseEmptyableJSON } from '@orpc/shared';
-import { C as CompositePlugin } from './server.Q6ZmnTgO.mjs';
-import { c as createProcedureClient, t as traverseContractProcedures, a as toHttpPath, i as isProcedure, u as unlazy, g as getRouter, b as createContractedProcedure } from './server.BtxZnWJ9.mjs';
+import { toArray, intercept, parseEmptyableJSON } from '@orpc/shared';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.C37gDhSZ.mjs';
+import { toHttpPath } from '@orpc/client/standard';
+
+class CompositeStandardHandlerPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
 
 class StandardHandler {
   constructor(router, matcher, codec, options) {
     this.matcher = matcher;
     this.codec = codec;
-    this.options = options;
-    this.plugin = new CompositePlugin(options.plugins);
-    this.plugin.init(this.options);
+    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
+    plugins.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+    this.rootInterceptors = toArray(options.rootInterceptors);
     this.matcher.init(router);
   }
-  plugin;
-  handle(request, ...[options]) {
+  interceptors;
+  clientInterceptors;
+  rootInterceptors;
+  async handle(request, options) {
+    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
+    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
+      return { matched: false, response: void 0 };
+    }
     return intercept(
-      this.options.rootInterceptors ?? [],
-      {
-        request,
-        ...options,
-        context: options?.context ?? {}
-        // context is optional only when all fields are optional so we can safely force it to have a context
-      },
+      this.rootInterceptors,
+      { ...options, request, prefix },
       async (interceptorOptions) => {
         let isDecoding = false;
         try {
           return await intercept(
-            this.options.interceptors ?? [],
+            this.interceptors,
             interceptorOptions,
-            async (interceptorOptions2) => {
-              const method = interceptorOptions2.request.method;
-              const url = interceptorOptions2.request.url;
-              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
-              const match = await this.matcher.match(method, pathname);
+            async ({ request: request2, context, prefix: prefix2 }) => {
+              const method = request2.method;
+              const url = request2.url;
+              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+              const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
               if (!match) {
                 return { matched: false, response: void 0 };
               }
               const client = createProcedureClient(match.procedure, {
-                context: interceptorOptions2.context,
+                context,
                 path: match.path,
-                interceptors: this.options.clientInterceptors
+                interceptors: this.clientInterceptors
               });
               isDecoding = true;
-              const input = await this.codec.decode(request, match.params, match.procedure);
+              const input = await this.codec.decode(request2, match.params, match.procedure);
               isDecoding = false;
-              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
-              const output = await client(input, { signal: request.signal, lastEventId });
+              const lastEventId = Array.isArray(request2.headers["last-event-id"]) ? request2.headers["last-event-id"].at(-1) : request2.headers["last-event-id"];
+              const output = await client(input, { signal: request2.signal, lastEventId });
               const response = this.codec.encode(output, match.procedure);
               return {
                 matched: true,
@@ -54,7 +69,7 @@ class StandardHandler {
             }
           );
         } catch (e) {
-          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
+          const error = isDecoding && !(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);
@@ -155,4 +170,4 @@ class StandardRPCMatcher {
   }
 }
 
-export { StandardHandler as S, StandardRPCCodec as a, StandardRPCMatcher as b };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardRPCCodec as a, StandardRPCMatcher as b };