@orpc/standard-server-peer 0.0.0-next.f50512c → 0.0.0-next.f5149a8

package/README.md

@@ -17,6 +17,9 @@
   <a href="https://discord.gg/TXEbwRBvQn">
     <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
   </a>
+  <a href="https://deepwiki.com/unnoq/orpc">
+    <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki">
+  </a>
 </div>
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
@@ -30,7 +33,8 @@
 - **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
 - **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
 - **📝 Contract-First Development**: Optionally define your API contract before implementation.
-- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
+- **🔍 First-Class OpenTelemetry**: Seamlessly integrate with OpenTelemetry for observability.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), SWR, Pinia Colada, and more.
 - **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
 - **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
 - **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
@@ -38,7 +42,6 @@
 - **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
 - **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
 - **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
-- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -50,9 +53,11 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
 - [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/otel](https://www.npmjs.com/package/@orpc/otel): [OpenTelemetry](https://opentelemetry.io/) integration for observability.
 - [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
+- [@orpc/experimental-react-swr](https://www.npmjs.com/package/@orpc/experimental-react-swr): [SWR](https://swr.vercel.app/) integration.
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
 - [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.

package/dist/index.d.mts

@@ -1,33 +1,11 @@
-import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
-import { StandardRequest, StandardResponse, EventMeta } from '@orpc/standard-server';
+import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, SetSpanErrorOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
+import { StandardRequest, EventMeta, StandardResponse, StandardBody, StandardHeaders } from '@orpc/standard-server';
 
 type EncodedMessage = string | ArrayBufferLike | Uint8Array;
 interface EncodedMessageSendFn {
     (message: EncodedMessage): Promisable<void>;
 }
 
-interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
-    /**
-     * Should abort or not?
-     *
-     * @default true
-     */
-    abort?: boolean;
-}
-declare class ClientPeer {
-    private readonly idGenerator;
-    private readonly responseQueue;
-    private readonly serverEventIteratorQueue;
-    private readonly serverControllers;
-    private readonly send;
-    constructor(send: EncodedMessageSendFn);
-    get length(): number;
-    open(id: string): AbortController;
-    request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: EncodedMessage): Promise<void>;
-    close(options?: AsyncIdQueueCloseOptions$1): void;
-}
-
 declare enum MessageType {
     REQUEST = 1,
     RESPONSE = 2,
@@ -50,25 +28,128 @@ interface ResponseMessageMap {
     [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
     [MessageType.ABORT_SIGNAL]: void;
 }
+interface BaseMessageFormat<P = unknown> {
+    /**
+     * Client-guaranteed unique identifier
+     */
+    i: string;
+    /**
+     * @default REQUEST | RESPONSE
+     */
+    t?: MessageType;
+    p: P;
+}
+interface SerializedEventIteratorPayload {
+    e: EventIteratorEvent;
+    d: unknown;
+    m?: EventMeta;
+}
+interface SerializedRequestPayload {
+    /**
+     * The url of the request
+     *
+     * might be relative path if origin is `orpc://localhost`
+     */
+    u: string;
+    b: StandardBody;
+    /**
+     * @default {}
+     */
+    h?: StandardHeaders;
+    /**
+     * @default POST
+     */
+    m?: string;
+}
+interface SerializedResponsePayload {
+    /**
+     * @default 200
+     */
+    s?: number;
+    /**
+     * @default {}
+     */
+    h?: StandardHeaders;
+    b: StandardBody;
+}
 type DecodedMessageUnion<TMap extends RequestMessageMap | ResponseMessageMap> = {
     [K in keyof TMap]: [id: string, type: K, payload: TMap[K]];
 }[keyof TMap];
 type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
 type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
+/**
+ * New serialization functions without Blob handling
+ */
+declare function serializeRequestMessage<T extends keyof RequestMessageMap>(id: string, type: T, payload: RequestMessageMap[T]): BaseMessageFormat;
+declare function deserializeRequestMessage(message: BaseMessageFormat): DecodedRequestMessage;
+declare function serializeResponseMessage<T extends keyof ResponseMessageMap>(id: string, type: T, payload: ResponseMessageMap[T]): BaseMessageFormat;
+declare function deserializeResponseMessage(message: BaseMessageFormat): DecodedResponseMessage;
+/**
+ * Original encode/decode functions now using the new serialize/deserialize functions
+ */
 declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: string, type: T, payload: RequestMessageMap[T]): Promise<EncodedMessage>;
 declare function decodeRequestMessage(raw: EncodedMessage): Promise<DecodedRequestMessage>;
 declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: string, type: T, payload: ResponseMessageMap[T]): Promise<EncodedMessage>;
 declare function decodeResponseMessage(raw: EncodedMessage): Promise<DecodedResponseMessage>;
 
+interface experimental_RequestMessageSendFn {
+    (message: DecodedRequestMessage): Promisable<void>;
+}
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
+declare class ClientPeer {
+    private readonly peer;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: EncodedMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
+declare class experimental_ClientPeerWithoutCodec {
+    private readonly idGenerator;
+    /**
+     * Queue of responses sent from server, awaiting consumption
+     */
+    private readonly responseQueue;
+    /**
+     * Queue of event iterator messages sent from server, awaiting consumption
+     */
+    private readonly serverEventIteratorQueue;
+    /**
+     * Controllers used to signal that the client should stop sending event iterator messages
+     */
+    private readonly serverControllers;
+    /**
+     * Cleanup functions invoked when the request/response is closed
+     */
+    private readonly cleanupFns;
+    private readonly send;
+    constructor(send: experimental_RequestMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message([id, type, payload]: DecodedResponseMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
+
 interface AsyncIdQueueCloseOptions {
     id?: string;
     reason?: unknown;
 }
 declare class AsyncIdQueue<T> {
     private readonly openIds;
-    private readonly items;
-    private readonly pendingPulls;
+    private readonly queues;
+    private readonly waiters;
     get length(): number;
+    get waiterIds(): string[];
+    hasBufferedItems(id: string): boolean;
     open(id: string): void;
     isOpen(id: string): boolean;
     push(id: string, item: T): void;
@@ -77,9 +158,17 @@ declare class AsyncIdQueue<T> {
     assertOpen(id: string): void;
 }
 
-declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: string, cleanup: AsyncIteratorClassCleanupFn): AsyncIteratorClass<unknown>;
+interface ToEventIteratorOptions extends SetSpanErrorOptions {
+}
+declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: string, cleanup: AsyncIteratorClassCleanupFn, options?: ToEventIteratorOptions): AsyncIteratorClass<unknown>;
 declare function resolveEventIterator(iterator: AsyncIterator<any>, callback: (payload: EventIteratorPayload) => Promise<'next' | 'abort'>): Promise<void>;
 
+interface experimental_ResponseMessageSendFn {
+    (message: DecodedResponseMessage): Promisable<void>;
+}
+interface ServerPeerHandleRequestFn {
+    (request: StandardRequest): Promise<StandardResponse>;
+}
 interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     /**
      * Should abort or not?
@@ -89,16 +178,43 @@ interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     abort?: boolean;
 }
 declare class ServerPeer {
+    private readonly peer;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    /**
+     * @todo This method will return Promise<void> in the next major version.
+     */
+    message(raw: EncodedMessage, handleRequest?: ServerPeerHandleRequestFn): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+     */
+    response(id: string, response: StandardResponse): Promise<void>;
+    close({ abort, ...options }?: ServerPeerCloseOptions): void;
+}
+declare class experimental_ServerPeerWithoutCodec {
+    /**
+     * Queue of event iterator messages sent from client, awaiting consumption
+     */
     private readonly clientEventIteratorQueue;
+    /**
+     * Map of active client request controllers, should be synced to request signal
+     */
     private readonly clientControllers;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_ResponseMessageSendFn);
     get length(): number;
     open(id: string): AbortController;
-    message(raw: EncodedMessage): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @todo This method will return Promise<void> in the next major version.
+     */
+    message([id, type, payload]: DecodedRequestMessage, handleRequest?: ServerPeerHandleRequestFn): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+     */
     response(id: string, response: StandardResponse): Promise<void>;
     close({ abort, ...options }?: ServerPeerCloseOptions): void;
 }
 
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, resolveEventIterator, toEventIterator };
-export type { ClientPeerCloseOptions, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, ServerPeerCloseOptions };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, deserializeRequestMessage, deserializeResponseMessage, encodeRequestMessage, encodeResponseMessage, experimental_ClientPeerWithoutCodec, experimental_ServerPeerWithoutCodec, resolveEventIterator, serializeRequestMessage, serializeResponseMessage, toEventIterator };
+export type { BaseMessageFormat, ClientPeerCloseOptions, DecodedMessageUnion, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, SerializedEventIteratorPayload, SerializedRequestPayload, SerializedResponsePayload, ServerPeerCloseOptions, ServerPeerHandleRequestFn, ToEventIteratorOptions, experimental_RequestMessageSendFn, experimental_ResponseMessageSendFn };

package/dist/index.d.ts

@@ -1,33 +1,11 @@
-import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
-import { StandardRequest, StandardResponse, EventMeta } from '@orpc/standard-server';
+import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, SetSpanErrorOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
+import { StandardRequest, EventMeta, StandardResponse, StandardBody, StandardHeaders } from '@orpc/standard-server';
 
 type EncodedMessage = string | ArrayBufferLike | Uint8Array;
 interface EncodedMessageSendFn {
     (message: EncodedMessage): Promisable<void>;
 }
 
-interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
-    /**
-     * Should abort or not?
-     *
-     * @default true
-     */
-    abort?: boolean;
-}
-declare class ClientPeer {
-    private readonly idGenerator;
-    private readonly responseQueue;
-    private readonly serverEventIteratorQueue;
-    private readonly serverControllers;
-    private readonly send;
-    constructor(send: EncodedMessageSendFn);
-    get length(): number;
-    open(id: string): AbortController;
-    request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: EncodedMessage): Promise<void>;
-    close(options?: AsyncIdQueueCloseOptions$1): void;
-}
-
 declare enum MessageType {
     REQUEST = 1,
     RESPONSE = 2,
@@ -50,25 +28,128 @@ interface ResponseMessageMap {
     [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
     [MessageType.ABORT_SIGNAL]: void;
 }
+interface BaseMessageFormat<P = unknown> {
+    /**
+     * Client-guaranteed unique identifier
+     */
+    i: string;
+    /**
+     * @default REQUEST | RESPONSE
+     */
+    t?: MessageType;
+    p: P;
+}
+interface SerializedEventIteratorPayload {
+    e: EventIteratorEvent;
+    d: unknown;
+    m?: EventMeta;
+}
+interface SerializedRequestPayload {
+    /**
+     * The url of the request
+     *
+     * might be relative path if origin is `orpc://localhost`
+     */
+    u: string;
+    b: StandardBody;
+    /**
+     * @default {}
+     */
+    h?: StandardHeaders;
+    /**
+     * @default POST
+     */
+    m?: string;
+}
+interface SerializedResponsePayload {
+    /**
+     * @default 200
+     */
+    s?: number;
+    /**
+     * @default {}
+     */
+    h?: StandardHeaders;
+    b: StandardBody;
+}
 type DecodedMessageUnion<TMap extends RequestMessageMap | ResponseMessageMap> = {
     [K in keyof TMap]: [id: string, type: K, payload: TMap[K]];
 }[keyof TMap];
 type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
 type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
+/**
+ * New serialization functions without Blob handling
+ */
+declare function serializeRequestMessage<T extends keyof RequestMessageMap>(id: string, type: T, payload: RequestMessageMap[T]): BaseMessageFormat;
+declare function deserializeRequestMessage(message: BaseMessageFormat): DecodedRequestMessage;
+declare function serializeResponseMessage<T extends keyof ResponseMessageMap>(id: string, type: T, payload: ResponseMessageMap[T]): BaseMessageFormat;
+declare function deserializeResponseMessage(message: BaseMessageFormat): DecodedResponseMessage;
+/**
+ * Original encode/decode functions now using the new serialize/deserialize functions
+ */
 declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: string, type: T, payload: RequestMessageMap[T]): Promise<EncodedMessage>;
 declare function decodeRequestMessage(raw: EncodedMessage): Promise<DecodedRequestMessage>;
 declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: string, type: T, payload: ResponseMessageMap[T]): Promise<EncodedMessage>;
 declare function decodeResponseMessage(raw: EncodedMessage): Promise<DecodedResponseMessage>;
 
