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

package/dist/adapters/aws-lambda/handler.d.ts

@@ -1,25 +1,27 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { AnyAPIGatewayProxyEvent, HttpResponseStream, SendStandardResponseOptions } from '@standard-server/aws-lambda';
-import type { Context } from '../../context.ts';
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { AnyAPIGatewayProxyEvent, HttpResponseStream, SendStandardResponseOptions } from "@standard-server/aws-lambda";
 export type AwsLambdaHandlerHandleResult = {
-    matched: true;
+  matched: true;
 } | {
-    matched: false;
+  matched: false;
 };
 export interface AwsLambdaHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
+  /**
+   * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+   */
+  sendStandardResponse?: SendStandardResponseOptions | undefined;
 }
 /**
  * Requires the AWS Lambda Node.js runtime with response streaming enabled,
  * handlers should be wrapped with `awslambda.streamifyResponse`.
  */
 export declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
-    handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
-}
+  private readonly standardHandler;
+  private readonly sendStandardResponseOptions;
+  constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
+  handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
+}

package/dist/adapters/aws-lambda/handler.js

@@ -1,24 +1,24 @@
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/aws-lambda';
-import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/aws-lambda";
+// src/adapters/aws-lambda/handler.ts
 /**
- * Requires the AWS Lambda Node.js runtime with response streaming enabled,
- * handlers should be wrapped with `awslambda.streamifyResponse`.
- */
-export class AwsLambdaHandler {
-    standardHandler;
-    sendStandardResponseOptions;
-    constructor(standardHandler, options = {}) {
-        this.standardHandler = standardHandler;
-        this.sendStandardResponseOptions = options.sendStandardResponse;
-    }
-    async handle(event, responseStream, ...rest) {
-        const standardRequest = toStandardLazyRequest(event, responseStream);
-        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
-        if (!result.matched) {
-            return result;
-        }
-        await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
-        return result;
-    }
-}
+* Requires the AWS Lambda Node.js runtime with response streaming enabled,
+* handlers should be wrapped with `awslambda.streamifyResponse`.
+*/
+var AwsLambdaHandler = class {
+	standardHandler;
+	sendStandardResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.sendStandardResponseOptions = options.sendStandardResponse;
+	}
+	async handle(event, responseStream, ...rest) {
+		const standardRequest = toStandardLazyRequest(event, responseStream);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) return result;
+		await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
+		return result;
+	}
+};
+export { AwsLambdaHandler };

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,16 +1,4 @@
-export * from './handler.ts';
-export * from './rpc-handler.ts';
-export type { AnyAPIGatewayProxyEvent, APIGatewayProxyEvent, 
-/**
- * AWS API Gateway proxy event, payload format 2.0, also used by Lambda Function URLs.
- *
- * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
- */
-APIGatewayProxyEventV2, 
-/**
- * Shape of the `awslambda` global the Lambda Node.js runtime injects when response streaming is enabled.
- * Declare it yourself: `declare const awslambda: AwsLambdaGlobal`.
- *
- * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
- */
-AwsLambdaGlobal, HttpResponseStream, } from '@standard-server/aws-lambda';
+import { AwsLambdaHandler, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, AnyAPIGatewayProxyEvent, AwsLambdaGlobal, HttpResponseStream } from "@standard-server/aws-lambda";
+export { type APIGatewayProxyEvent, type APIGatewayProxyEventV2, type AnyAPIGatewayProxyEvent, type AwsLambdaGlobal, AwsLambdaHandler, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, type HttpResponseStream, RPCHandler, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.js

@@ -1,2 +1,2 @@
-export * from './handler.js';
-export * from './rpc-handler.js';
+export { AwsLambdaHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

package/dist/adapters/aws-lambda/rpc-handler.d.ts

@@ -1,10 +1,10 @@
-import type { Context } from '../../context.ts';
-import type { Router } from '../../router.ts';
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
-import type { AwsLambdaHandlerOptions } from './handler.ts';
-import { AwsLambdaHandler } from './handler.ts';
-export interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { AwsLambdaHandler, AwsLambdaHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
 /**
  * Serves an oRPC router over the RPC protocol on AWS Lambda,
  * behind API Gateway or Lambda Function URLs.
@@ -15,5 +15,5 @@ export interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOp
  * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
  */
 export declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/aws-lambda/rpc-handler.js

@@ -1,18 +1,21 @@
-import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
-import { AwsLambdaHandler } from './handler.js';
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { AwsLambdaHandler } from "./handler.js";
+// src/adapters/aws-lambda/rpc-handler.ts
 /**
- * Serves an oRPC router over the RPC protocol on AWS Lambda,
- * behind API Gateway or Lambda Function URLs.
- *
- * @remarks
- * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
- *
- * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
- */
-export class RPCHandler extends AwsLambdaHandler {
-    constructor(router, options = {}) {
-        const codec = new RPCHandlerCodec(router, options);
-        const handler = new StandardHandler(codec, options);
-        super(handler, options);
-    }
-}
+* Serves an oRPC router over the RPC protocol on AWS Lambda,
+* behind API Gateway or Lambda Function URLs.
+*
+* @remarks
+* **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
+*
+* @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+*/
+var RPCHandler = class extends AwsLambdaHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -1,45 +1,47 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
-import type { Message, Peer } from 'crossws';
-import type { Context } from '../../context.ts';
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
-export type CrosswsPeerLike = Pick<Peer, 'send'>;
-export type CrosswsMessageLike = Pick<Message, 'rawData' | 'uint8Array'>;
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
+import { Message, Peer } from "crossws";
+export type CrosswsPeerLike = Pick<Peer, "send">;
+export type CrosswsMessageLike = Pick<Message, "rawData" | "uint8Array">;
 export interface experimental_CrosswsHandlerOptions<_T extends Context> {
-    /**
-     * 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;
+  /**
+   * 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;
 }
 export declare class experimental_CrosswsHandler<T extends Context> {
-    private readonly handler;
-    /**
-     * `null` marks a closed peer, so late messages never create a new server peer.
-     */
-    private readonly peers;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * @param ws The crossws peer instance. Use the same instance for all messages.
-     */
-    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     * Messages passed to `.message()` for this peer afterwards are ignored.
-     *
-     * @param ws The same crossws peer instance passed to `.message()`.
-     */
-    close(ws: CrosswsPeerLike): Promise<void>;
-}
+  private readonly handler;
+  /**
+   * `null` marks a closed peer, so late messages never create a new server peer.
+   */
+  private readonly peers;
+  private readonly encodePeerMessageOptions;
+  private readonly decodePeerMessageOptions;
+  constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
+  /**
+   * Handles a single WebSocket message.
+   *
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
+   *
+   * @param ws The crossws peer instance. Use the same instance for all messages.
+   */
+  message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+    matched: boolean;
+  }>;
+  /**
+   * Cleans up peer state for a closed WebSocket.
+   * Messages passed to `.message()` for this peer afterwards are ignored.
+   *
+   * @param ws The same crossws peer instance passed to `.message()`.
+   */
+  close(ws: CrosswsPeerLike): Promise<void>;
+}

package/dist/adapters/crossws/handler.js

@@ -1,60 +1,53 @@
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer, } from '@standard-server/peer';
-import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
-export class experimental_CrosswsHandler {
-    handler;
-    /**
-     * `null` marks a closed peer, so late messages never create a new server peer.
-     */
-    peers = new WeakMap();
-    encodePeerMessageOptions;
-    decodePeerMessageOptions;
-    constructor(handler, options = {}) {
-        this.handler = handler;
-        this.encodePeerMessageOptions = options.encodePeerMessage;
-        this.decodePeerMessageOptions = options.decodePeerMessage;
-    }
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * @param ws The crossws peer instance. Use the same instance for all messages.
-     */
-    async message(ws, message, ...rest) {
-        /**
-         * Message order is important: loading -> decode -> .message.
-         * This flow must stay synchronous, or we need to use `sequential` helper
-         */
-        const encodedMessage = typeof message.rawData === 'string'
-            ? message.rawData
-            : message.uint8Array();
-        const result = decodePeerMessage(encodedMessage, this.decodePeerMessageOptions);
-        let peer = this.peers.get(ws);
-        // Closed: a new peer here would leak and its requests would never be aborted.
-        if (peer === null) {
-            return result;
-        }
-        if (!peer) {
-            this.peers.set(ws, (peer = new ServerPeer(async (message) => {
-                ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
-            })));
-        }
-        if (result.matched && isClientPeerSendMessage(result.message)) {
-            await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
-        }
-        return result;
-    }
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     * Messages passed to `.message()` for this peer afterwards are ignored.
-     *
-     * @param ws The same crossws peer instance passed to `.message()`.
-     */
-    async close(ws) {
-        const peer = this.peers.get(ws);
-        this.peers.set(ws, null);
-        await peer?.close();
-    }
-}
+import { createStandardPeerRequestHandler } from "../standard-peer/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage } from "@standard-server/peer";
+// src/adapters/crossws/handler.ts
+var experimental_CrosswsHandler = class {
+	handler;
+	/**
+	* `null` marks a closed peer, so late messages never create a new server peer.
+	*/
+	peers = /* @__PURE__ */ new WeakMap();
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	/**
+	* Handles a single WebSocket message.
+	*
+	* Message order matters. Call this immediately after receiving a message,
+	* before any other async work, to preserve ordering.
+	*
+	* @param ws The crossws peer instance. Use the same instance for all messages.
+	*/
+	async message(ws, message, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		const encodedMessage = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
+		const result = decodePeerMessage(encodedMessage, this.decodePeerMessageOptions);
+		let peer = this.peers.get(ws);
+		if (peer === null) return result;
+		if (!peer) this.peers.set(ws, peer = new ServerPeer(async (message) => {
+			ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
+		}));
+		if (result.matched && isClientPeerSendMessage(result.message)) await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return result;
+	}
+	/**
+	* Cleans up peer state for a closed WebSocket.
+	* Messages passed to `.message()` for this peer afterwards are ignored.
+	*
+	* @param ws The same crossws peer instance passed to `.message()`.
+	*/
+	async close(ws) {
+		const peer = this.peers.get(ws);
+		this.peers.set(ws, null);
+		await peer?.close();
+	}
+};
+export { experimental_CrosswsHandler };

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

