@orpc/server 2.0.0-beta.47 → 2.0.0-beta.49

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

@@ -1,47 +1,7 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CgBF3Vj1.js';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standard-server/fetch';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type FetchHandlerHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface FetchHandlerOptions<_T extends Context> {
-    /**
-     * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
-     */
-    toFetchResponse?: ToFetchResponseOptions | undefined;
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+export { 
 /**
- * Serves an oRPC router over the RPC protocol using the Fetch API
- * (Request/Response), supported by modern runtimes like Deno, Bun,
- * Cloudflare Workers, and browsers.
- *
- * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
  */
-declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { FetchHandler, RPCHandler };
-export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.ts';
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/fetch/index.js

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.js';
+export * from './handler.js';
+export * from './rpc-handler.js';

package/dist/adapters/fetch/rpc-handler.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { FetchHandlerOptions } from './handler.ts';
+import { FetchHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using the Fetch API
+ * (Request/Response), supported by modern runtimes like Deno, Bun,
+ * Cloudflare Workers, and browsers.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/fetch/rpc-handler.js

@@ -0,0 +1,16 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { FetchHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol using the Fetch API
+ * (Request/Response), supported by modern runtimes like Deno, Bun,
+ * Cloudflare Workers, and browsers.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ */
+export class RPCHandler extends FetchHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

package/dist/adapters/message-port/{index.d.mts → handler.d.ts}

@@ -1,17 +1,11 @@
-import { SupportedMessagePort } from '@orpc/client/message-port';
-import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
-import { Context } from '../../index.mjs';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import { Router } from '../../index.mjs';
-import { RPCHandlerCodecOptions } from '../standard/index.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
+import type { SupportedMessagePort } from '@orpc/client/message-port';
+import type { MaybeOptionalOptions, Promisable, Value } from '@orpc/shared';
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
+import { ServerPeer } from '@standard-server/peer';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
 type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
-interface MessagePortHandlerOptions<_T extends Context> {
+export interface MessagePortHandlerOptions<_T extends Context> {
     /**
      * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
      * Use this option to bypass encoding and leverage the full capabilities of the
@@ -22,7 +16,10 @@ interface MessagePortHandlerOptions<_T extends Context> {
      * **Note**: Returning `null` or `undefined` disables this feature.
      * **Warning**: Ensure your message port implementation supports `transferable` objects before enabling this.
      */
-    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]> | undefined;
+    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [
+        message: DecodedResponseMessage,
+        port: SupportedMessagePort
+    ]> | undefined;
     /**
      * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
      */
@@ -32,8 +29,11 @@ interface MessagePortHandlerOptions<_T extends Context> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class MessagePortHandler<T extends Context> {
+export declare class MessagePortHandler<T extends Context> {
     private readonly handler;
+    /**
+     * `null` marks a closed port, so late messages never create a new peer.
+     */
     private readonly peers;
     private readonly transfer;
     private readonly encodePeerMessageOptions;
@@ -55,23 +55,10 @@ declare class MessagePortHandler<T extends Context> {
     }>;
     /**
      * Cleans up peer state for a closed message port.
+     * Messages passed to `.message()` for this port afterwards are ignored.
      *
      * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol on a message port,
- * such as browser extensions, Electron, or worker threads.
- *
- * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
- */
-declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { MessagePortHandler, RPCHandler };
-export type { MessagePortHandlerOptions, RPCHandlerOptions };
+export {};

package/dist/adapters/message-port/handler.js

@@ -0,0 +1,86 @@
+import { onMessagePortClose, onMessagePortMessage, postMessagePortMessage, } from '@orpc/client/message-port';
+import { resolveMaybeOptionalOptions, value } from '@orpc/shared';
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerMessage, ServerPeer, } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
+export class MessagePortHandler {
+    handler;
+    /**
+     * `null` marks a closed port, so late messages never create a new peer.
+     */
+    peers = new WeakMap();
+    transfer;
+    encodePeerMessageOptions;
+    decodePeerMessageOptions;
+    constructor(handler, options = {}) {
+        this.handler = handler;
+        this.transfer = options.experimental_transfer;
+        this.encodePeerMessageOptions = options.encodePeerMessage;
+        this.decodePeerMessageOptions = options.decodePeerMessage;
+    }
+    /**
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
+     */
+    upgrade(port, ...rest) {
+        /**
+         * Message order is important: loading -> decode -> .message.
+         * This flow must stay synchronous, or we need to use `sequential` helper
+         */
+        onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
+        onMessagePortClose(port, () => this.close(port));
+    }
+    /**
+     * Handles a single message received from a message port.
+     *
+     * @param port The message port instance. Use the same instance for all messages.
+     */
+    async message(port, data, ...rest) {
+        let peerMessage;
+        if (typeof data === 'string' || data instanceof Uint8Array) {
+            // MessagePort receives the exact payload sent, and `encodePeerMessage` only returns string or Uint8Array.
+            const result = decodePeerMessage(data, this.decodePeerMessageOptions);
+            if (result.matched && isClientPeerSendMessage(result.message)) {
+                peerMessage = result.message;
+            }
+        }
+        else if (isPeerMessage(data) && isClientPeerSendMessage(data)) {
+            peerMessage = data;
+        }
+        if (peerMessage === undefined) {
+            return { matched: false };
+        }
+        let peer = this.peers.get(port);
+        if (peer === null) {
+            return { matched: true };
+        }
+        if (!peer) {
+            this.peers.set(port, (peer = new ServerPeer(async (message) => {
+                const transfer = await value(this.transfer, message, port);
+                if (transfer) {
+                    postMessagePortMessage(port, message, transfer);
+                }
+                else {
+                    postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
+                }
+            })));
+        }
+        /**
+         * Message order is important: loading -> decode -> .message.
+         * This flow must stay synchronous, or we need to use `sequential` helper
+         */
+        await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+        return { matched: true };
+    }
+    /**
+     * Cleans up peer state for a closed message port.
+     * Messages passed to `.message()` for this port afterwards are ignored.
+     *
+     * @param port The same message port instance passed to `.message()`.
+     */
+    async close(port) {
+        const peer = this.peers.get(port);
+        this.peers.set(port, null);
+        await peer?.close();
+    }
+}

package/dist/adapters/message-port/index.d.ts

@@ -1,77 +1,2 @@
-import { SupportedMessagePort } from '@orpc/client/message-port';
-import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
-interface MessagePortHandlerOptions<_T extends Context> {
-    /**
-     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
-     * Use this option to bypass encoding and leverage the full capabilities of the
-     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
-     *
-     * @remarks
-     * **Note**: Returning `null` or `undefined` disables this feature.
-     * **Warning**: Ensure your message port implementation supports `transferable` objects before enabling this.
-     */
-    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]> | undefined;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class MessagePortHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly transfer;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    /**
-     * Attaches message and close listeners to a message port.
-     *
-     * Prefer this over calling `.message()` and `.close()` manually.
-     */
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
-    /**
-     * Handles a single message received from a message port.
-     *
-     * @param port The message port instance. Use the same instance for all messages.
-     */
-    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed message port.
-     *
-     * @param port The same message port instance passed to `.message()`.
-     */
-    close(port: SupportedMessagePort): Promise<void>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol on a message port,
- * such as browser extensions, Electron, or worker threads.
- *
- * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
- */
-declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { MessagePortHandler, RPCHandler };
-export type { MessagePortHandlerOptions, RPCHandlerOptions };
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/message-port/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';

package/dist/adapters/message-port/rpc-handler.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { MessagePortHandlerOptions } from './handler.ts';
+import { MessagePortHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/message-port/rpc-handler.js

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { MessagePortHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
+export class RPCHandler extends MessagePortHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions } from '@standard-server/node';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+export type NodeHttpHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+export interface NodeHttpHandlerOptions<_T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+export declare class NodeHttpHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
+}

package/dist/adapters/node/handler.js

@@ -0,0 +1,20 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/node';
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+export class NodeHttpHandler {
+    standardHandler;
+    sendStandardResponseOptions;
+    constructor(standardHandler, options = {}) {
+        this.standardHandler = standardHandler;
+        this.sendStandardResponseOptions = options.sendStandardResponse;
+    }
+    async handle(request, response, ...rest) {
+        const standardRequest = toStandardLazyRequest(request, response);
+        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+        if (!result.matched) {
+            return result;
+        }
+        await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+        return result;
+    }
+}

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

@@ -1,44 +1,7 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CgBF3Vj1.js';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type NodeHttpHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface NodeHttpHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-declare class NodeHttpHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    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>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+export { 
 /**
- * Serves an oRPC router over the RPC protocol using Node.js built-in
- * HTTP request/response objects.
- *
- * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
  */
-declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.ts';
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/node/index.js

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.js';
+export * from './handler.js';
+export * from './rpc-handler.js';

package/dist/adapters/node/rpc-handler.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { NodeHttpHandlerOptions } from './handler.ts';
+import { NodeHttpHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/node/rpc-handler.js

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { NodeHttpHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
+export class RPCHandler extends NodeHttpHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { AnyORPCError } from '@orpc/client';
+import type { Promisable } from '@orpc/shared';
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { AnyProcedure } from '../../procedure.ts';
+import type { ResolvedStandardHandlerHandleOptions } from './handler.ts';
+export interface StandardHandlerCodecResolvedProcedure {
+    path: string[];
+    procedure: AnyProcedure;
+    decodeInput: () => Promise<unknown>;
+}
+export interface StandardHandlerCodec<T extends Context> {
+    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>;
+}

package/dist/adapters/standard/codec.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,68 @@
+import type { ErrorMap, Schema } from '@orpc/contract';
+import type { Interceptor, Promisable, Value } from '@orpc/shared';
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { ProcedureClientInterceptor } from '../../procedure-client.ts';
+import type { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from './codec.ts';
+import type { StandardHandlerPlugin } from './plugin.ts';
+export 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.
+ */
+export interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
+    context: T;
+}
+export type StandardHandlerHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response?: undefined;
+};
+export interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+export type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
+export interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+export type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
+export interface StandardHandlerOptions<TContext extends Context> {
+    /**
+     * Fired on every request before routing, useful when you want
+     * to intercept all requests regardless of whether they match a procedure or not.
+     *
+     * @examples
+     * - batch plugins - separate one request into multiple and call multiple next
+     * - openapi spec plugin - to intercept a request and early response
+     */
+    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
+    /**
+     * interceptor run after routing and before error handler,
+     * useful for error handling, logging, metrics, etc.
+     */
+    interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
+    /**
+     *
+     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
+     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
+     */
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
+    plugins?: StandardHandlerPlugin<TContext>[] | undefined;
+}
+export declare class StandardHandler<T extends Context> {
+    private readonly codec;
+    private readonly routingInterceptors;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+}