+interface experimental_RequestMessageSendFn {
+    (message: DecodedRequestMessage): Promisable<void>;
+}
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
+declare class ClientPeer {
+    private readonly peer;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: EncodedMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
+declare class experimental_ClientPeerWithoutCodec {
+    private readonly idGenerator;
+    /**
+     * Queue of responses sent from server, awaiting consumption
+     */
+    private readonly responseQueue;
+    /**
+     * Queue of event iterator messages sent from server, awaiting consumption
+     */
+    private readonly serverEventIteratorQueue;
+    /**
+     * Controllers used to signal that the client should stop sending event iterator messages
+     */
+    private readonly serverControllers;
+    /**
+     * Cleanup functions invoked when the request/response is closed
+     */
+    private readonly cleanupFns;
+    private readonly send;
+    constructor(send: experimental_RequestMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message([id, type, payload]: DecodedResponseMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
+
 interface AsyncIdQueueCloseOptions {
     id?: string;
     reason?: unknown;
 }
 declare class AsyncIdQueue<T> {
     private readonly openIds;
-    private readonly items;
-    private readonly pendingPulls;
+    private readonly queues;
+    private readonly waiters;
     get length(): number;
+    get waiterIds(): string[];
+    hasBufferedItems(id: string): boolean;
     open(id: string): void;
     isOpen(id: string): boolean;
     push(id: string, item: T): void;
@@ -77,9 +158,17 @@ declare class AsyncIdQueue<T> {
     assertOpen(id: string): void;
 }
 
-declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: string, cleanup: AsyncIteratorClassCleanupFn): AsyncIteratorClass<unknown>;
+interface ToEventIteratorOptions extends SetSpanErrorOptions {
+}
+declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: string, cleanup: AsyncIteratorClassCleanupFn, options?: ToEventIteratorOptions): AsyncIteratorClass<unknown>;
 declare function resolveEventIterator(iterator: AsyncIterator<any>, callback: (payload: EventIteratorPayload) => Promise<'next' | 'abort'>): Promise<void>;
 
+interface experimental_ResponseMessageSendFn {
+    (message: DecodedResponseMessage): Promisable<void>;
+}
+interface ServerPeerHandleRequestFn {
+    (request: StandardRequest): Promise<StandardResponse>;
+}
 interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     /**
      * Should abort or not?
@@ -89,16 +178,43 @@ interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     abort?: boolean;
 }
 declare class ServerPeer {
+    private readonly peer;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: string): AbortController;
+    /**
+     * @todo This method will return Promise<void> in the next major version.
+     */
+    message(raw: EncodedMessage, handleRequest?: ServerPeerHandleRequestFn): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+     */
+    response(id: string, response: StandardResponse): Promise<void>;
+    close({ abort, ...options }?: ServerPeerCloseOptions): void;
+}
+declare class experimental_ServerPeerWithoutCodec {
+    /**
+     * Queue of event iterator messages sent from client, awaiting consumption
+     */
     private readonly clientEventIteratorQueue;
+    /**
+     * Map of active client request controllers, should be synced to request signal
+     */
     private readonly clientControllers;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_ResponseMessageSendFn);
     get length(): number;
     open(id: string): AbortController;
-    message(raw: EncodedMessage): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @todo This method will return Promise<void> in the next major version.
+     */
+    message([id, type, payload]: DecodedRequestMessage, handleRequest?: ServerPeerHandleRequestFn): Promise<[id: string, StandardRequest | undefined]>;
+    /**
+     * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+     */
     response(id: string, response: StandardResponse): Promise<void>;
     close({ abort, ...options }?: ServerPeerCloseOptions): void;
 }
 
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, resolveEventIterator, toEventIterator };
-export type { ClientPeerCloseOptions, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, ServerPeerCloseOptions };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, deserializeRequestMessage, deserializeResponseMessage, encodeRequestMessage, encodeResponseMessage, experimental_ClientPeerWithoutCodec, experimental_ServerPeerWithoutCodec, resolveEventIterator, serializeRequestMessage, serializeResponseMessage, toEventIterator };
+export type { BaseMessageFormat, ClientPeerCloseOptions, DecodedMessageUnion, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, SerializedEventIteratorPayload, SerializedRequestPayload, SerializedResponsePayload, ServerPeerCloseOptions, ServerPeerHandleRequestFn, ToEventIteratorOptions, experimental_RequestMessageSendFn, experimental_ResponseMessageSendFn };