@@ -1,2 +1,3 @@
-export * from './handler.ts';
-export * from './rpc-handler.ts';
+import { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandler, experimental_CrosswsHandlerOptions } from "./handler.js";
+import { experimental_RPCHandler, experimental_RPCHandlerOptions } from "./rpc-handler.js";
+export { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandler, experimental_CrosswsHandlerOptions, experimental_RPCHandler, experimental_RPCHandlerOptions };

package/dist/adapters/crossws/index.js

@@ -1,2 +1,2 @@
-export * from './handler.js';
-export * from './rpc-handler.js';
+export { experimental_CrosswsHandler } from "./handler.js";
+export { experimental_RPCHandler } from "./rpc-handler.js";

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

@@ -1,16 +1,16 @@
-import type { Context } from '../../context.ts';
-import type { Router } from '../../router.ts';
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
-import type { experimental_CrosswsHandlerOptions as CrosswsHandlerOptions } from './handler.ts';
-import { experimental_CrosswsHandler as CrosswsHandler } from './handler.ts';
-export interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, CrosswsHandlerOptions<T> {
-}
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { experimental_CrosswsHandler, experimental_CrosswsHandlerOptions } from "./handler.js";
+export interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {}
 /**
  * Serves an oRPC router over the RPC protocol on a WebSocket connection
  * managed by [crossws](https://github.com/h3js/crossws).
  *
  * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
  */
