@orpc/server 1.14.11 → 1.14.12

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

@@ -1,91 +1,99 @@
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.CcR4kgje.mjs';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import { R as Router } from '../../shared/server.15O7oC1p.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.mjs';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import compression from '@orpc/interop/compression';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DzE6WeuY.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.C8_sRzQB.mjs';
 
 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>;
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
 }
-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>;
+declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
 }
 
-type NodeHttpHandlerHandleResult = {
+type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: NodeHttpRequest;
     response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+    sendStandardResponseOptions: SendStandardResponseOptions;
 }
-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;
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
+    private readonly adapterInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface BodyLimitPluginOptions {
     /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface CompressionPluginOptions extends compression.CompressionOptions {
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.dev/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly compressionHandler;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
      */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
+    strictGetMethodPluginEnabled?: boolean;
 }
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -1,91 +1,99 @@
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { R as Router } from '../../shared/server.m3szVJGU.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import compression from '@orpc/interop/compression';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D8IXzfqT.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.ChyoA9XY.js';
 
 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>;
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
 }
-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>;
+declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
 }
 
-type NodeHttpHandlerHandleResult = {
+type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: NodeHttpRequest;
     response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+    sendStandardResponseOptions: SendStandardResponseOptions;
 }
-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;
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
+    private readonly adapterInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface BodyLimitPluginOptions {
     /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface CompressionPluginOptions extends compression.CompressionOptions {
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.dev/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly compressionHandler;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
      */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
+    strictGetMethodPluginEnabled?: boolean;
 }
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,44 +1,125 @@
-import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
-import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/node';
-import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.COPVXhDG.mjs';
-import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.DofEOwf-.mjs';
+import { ORPCError } from '@orpc/client';
+import { once, toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import compression from '@orpc/interop/compression';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.CMf4nKky.mjs';
+import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
 import '@orpc/contract';
-import '../../shared/server.BoiFpNT7.mjs';
 
-class CompositeNodeHttpHandlerPlugin {
-  name = "~composite/node-http-handler";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
   }
-  initNodeHttpHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initNodeHttpHandlerOptions) {
-        options = plugin.initNodeHttpHandlerOptions(options);
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      const checkHeader = once(() => {
+        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+          throw new ORPCError("PAYLOAD_TOO_LARGE");
+        }
+      });
+      const originalEmit = options2.request.emit;
+      let currentBodySize = 0;
+      options2.request.emit = (event, ...args) => {
+        if (event === "data") {
+          checkHeader();
+          currentBodySize += args[0].length;
+          if (currentBodySize > this.maxBodySize) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+        }
+        return originalEmit.call(options2.request, event, ...args);
+      };
+      try {
+        return await options2.next(options2);
+      } finally {
+        options2.request.emit = originalEmit;
+      }
+    });
+  }
+}
+
+class CompressionPlugin {
+  compressionHandler;
+  constructor(options = {}) {
+    this.compressionHandler = compression({
+      ...options,
+      filter: (req, res) => {
+        const hasContentDisposition = res.hasHeader("content-disposition");
+        const contentType = res.getHeader("content-type")?.toString();
+        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
+          return false;
+        }
+        return options.filter ? options.filter(req, res) : compression.filter(req, res);
       }
+    });
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.unshift(async (options2) => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      const originalWrite = options2.response.write;
+      const originalEnd = options2.response.end;
+      const originalOn = options2.response.on;
+      this.compressionHandler(
+        options2.request,
+        options2.response,
+        async (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            try {
+              resolve(await options2.next());
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      );
+      try {
+        return await promise;
+      } finally {
+        options2.response.write = originalWrite;
+        options2.response.end = originalEnd;
+        options2.response.on = originalOn;
+      }
+    });
+  }
+}
+
+class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
     }
-    return options;
   }
 }
 
 class NodeHttpHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeNodeHttpHandlerPlugin(options.plugins).initNodeHttpHandlerOptions(options);
-    this.nodeHttpInterceptors = options.nodeHttpInterceptors;
-    this.sendStandardResponseOptions = options.sendStandardResponse;
+    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
   }
   sendStandardResponseOptions;
-  nodeHttpInterceptors;
+  adapterInterceptors;
   async handle(request, response, ...rest) {
     return intercept(
-      this.nodeHttpInterceptors,
+      this.adapterInterceptors,
       {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
         request,
         response,
         sendStandardResponseOptions: this.sendStandardResponseOptions
@@ -47,10 +128,10 @@ class NodeHttpHandler {
         const standardRequest = toStandardLazyRequest(request2, response2);
         const result = await this.standardHandler.handle(standardRequest, options);
         if (!result.matched) {
-          return result;
+          return { matched: false };
         }
         await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
-        return result;
+        return { matched: true };
       }
     );
   }
@@ -58,16 +139,12 @@ class NodeHttpHandler {
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
-    if (options.csrfGuardPlugin?.enabled !== false) {
-      options = {
-        ...options,
-        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
-      };
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
     }
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
+    super(new StandardRPCHandler(router, options), options);
   }
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };

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

@@ -1,19 +1,21 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.DDFizwfU.mjs';
-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.DDFizwfU.mjs';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.B4BnEWWm.mjs';
-import { C as Context } from '../../shared/server.CcR4kgje.mjs';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
+import { S as StandardCodec, a as StandardParams } from '../../shared/server.BqadksTP.mjs';
+export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.BqadksTP.mjs';
+import { ORPCError } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure } from '../../shared/server.qKsRrdxW.mjs';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.DzE6WeuY.mjs';
+export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
 import '@orpc/contract';
-import '../../shared/server.15O7oC1p.mjs';
+import '@orpc/shared';
+import '../../shared/server.C8_sRzQB.mjs';
 
-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>;
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
 
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };
+export { StandardCodec, StandardParams, StandardRPCCodec };

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

@@ -1,19 +1,21 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.BhsVw7m7.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.BhsVw7m7.js';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.CnN50DHH.js';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
+import { S as StandardCodec, a as StandardParams } from '../../shared/server.7cEtMB30.js';
+export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.7cEtMB30.js';
+import { ORPCError } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure } from '../../shared/server.qKsRrdxW.js';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.D8IXzfqT.js';
+export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
 import '@orpc/contract';
-import '../../shared/server.m3szVJGU.js';
+import '@orpc/shared';
+import '../../shared/server.ChyoA9XY.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>;
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
 
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };
+export { StandardCodec, StandardParams, StandardRPCCodec };

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,8 @@
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.COPVXhDG.mjs';
-export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardRPCCodec, b as StandardRPCHandler, c as StandardRPCMatcher } from '../../shared/server.CMf4nKky.mjs';
+export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client/standard';
 import '@orpc/client';
 import '@orpc/shared';
-import '@standardserver/core';
-import '../../shared/server.DofEOwf-.mjs';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
 import '@orpc/contract';
-import '../../shared/server.BoiFpNT7.mjs';