package/dist/index.mjs

@@ -1,6 +1,8 @@
-import { isAsyncIteratorObject, stringifyJSON, readAsBuffer, AsyncIteratorClass, isTypescriptObject, SequentialIdGenerator, AsyncIdQueue } from '@orpc/shared';
-import { generateContentDisposition, flattenHeader, getFilenameFromContentDisposition, withEventMeta, ErrorEvent, getEventMeta, isEventIteratorHeaders, experimental_HibernationEventIterator } from '@orpc/standard-server';
+import { isAsyncIteratorObject, stringifyJSON, readAsBuffer, AsyncIteratorClass, startSpan, runInSpanContext, isTypescriptObject, setSpanError, runWithSpan, SequentialIdGenerator, AsyncIdQueue, getGlobalOtelConfig, clone, AbortError } from '@orpc/shared';
+import { generateContentDisposition, flattenHeader, getFilenameFromContentDisposition, withEventMeta, ErrorEvent, getEventMeta, isEventIteratorHeaders, HibernationEventIterator } from '@orpc/standard-server';
 
+const SHORTABLE_ORIGIN = "orpc://localhost";
+const SHORTABLE_ORIGIN_MATCHER = /^orpc:\/\/localhost\//;
 var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2[MessageType2["REQUEST"] = 1] = "REQUEST";
   MessageType2[MessageType2["RESPONSE"] = 2] = "RESPONSE";