-export declare class experimental_RPCHandler<T extends Context> extends CrosswsHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
-}
+export declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+  constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
+}

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

@@ -1,15 +1,18 @@
-import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
-import { experimental_CrosswsHandler as CrosswsHandler } from './handler.js';
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { experimental_CrosswsHandler } from "./handler.js";
+// src/adapters/crossws/rpc-handler.ts
 /**
- * Serves an oRPC router over the RPC protocol on a WebSocket connection
- * managed by [crossws](https://github.com/h3js/crossws).
- *
- * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
- */
-export class experimental_RPCHandler extends CrosswsHandler {
-    constructor(router, options = {}) {
-        const codec = new RPCHandlerCodec(router, options);
-        const handler = new StandardHandler(codec, options);
-        super(handler, options);
-    }
-}
+* Serves an oRPC router over the RPC protocol on a WebSocket connection
+* managed by [crossws](https://github.com/h3js/crossws).
+*
+* @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+*/
+var experimental_RPCHandler = class extends experimental_CrosswsHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { experimental_RPCHandler };

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

@@ -1,21 +1,23 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { AnyFastifyReply, AnyFastifyRequest, SendStandardResponseOptions } from '@standard-server/fastify';
-import type { Context } from '../../context.ts';
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { AnyFastifyReply, AnyFastifyRequest, SendStandardResponseOptions } from "@standard-server/fastify";
 export type FastifyHandlerHandleResult = {
-    matched: true;
+  matched: true;
 } | {
-    matched: false;
+  matched: false;
 };
 export interface FastifyHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
+  /**
+   * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+   */
+  sendStandardResponse?: SendStandardResponseOptions | undefined;
 }
 export declare class FastifyHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
-    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
-}
+  private readonly standardHandler;
+  private readonly sendStandardResponseOptions;
+  constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+  handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}

package/dist/adapters/fastify/handler.js

@@ -1,20 +1,20 @@
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/fastify';
-import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-export class FastifyHandler {
-    standardHandler;
-    sendStandardResponseOptions;
-    constructor(standardHandler, options = {}) {
-        this.standardHandler = standardHandler;
-        this.sendStandardResponseOptions = options.sendStandardResponse;
-    }
-    async handle(request, reply, ...rest) {
-        const standardRequest = toStandardLazyRequest(request, reply);
-        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
-        if (!result.matched) {
-            return result;
-        }
-        await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
-        return result;
-    }
-}
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/fastify";
+// src/adapters/fastify/handler.ts
+var FastifyHandler = class {
+	standardHandler;
+	sendStandardResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.sendStandardResponseOptions = options.sendStandardResponse;
+	}
+	async handle(request, reply, ...rest) {
+		const standardRequest = toStandardLazyRequest(request, reply);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) return result;
+		await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
+		return result;
+	}
+};
+export { FastifyHandler };

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

@@ -1,2 +1,3 @@
-export * from './handler.ts';
-export * from './rpc-handler.ts';
+import { FastifyHandler, FastifyHandlerHandleResult, FastifyHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { FastifyHandler, FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/fastify/index.js

@@ -1,2 +1,2 @@
-export * from './handler.js';
-export * from './rpc-handler.js';
+export { FastifyHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

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

@@ -1,15 +1,15 @@
-import type { Context } from '../../context.ts';
-import type { Router } from '../../router.ts';
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
-import type { FastifyHandlerOptions } from './handler.ts';
-import { FastifyHandler } from './handler.ts';
-export interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { FastifyHandler, FastifyHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
 /**
  * Serves an oRPC router over the RPC protocol inside a Fastify server.
  *
  * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
  */
 export declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}