@orpc/server 1.14.9 → 1.14.11

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

@@ -1,99 +1,91 @@
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-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.yoEB3Fx4.js';
+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 '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
 interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+    /**
+     * Initializes the plugin and returns new node HTTP handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform node HTTP handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initNodeHttpHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
 }
-declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<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>;
 }
 
-type NodeHttpHandleResult = {
+type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
     request: NodeHttpRequest;
     response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions;
-}
-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 adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
 }
-
-interface BodyLimitPluginOptions {
+type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
+interface NodeHttpHandlerOptions<T extends Context> {
     /**
-     * The maximum size of the body in bytes.
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
      */
-    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 {
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
     /**
-     * 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.
+     * Interceptors that run before the mapping between the Standard API and Node HTTP API,
+     * useful for extending Node HTTP request/response before handling, ...
      */
-    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
+    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
-/**
- * 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;
+declare class NodeHttpHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly nodeHttpInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
-     * Enables or disables the StrictGetMethodPlugin.
-     *
-     * @default true
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
      */
-    strictGetMethodPluginEnabled?: boolean;
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: 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<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,125 +1,44 @@
-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.ZxHCEN1h.mjs';
-import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
-import '@orpc/client/standard';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+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 '@orpc/contract';
+import '../../shared/server.BoiFpNT7.mjs';
 
-class BodyLimitPlugin {
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
+class CompositeNodeHttpHandlerPlugin {
+  name = "~composite/node-http-handler";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
   }
-  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) {
+  initNodeHttpHandlerOptions(options) {
     for (const plugin of this.plugins) {
-      plugin.initRuntimeAdapter?.(options);
+      if (plugin.initNodeHttpHandlerOptions) {
+        options = plugin.initNodeHttpHandlerOptions(options);
+      }
     }
+    return options;
   }
 }
 
 class NodeHttpHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
-    plugin.initRuntimeAdapter(options);
-    this.adapterInterceptors = toArray(options.adapterInterceptors);
-    this.sendStandardResponseOptions = options;
+    options = new CompositeNodeHttpHandlerPlugin(options.plugins).initNodeHttpHandlerOptions(options);
+    this.nodeHttpInterceptors = options.nodeHttpInterceptors;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
   }
   sendStandardResponseOptions;
-  adapterInterceptors;
+  nodeHttpInterceptors;
   async handle(request, response, ...rest) {
     return intercept(
-      this.adapterInterceptors,
+      this.nodeHttpInterceptors,
       {
-        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
         request,
         response,
         sendStandardResponseOptions: this.sendStandardResponseOptions
@@ -128,10 +47,10 @@ class NodeHttpHandler {
         const standardRequest = toStandardLazyRequest(request2, response2);
         const result = await this.standardHandler.handle(standardRequest, options);
         if (!result.matched) {
-          return { matched: false };
+          return result;
         }
         await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
-        return { matched: true };
+        return result;
       }
     );
   }
@@ -139,12 +58,16 @@ class NodeHttpHandler {
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
-    if (options.strictGetMethodPluginEnabled ?? true) {
-      options.plugins ??= [];
-      options.plugins.push(new StrictGetMethodPlugin());
+    if (options.csrfGuardPlugin?.enabled !== false) {
+      options = {
+        ...options,
+        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
+      };
     }
-    super(new StandardRPCHandler(router, options), options);
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };

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

@@ -1,21 +1,19 @@
-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.ChUyt5-i.mjs';
-export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/contract';
+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 '../../shared/server.C8_sRzQB.mjs';
+import '@orpc/contract';
+import '../../shared/server.15O7oC1p.mjs';
 
-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;
-}
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
 
-export { StandardCodec, StandardParams, StandardRPCCodec };
+export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
+export type { FriendlyStandardHandlerHandleOptions };

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

@@ -1,21 +1,19 @@
-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.yoEB3Fx4.js';
-export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/contract';
+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 '../../shared/server.ChyoA9XY.js';
+import '@orpc/contract';
+import '../../shared/server.m3szVJGU.js';
 
-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;
-}
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
 
-export { StandardCodec, StandardParams, StandardRPCCodec };
+export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
+export type { FriendlyStandardHandlerHandleOptions };

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,8 @@
-export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardRPCCodec, b as StandardRPCHandler, c as StandardRPCMatcher } from '../../shared/server.ZxHCEN1h.mjs';
-export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import '@orpc/client/standard';
+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';
 import '@orpc/client';
 import '@orpc/shared';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import '@standardserver/core';
+import '../../shared/server.DofEOwf-.mjs';
 import '@orpc/contract';
+import '../../shared/server.BoiFpNT7.mjs';

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

@@ -1,18 +1,16 @@
-import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
-import { C as Context } from '../../shared/server.qKsRrdxW.mjs';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DDFizwfU.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/shared';
-import '@orpc/standard-server';
 
-type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
-/**
- * @deprecated Use `createServerPeerRequestHandleFn` instead.
- */
-declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
-declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+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>;
 
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
-export type { HandleStandardServerPeerMessageOptions };
+export { createStandardPeerRequestHandler };
+export type { StandardPeerRequestHandlerOptions };

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

@@ -1,18 +1,16 @@
-import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
-import { C as Context } from '../../shared/server.qKsRrdxW.js';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context } from '../../shared/server.CcR4kgje.js';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.BhsVw7m7.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/shared';
-import '@orpc/standard-server';
 
-type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
-/**
- * @deprecated Use `createServerPeerRequestHandleFn` instead.
- */
-declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
-declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+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>;
 
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
-export type { HandleStandardServerPeerMessageOptions };
+export { createStandardPeerRequestHandler };
+export type { StandardPeerRequestHandlerOptions };

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

@@ -1,21 +1,2 @@
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-
-async function handleStandardServerPeerMessage(handler, peer, message, options) {
-  const [id, request] = await peer.message(message);
-  if (!request) {
-    return;
-  }
-  const handle = createServerPeerHandleRequestFn(handler, options);
-  await peer.response(id, await handle(request));
-}
-function createServerPeerHandleRequestFn(handler, options) {
-  return async (request) => {
-    const { response } = await handler.handle(
-      { ...request, body: () => Promise.resolve(request.body) },
-      resolveFriendlyStandardHandleOptions(options)
-    );
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
+import '@orpc/shared';