@@ -8,7 +10,7 @@ var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2[MessageType2["ABORT_SIGNAL"] = 4] = "ABORT_SIGNAL";
   return MessageType2;
 })(MessageType || {});
-async function encodeRequestMessage(id, type, payload) {
+function serializeRequestMessage(id, type, payload) {
   if (type === 3 /* EVENT_ITERATOR */) {
     const eventPayload = payload;
     const serializedPayload2 = {
@@ -16,35 +18,26 @@ async function encodeRequestMessage(id, type, payload) {
       d: eventPayload.data,
       m: eventPayload.meta
     };
-    return encodeRawMessage({ i: id, t: type, p: serializedPayload2 });
+    return { i: id, t: type, p: serializedPayload2 };
   }
   if (type === 4 /* ABORT_SIGNAL */) {
-    return encodeRawMessage({ i: id, t: type, p: payload });
+    return { i: id, t: type, p: payload };
   }
   const request = payload;
-  const { body: processedBody, headers: processedHeaders } = await serializeBodyAndHeaders(
-    request.body,
-    request.headers
-  );
   const serializedPayload = {
-    u: request.url.toString().replace(/^orpc:\//, "/"),
-    b: processedBody instanceof Blob ? void 0 : processedBody,
-    h: Object.keys(processedHeaders).length > 0 ? processedHeaders : void 0,
+    u: request.url.toString().replace(SHORTABLE_ORIGIN_MATCHER, "/"),
+    b: request.body,
+    h: Object.keys(request.headers).length > 0 ? request.headers : void 0,
     m: request.method === "POST" ? void 0 : request.method
   };
-  const baseMessage = {
+  return {
     i: id,
     p: serializedPayload
   };
-  if (processedBody instanceof Blob) {
-    return encodeRawMessage(baseMessage, processedBody);
-  }
-  return encodeRawMessage(baseMessage);
 }
-async function decodeRequestMessage(raw) {
-  const { json: message, buffer } = await decodeRawMessage(raw);
+function deserializeRequestMessage(message) {
   const id = message.i;
-  const type = message.t;
+  const type = message.t ?? 1 /* REQUEST */;
   if (type === 3 /* EVENT_ITERATOR */) {
     const payload2 = message.p;
     return [id, type, { event: payload2.e, data: payload2.d, meta: payload2.m }];
@@ -53,11 +46,14 @@ async function decodeRequestMessage(raw) {
     return [id, type, message.p];
   }
   const payload = message.p;
-  const headers = payload.h ?? {};
-  const body = await deserializeBody(headers, payload.b, buffer);
-  return [id, 1 /* REQUEST */, { url: new URL(payload.u, "orpc:/"), headers, method: payload.m ?? "POST", body }];
+  return [id, 1 /* REQUEST */, {
+    url: payload.u.startsWith("/") ? new URL(`${SHORTABLE_ORIGIN}${payload.u}`) : new URL(payload.u),
+    headers: payload.h ?? {},
+    method: payload.m ?? "POST",
+    body: payload.b
+  }];
 }
-async function encodeResponseMessage(id, type, payload) {
+function serializeResponseMessage(id, type, payload) {
   if (type === 3 /* EVENT_ITERATOR */) {
     const eventPayload = payload;
     const serializedPayload2 = {
@@ -65,32 +61,23 @@ async function encodeResponseMessage(id, type, payload) {
       d: eventPayload.data,
       m: eventPayload.meta
     };
-    return encodeRawMessage({ i: id, t: type, p: serializedPayload2 });
+    return { i: id, t: type, p: serializedPayload2 };
   }
   if (type === 4 /* ABORT_SIGNAL */) {
-    return encodeRawMessage({ i: id, t: type, p: void 0 });
+    return { i: id, t: type, p: void 0 };
   }
   const response = payload;
-  const { body: processedBody, headers: processedHeaders } = await serializeBodyAndHeaders(
-    response.body,
-    response.headers
-  );
   const serializedPayload = {
     s: response.status === 200 ? void 0 : response.status,
-    h: Object.keys(processedHeaders).length > 0 ? processedHeaders : void 0,
-    b: processedBody instanceof Blob ? void 0 : processedBody
+    h: Object.keys(response.headers).length > 0 ? response.headers : void 0,
+    b: response.body
   };
-  const baseMessage = {
+  return {
     i: id,
     p: serializedPayload
   };
-  if (processedBody instanceof Blob) {
-    return encodeRawMessage(baseMessage, processedBody);
-  }
-  return encodeRawMessage(baseMessage);
 }
-async function decodeResponseMessage(raw) {
-  const { json: message, buffer } = await decodeRawMessage(raw);
+function deserializeResponseMessage(message) {
   const id = message.i;
   const type = message.t;
   if (type === 3 /* EVENT_ITERATOR */) {
@@ -101,9 +88,71 @@ async function decodeResponseMessage(raw) {
     return [id, type, message.p];
   }
   const payload = message.p;
-  const headers = payload.h ?? {};
-  const body = await deserializeBody(headers, payload.b, buffer);
-  return [id, 2 /* RESPONSE */, { status: payload.s ?? 200, headers, body }];
+  return [id, 2 /* RESPONSE */, {
+    status: payload.s ?? 200,
+    headers: payload.h ?? {},
+    body: payload.b
+  }];
+}
+async function encodeRequestMessage(id, type, payload) {
+  if (type === 3 /* EVENT_ITERATOR */ || type === 4 /* ABORT_SIGNAL */) {
+    return encodeRawMessage(serializeRequestMessage(id, type, payload));
+  }
+  const request = payload;
+  const { body: processedBody, headers: processedHeaders } = await serializeBodyAndHeaders(
+    request.body,
+    request.headers
+  );
+  const modifiedRequest = {
+    ...request,
+    body: processedBody instanceof Blob ? void 0 : processedBody,
+    headers: processedHeaders
+  };
+  const baseMessage = serializeRequestMessage(id, 1 /* REQUEST */, modifiedRequest);
+  if (processedBody instanceof Blob) {
+    return encodeRawMessage(baseMessage, processedBody);
+  }
+  return encodeRawMessage(baseMessage);
+}
+async function decodeRequestMessage(raw) {
+  const { json: message, buffer } = await decodeRawMessage(raw);
+  const [id, type, payload] = deserializeRequestMessage(message);
+  if (type === 3 /* EVENT_ITERATOR */ || type === 4 /* ABORT_SIGNAL */) {
+    return [id, type, payload];
+  }
+  const request = payload;
+  const body = await deserializeBody(request.headers, request.body, buffer);
+  return [id, type, { ...request, body }];
+}
+async function encodeResponseMessage(id, type, payload) {
+  if (type === 3 /* EVENT_ITERATOR */ || type === 4 /* ABORT_SIGNAL */) {
+    return encodeRawMessage(serializeResponseMessage(id, type, payload));
+  }
+  const response = payload;
+  const { body: processedBody, headers: processedHeaders } = await serializeBodyAndHeaders(
+    response.body,
+    response.headers
+  );
+  const modifiedResponse = {
+    ...response,
+    body: processedBody instanceof Blob ? void 0 : processedBody,
+    headers: processedHeaders
+  };
+  const baseMessage = serializeResponseMessage(id, 2 /* RESPONSE */, modifiedResponse);
+  if (processedBody instanceof Blob) {
+    return encodeRawMessage(baseMessage, processedBody);
+  }
+  return encodeRawMessage(baseMessage);
+}
+async function decodeResponseMessage(raw) {
+  const { json: message, buffer } = await decodeRawMessage(raw);
+  const [id, type, payload] = deserializeResponseMessage(message);
+  if (type === 3 /* EVENT_ITERATOR */ || type === 4 /* ABORT_SIGNAL */) {
+    return [id, type, payload];
+  }
+  const response = payload;
+  const body = await deserializeBody(response.headers, response.body, buffer);
+  return [id, type, { ...response, body }];
 }
 async function serializeBodyAndHeaders(body, originalHeaders) {
   const headers = { ...originalHeaders };
@@ -179,134 +228,252 @@ async function decodeRawMessage(raw) {
   };
 }
 
-function toEventIterator(queue, id, cleanup) {
+function toEventIterator(queue, id, cleanup, options = {}) {
+  let span;
   return new AsyncIteratorClass(async () => {
-    const item = await queue.pull(id);
-    switch (item.event) {
-      case "message": {
-        let data = item.data;
-        if (item.meta && isTypescriptObject(data)) {
-          data = withEventMeta(data, item.meta);
+    span ??= startSpan("consume_event_iterator_stream");
+    try {
+      const item = await runInSpanContext(span, () => queue.pull(id));
+      switch (item.event) {
+        case "message": {
+          let data = item.data;
+          if (item.meta && isTypescriptObject(data)) {
+            data = withEventMeta(data, item.meta);
+          }
+          span?.addEvent("message");
+          return { value: data, done: false };
         }
-        return { value: data, done: false };
-      }
-      case "error": {
-        let error = new ErrorEvent({
-          data: item.data
-        });
-        if (item.meta) {
-          error = withEventMeta(error, item.meta);
+        case "error": {
+          let error = new ErrorEvent({
+            data: item.data
+          });
+          if (item.meta) {
+            error = withEventMeta(error, item.meta);
+          }
+          span?.addEvent("error");
+          throw error;
         }
-        throw error;
-      }
-      case "done": {
-        let data = item.data;
-        if (item.meta && isTypescriptObject(data)) {
-          data = withEventMeta(data, item.meta);
+        case "done": {
+          let data = item.data;
+          if (item.meta && isTypescriptObject(data)) {
+            data = withEventMeta(data, item.meta);
+          }
+          span?.addEvent("done");
+          return { value: data, done: true };
         }
-        return { value: data, done: true };
       }
-    }
-  }, cleanup);
-}
-async function resolveEventIterator(iterator, callback) {
-  while (true) {
-    const payload = await (async () => {
-      try {
-        const { value, done } = await iterator.next();
-        if (done) {
-          return { event: "done", data: value, meta: getEventMeta(value) };
-        }
-        return { event: "message", data: value, meta: getEventMeta(value) };
-      } catch (err) {
-        return {
-          meta: getEventMeta(err),
-          event: "error",
-          data: err instanceof ErrorEvent ? err.data : void 0
-        };
+    } catch (e) {
+      if (!(e instanceof ErrorEvent)) {
+        setSpanError(span, e, options);
       }
-    })();
+      throw e;
+    }
+  }, async (reason) => {
     try {
-      const direction = await callback(payload);
-      if (payload.event === "done" || payload.event === "error") {
-        return;
+      if (reason !== "next") {
+        span?.addEvent("cancelled");
       }
-      if (direction === "abort") {
+      await runInSpanContext(span, () => cleanup(reason));
+    } catch (e) {
+      setSpanError(span, e, options);
+      throw e;
+    } finally {
+      span?.end();
+    }
+  });
+}
+function resolveEventIterator(iterator, callback) {
+  return runWithSpan(
+    { name: "stream_event_iterator" },
+    async (span) => {
+      while (true) {
+        const payload = await (async () => {
+          try {
+            const { value, done } = await iterator.next();
+            if (done) {
+              span?.addEvent("done");
+              return { event: "done", data: value, meta: getEventMeta(value) };
+            }
+            span?.addEvent("message");
+            return { event: "message", data: value, meta: getEventMeta(value) };
+          } catch (err) {
+            if (err instanceof ErrorEvent) {
+              span?.addEvent("error");
+              return {
+                event: "error",
+                data: err.data,
+                meta: getEventMeta(err)
+              };
+            } else {
+              try {
+                await callback({ event: "error", data: void 0 });
+              } catch (err2) {
+                setSpanError(span, err);
+                throw err2;
+              }
+              throw err;
+            }
+          }
+        })();
+        let isInvokeCleanupFn = false;
         try {
-          await iterator.return?.();
-        } catch {
+          const direction = await callback(payload);
+          if (payload.event === "done" || payload.event === "error") {
+            return;
+          }
+          if (direction === "abort") {
+            isInvokeCleanupFn = true;
+            await iterator.return?.();
+            return;
+          }
+        } catch (err) {
+          if (!isInvokeCleanupFn) {
+            try {
+              await iterator.return?.();
+            } catch (err2) {
+              setSpanError(span, err);
+              throw err2;
+            }
+          }
+          throw err;
         }
-        return;
-      }
-    } catch (err) {
-      try {
-        await iterator.return?.();
-      } catch {
       }
-      throw err;
     }
-  }
+  );
 }
 
 class ClientPeer {
+  peer;
+  constructor(send) {
+    this.peer = new experimental_ClientPeerWithoutCodec(async ([id, type, payload]) => {
+      await send(await encodeRequestMessage(id, type, payload));
+    });
+  }
+  get length() {
+    return this.peer.length;
+  }
+  open(id) {
+    return this.peer.open(id);
+  }
+  async request(request) {
+    return this.peer.request(request);
+  }
+  async message(raw) {
+    return this.peer.message(await decodeResponseMessage(raw));
+  }
+  close(options = {}) {
+    return this.peer.close(options);
+  }
+}
+class experimental_ClientPeerWithoutCodec {
   idGenerator = new SequentialIdGenerator();
+  /**
+   * Queue of responses sent from server, awaiting consumption
+   */
   responseQueue = new AsyncIdQueue();
+  /**
+   * Queue of event iterator messages sent from server, awaiting consumption
+   */
   serverEventIteratorQueue = new AsyncIdQueue();
+  /**
+   * Controllers used to signal that the client should stop sending event iterator messages
+   */
   serverControllers = /* @__PURE__ */ new Map();
+  /**
+   * Cleanup functions invoked when the request/response is closed
+   */
+  cleanupFns = /* @__PURE__ */ new Map();
   send;
   constructor(send) {
-    this.send = async (id, ...rest) => encodeRequestMessage(id, ...rest).then(async (raw) => {
+    this.send = async (message) => {
+      const id = message[0];
       if (this.serverControllers.has(id)) {
-        await send(raw);
+        await send(message);
       }
-    });
+    };
   }
   get length() {
-    return (+this.responseQueue.length + this.serverEventIteratorQueue.length + this.serverControllers.size) / 3;
+    return (+this.responseQueue.length + this.serverEventIteratorQueue.length + this.serverControllers.size + this.cleanupFns.size) / 4;
   }
   open(id) {
     this.serverEventIteratorQueue.open(id);
     this.responseQueue.open(id);
     const controller = new AbortController();
     this.serverControllers.set(id, controller);
+    this.cleanupFns.set(id, []);
     return controller;
   }
   async request(request) {
     const signal = request.signal;
-    if (signal?.aborted) {
-      throw signal.reason;
-    }
-    const id = this.idGenerator.generate();
-    const serverController = this.open(id);
-    return new Promise((resolve, reject) => {
-      this.send(id, MessageType.REQUEST, request).then(async () => {
+    return runWithSpan(
+      { name: "send_peer_request", signal },
+      async () => {
         if (signal?.aborted) {
-          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
-          this.close({ id, reason: signal.reason });
-          return;
+          throw signal.reason;
         }
-        signal?.addEventListener("abort", async () => {
-          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
-          this.close({ id, reason: signal.reason });
-        }, { once: true });
-        if (isAsyncIteratorObject(request.body)) {
-          await resolveEventIterator(request.body, async (payload) => {
-            if (serverController.signal.aborted) {
-              return "abort";
-            }
-            await this.send(id, MessageType.EVENT_ITERATOR, payload);
-            return "next";
+        const id = this.idGenerator.generate();
+        const serverController = this.open(id);
+        try {
+          const otelConfig = getGlobalOtelConfig();
+          if (otelConfig) {
+            const headers = clone(request.headers);
+            otelConfig.propagation.inject(otelConfig.context.active(), headers);
+            request = { ...request, headers };
+          }
+          await this.send([id, MessageType.REQUEST, request]);
+          if (signal?.aborted) {
+            await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
+            throw signal.reason;
+          }
+          let abortListener;
+          signal?.addEventListener("abort", abortListener = async () => {
+            await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
+            this.close({ id, reason: signal.reason });
+          }, { once: true });
+          this.cleanupFns.get(id)?.push(() => {
+            signal?.removeEventListener("abort", abortListener);
           });
+          if (isAsyncIteratorObject(request.body)) {
+            const iterator = request.body;
+            void resolveEventIterator(iterator, async (payload) => {
+              if (serverController.signal.aborted) {
+                return "abort";
+              }
+              await this.send([id, MessageType.EVENT_ITERATOR, payload]);
+              return "next";
+            });
+          }
+          const response = await this.responseQueue.pull(id);
+          if (isEventIteratorHeaders(response.headers)) {
+            const iterator = toEventIterator(
+              this.serverEventIteratorQueue,
+              id,
+              async (reason) => {
+                try {
+                  if (reason !== "next") {
+                    await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
+                  }
+                } finally {
+                  this.close({ id });
+                }
+              },
+              { signal }
+            );
+            return {
+              ...response,
+              body: iterator
+            };
+          }
+          this.close({ id });
+          return response;
+        } catch (err) {
+          this.close({ id, reason: err });
+          throw err;
         }
-      }).catch((err) => {
-        this.close({ id, reason: err });
-        reject(err);
-      });
-      this.responseQueue.pull(id).then(resolve).catch(reject);
-    });
+      }
+    );
   }
-  async message(raw) {
-    const [id, type, payload] = await decodeResponseMessage(raw);
+  async message([id, type, payload]) {
     if (type === MessageType.ABORT_SIGNAL) {
       this.serverControllers.get(id)?.abort();
       return;
@@ -320,31 +487,19 @@ class ClientPeer {
     if (!this.responseQueue.isOpen(id)) {
       return;
     }
-    if (isEventIteratorHeaders(payload.headers)) {
-      this.responseQueue.push(id, {
-        ...payload,
-        body: toEventIterator(this.serverEventIteratorQueue, id, async (reason) => {
-          try {
-            if (reason !== "next") {
-              await this.send(id, MessageType.ABORT_SIGNAL, void 0);
-            }
-          } finally {
-            this.close({ id });
-          }
-        })
-      });
-    } else {
-      this.responseQueue.push(id, payload);
-      this.close({ id });
-    }
+    this.responseQueue.push(id, payload);
   }
   close(options = {}) {
     if (options.id !== void 0) {
       this.serverControllers.get(options.id)?.abort(options.reason);
       this.serverControllers.delete(options.id);
+      this.cleanupFns.get(options.id)?.forEach((fn) => fn());
+      this.cleanupFns.delete(options.id);
     } else {
       this.serverControllers.forEach((c) => c.abort(options.reason));
       this.serverControllers.clear();
+      this.cleanupFns.forEach((fns) => fns.forEach((fn) => fn()));
+      this.cleanupFns.clear();
     }
     this.responseQueue.close(options);
     this.serverEventIteratorQueue.close(options);
@@ -352,15 +507,51 @@ class ClientPeer {
 }
 
 class ServerPeer {
+  peer;
+  constructor(send) {
+    this.peer = new experimental_ServerPeerWithoutCodec(async ([id, type, payload]) => {
+      await send(await encodeResponseMessage(id, type, payload));
+    });
+  }
+  get length() {
+    return this.peer.length;
+  }
+  open(id) {
+    return this.peer.open(id);
+  }
+  /**
+   * @todo This method will return Promise<void> in the next major version.
+   */
+  async message(raw, handleRequest) {
+    return this.peer.message(await decodeRequestMessage(raw), handleRequest);
+  }
+  /**
+   * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+   */
+  async response(id, response) {
+    return this.peer.response(id, response);
+  }
+  close({ abort = true, ...options } = {}) {
+    return this.peer.close({ ...options, abort });
+  }
+}
+class experimental_ServerPeerWithoutCodec {
+  /**
+   * Queue of event iterator messages sent from client, awaiting consumption
+   */
   clientEventIteratorQueue = new AsyncIdQueue();
+  /**
+   * Map of active client request controllers, should be synced to request signal
+   */
   clientControllers = /* @__PURE__ */ new Map();
   send;
   constructor(send) {
-    this.send = (id, ...rest) => encodeResponseMessage(id, ...rest).then(async (raw) => {
+    this.send = async (message) => {
+      const id = message[0];
       if (this.clientControllers.has(id)) {
-        await send(raw);
+        await send(message);
       }
-    });
+    };
   }
   get length() {
     return (this.clientEventIteratorQueue.length + this.clientControllers.size) / 2;
@@ -371,10 +562,12 @@ class ServerPeer {
     this.clientControllers.set(id, controller);
     return controller;
   }
-  async message(raw) {
-    const [id, type, payload] = await decodeRequestMessage(raw);
+  /**
+   * @todo This method will return Promise<void> in the next major version.
+   */
+  async message([id, type, payload], handleRequest) {
     if (type === MessageType.ABORT_SIGNAL) {
-      this.close({ id });
+      this.close({ id, reason: new AbortError("Client aborted the request") });
       return [id, void 0];
     }
     if (type === MessageType.EVENT_ITERATOR) {
@@ -384,51 +577,89 @@ class ServerPeer {
       return [id, void 0];
     }
     const clientController = this.open(id);
+    const signal = clientController.signal;
     const request = {
       ...payload,
-      signal: clientController.signal,
-      body: isEventIteratorHeaders(payload.headers) ? toEventIterator(this.clientEventIteratorQueue, id, async (reason) => {
-        if (reason !== "next") {
-          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
-        }
-      }) : payload.body
+      signal,
+      body: isEventIteratorHeaders(payload.headers) ? toEventIterator(
+        this.clientEventIteratorQueue,
+        id,
+        async (reason) => {
+          if (reason !== "next") {
+            await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
+          }
+        },
+        { signal }
+      ) : payload.body
     };
+    if (handleRequest) {
+      let context;
+      const otelConfig = getGlobalOtelConfig();
+      if (otelConfig) {
+        context = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+      }
+      await runWithSpan(
+        { name: "receive_peer_request", context },
+        async () => {
+          const response = await runWithSpan(
+            { name: "handle_request" },
+            async () => {
+              try {
+                return await handleRequest(request);
+              } catch (reason) {
+                this.close({ id, reason, abort: false });
+                throw reason;
+              }
+            }
+          );
+          await runWithSpan(
+            { name: "send_peer_response" },
+            () => this.response(id, response)
+          );
+        }
+      );
+    }
     return [id, request];
   }
+  /**
+   * @deprecated Please pass the `handleRequest` (second arg) function to the `message` method instead.
+   */
   async response(id, response) {
     const signal = this.clientControllers.get(id)?.signal;
     if (!signal || signal.aborted) {
       return;
     }
-    await this.send(id, MessageType.RESPONSE, response).then(async () => {
+    try {
+      await this.send([id, MessageType.RESPONSE, response]);
       if (!signal.aborted && isAsyncIteratorObject(response.body)) {
-        if (response.body instanceof experimental_HibernationEventIterator) {
+        if (response.body instanceof HibernationEventIterator) {
           response.body.hibernationCallback?.(id);
         } else {
-          await resolveEventIterator(response.body, async (payload) => {
+          const iterator = response.body;
+          await resolveEventIterator(iterator, async (payload) => {
             if (signal.aborted) {
               return "abort";
             }
-            await this.send(id, MessageType.EVENT_ITERATOR, payload);
+            await this.send([id, MessageType.EVENT_ITERATOR, payload]);
             return "next";
           });
         }
       }
       this.close({ id, abort: false });
-    }).catch((reason) => {
+    } catch (reason) {
       this.close({ id, reason, abort: false });
       throw reason;
-    });
+    }
   }
   close({ abort = true, ...options } = {}) {
     if (options.id === void 0) {
       if (abort) {
-        this.clientControllers.forEach((c) => c.abort());
+        this.clientControllers.forEach((c) => c.abort(options.reason));
       }
       this.clientControllers.clear();
     } else {
       if (abort) {
-        this.clientControllers.get(options.id)?.abort();
+        this.clientControllers.get(options.id)?.abort(options.reason);
       }
       this.clientControllers.delete(options.id);
     }
@@ -436,4 +667,4 @@ class ServerPeer {
   }
 }
 
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, resolveEventIterator, toEventIterator };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, deserializeRequestMessage, deserializeResponseMessage, encodeRequestMessage, encodeResponseMessage, experimental_ClientPeerWithoutCodec, experimental_ServerPeerWithoutCodec, resolveEventIterator, serializeRequestMessage, serializeResponseMessage, toEventIterator };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/standard-server-peer",
   "type": "module",
-  "version": "0.0.0-next.f50512c",
+  "version": "0.0.0-next.f5149a8",
   "license": "MIT",
   "homepage": "https://unnoq.com",
   "repository": {
@@ -23,8 +23,8 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.f50512c",
-    "@orpc/standard-server": "0.0.0-next.f50512c"
+    "@orpc/standard-server": "0.0.0-next.f5149a8",
+    "@orpc/shared": "0.0.0-next.f5149a8"
   },
   "scripts": {
     "build": "unbuild",