@orpc/standard-server-peer 0.0.0-next.f7af1c4 → 0.0.0-next.f8cfaa5

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>

package/dist/index.d.mts

@@ -1,11 +1,100 @@
 import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, SetSpanErrorOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
-import { StandardRequest, StandardResponse, EventMeta } from '@orpc/standard-server';
+import { StandardRequest, EventMeta, StandardResponse, StandardBody, StandardHeaders } from '@orpc/standard-server';
 
 type EncodedMessage = string | ArrayBufferLike | Uint8Array;
 interface EncodedMessageSendFn {
     (message: EncodedMessage): Promisable<void>;
 }
 
+declare enum MessageType {
+    REQUEST = 1,
+    RESPONSE = 2,
+    EVENT_ITERATOR = 3,
+    ABORT_SIGNAL = 4
+}
+type EventIteratorEvent = 'message' | 'error' | 'done';
+interface EventIteratorPayload {
+    event: EventIteratorEvent;
+    data: unknown;
+    meta?: EventMeta;
+}
+interface RequestMessageMap {
+    [MessageType.REQUEST]: Omit<StandardRequest, 'signal'>;
+    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
+    [MessageType.ABORT_SIGNAL]: void;
+}
+interface ResponseMessageMap {
+    [MessageType.RESPONSE]: StandardResponse;
+    [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?
@@ -15,6 +104,15 @@ interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     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
@@ -33,46 +131,14 @@ declare class ClientPeer {
      */
     private readonly cleanupFns;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_RequestMessageSendFn);
     get length(): number;
     open(id: string): AbortController;
     request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: EncodedMessage): Promise<void>;
+    message([id, type, payload]: DecodedResponseMessage): Promise<void>;
     close(options?: AsyncIdQueueCloseOptions$1): void;
 }
 
-declare enum MessageType {
-    REQUEST = 1,
-    RESPONSE = 2,
-    EVENT_ITERATOR = 3,
-    ABORT_SIGNAL = 4
-}
-type EventIteratorEvent = 'message' | 'error' | 'done';
-interface EventIteratorPayload {
-    event: EventIteratorEvent;
-    data: unknown;
-    meta?: EventMeta;
-}
-interface RequestMessageMap {
-    [MessageType.REQUEST]: Omit<StandardRequest, 'signal'>;
-    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
-    [MessageType.ABORT_SIGNAL]: void;
-}
-interface ResponseMessageMap {
-    [MessageType.RESPONSE]: StandardResponse;
-    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
-    [MessageType.ABORT_SIGNAL]: void;
-}
-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>;
-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 AsyncIdQueueCloseOptions {
     id?: string;
     reason?: unknown;
@@ -97,6 +163,9 @@ 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>;
 }
@@ -109,6 +178,21 @@ 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
      */
@@ -118,13 +202,13 @@ declare class ServerPeer {
      */
     private readonly clientControllers;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_ResponseMessageSendFn);
     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]>;
+    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.
      */
@@ -132,5 +216,5 @@ declare class ServerPeer {
     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, ServerPeerHandleRequestFn, ToEventIteratorOptions };
+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,11 +1,100 @@
 import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, SetSpanErrorOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClass } from '@orpc/shared';
-import { StandardRequest, StandardResponse, EventMeta } from '@orpc/standard-server';
+import { StandardRequest, EventMeta, StandardResponse, StandardBody, StandardHeaders } from '@orpc/standard-server';
 
 type EncodedMessage = string | ArrayBufferLike | Uint8Array;
 interface EncodedMessageSendFn {
     (message: EncodedMessage): Promisable<void>;
 }
 
+declare enum MessageType {
+    REQUEST = 1,
+    RESPONSE = 2,
+    EVENT_ITERATOR = 3,
+    ABORT_SIGNAL = 4
+}
+type EventIteratorEvent = 'message' | 'error' | 'done';
+interface EventIteratorPayload {
+    event: EventIteratorEvent;
+    data: unknown;
+    meta?: EventMeta;
+}
+interface RequestMessageMap {
+    [MessageType.REQUEST]: Omit<StandardRequest, 'signal'>;
+    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
+    [MessageType.ABORT_SIGNAL]: void;
+}
+interface ResponseMessageMap {
+    [MessageType.RESPONSE]: StandardResponse;
+    [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?
@@ -15,6 +104,15 @@ interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
     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
@@ -33,46 +131,14 @@ declare class ClientPeer {
      */
     private readonly cleanupFns;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_RequestMessageSendFn);
     get length(): number;
     open(id: string): AbortController;
     request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: EncodedMessage): Promise<void>;
+    message([id, type, payload]: DecodedResponseMessage): Promise<void>;
     close(options?: AsyncIdQueueCloseOptions$1): void;
 }
 
-declare enum MessageType {
-    REQUEST = 1,
-    RESPONSE = 2,
-    EVENT_ITERATOR = 3,
-    ABORT_SIGNAL = 4
-}
-type EventIteratorEvent = 'message' | 'error' | 'done';
-interface EventIteratorPayload {
-    event: EventIteratorEvent;
-    data: unknown;
-    meta?: EventMeta;
-}
-interface RequestMessageMap {
-    [MessageType.REQUEST]: Omit<StandardRequest, 'signal'>;
-    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
-    [MessageType.ABORT_SIGNAL]: void;
-}
-interface ResponseMessageMap {
-    [MessageType.RESPONSE]: StandardResponse;
-    [MessageType.EVENT_ITERATOR]: EventIteratorPayload;
-    [MessageType.ABORT_SIGNAL]: void;
-}
-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>;
-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 AsyncIdQueueCloseOptions {
     id?: string;
     reason?: unknown;
@@ -97,6 +163,9 @@ 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>;
 }
@@ -109,6 +178,21 @@ 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
      */
@@ -118,13 +202,13 @@ declare class ServerPeer {
      */
     private readonly clientControllers;
     private readonly send;
-    constructor(send: EncodedMessageSendFn);
+    constructor(send: experimental_ResponseMessageSendFn);
     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]>;
+    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.
      */
@@ -132,5 +216,5 @@ declare class ServerPeer {
     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, ServerPeerHandleRequestFn, ToEventIteratorOptions };
+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, 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 };
@@ -294,6 +343,29 @@ function resolveEventIterator(iterator, callback) {
 }
 
 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
@@ -313,11 +385,12 @@ class ClientPeer {
   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 + this.cleanupFns.size) / 4;
@@ -347,14 +420,14 @@ class ClientPeer {
             otelConfig.propagation.inject(otelConfig.context.active(), headers);
             request = { ...request, headers };
           }
-          await this.send(id, MessageType.REQUEST, request);
+          await this.send([id, MessageType.REQUEST, request]);
           if (signal?.aborted) {
-            await this.send(id, MessageType.ABORT_SIGNAL, void 0);
+            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);
+            await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
             this.close({ id, reason: signal.reason });
           }, { once: true });
           this.cleanupFns.get(id)?.push(() => {
@@ -366,7 +439,7 @@ class ClientPeer {
               if (serverController.signal.aborted) {
                 return "abort";
               }
-              await this.send(id, MessageType.EVENT_ITERATOR, payload);
+              await this.send([id, MessageType.EVENT_ITERATOR, payload]);
               return "next";
             });
           }
@@ -378,7 +451,7 @@ class ClientPeer {
               async (reason) => {
                 try {
                   if (reason !== "next") {
-                    await this.send(id, MessageType.ABORT_SIGNAL, void 0);
+                    await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
                   }
                 } finally {
                   this.close({ id });
@@ -400,8 +473,7 @@ class ClientPeer {
       }
     );
   }
-  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;
@@ -435,6 +507,35 @@ 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
    */
@@ -445,11 +546,12 @@ class ServerPeer {
   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;
@@ -463,8 +565,7 @@ class ServerPeer {
   /**
    * @todo This method will return Promise<void> in the next major version.
    */
-  async message(raw, handleRequest) {
-    const [id, type, payload] = await decodeRequestMessage(raw);
+  async message([id, type, payload], handleRequest) {
     if (type === MessageType.ABORT_SIGNAL) {
       this.close({ id, reason: new AbortError("Client aborted the request") });
       return [id, void 0];
@@ -485,7 +586,7 @@ class ServerPeer {
         id,
         async (reason) => {
           if (reason !== "next") {
-            await this.send(id, MessageType.ABORT_SIGNAL, void 0);
+            await this.send([id, MessageType.ABORT_SIGNAL, void 0]);
           }
         },
         { signal }
@@ -529,7 +630,7 @@ class ServerPeer {
       return;
     }
     try {
-      await this.send(id, MessageType.RESPONSE, response);
+      await this.send([id, MessageType.RESPONSE, response]);
       if (!signal.aborted && isAsyncIteratorObject(response.body)) {
         if (response.body instanceof HibernationEventIterator) {
           response.body.hibernationCallback?.(id);
@@ -539,7 +640,7 @@ class ServerPeer {
             if (signal.aborted) {
               return "abort";
             }
-            await this.send(id, MessageType.EVENT_ITERATOR, payload);
+            await this.send([id, MessageType.EVENT_ITERATOR, payload]);
             return "next";
           });
         }
@@ -566,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.f7af1c4",
+  "version": "0.0.0-next.f8cfaa5",
   "license": "MIT",
   "homepage": "https://unnoq.com",
   "repository": {
@@ -23,8 +23,8 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.f7af1c4",
-    "@orpc/standard-server": "0.0.0-next.f7af1c4"
+    "@orpc/shared": "0.0.0-next.f8cfaa5",
+    "@orpc/standard-server": "0.0.0-next.f8cfaa5"
   },
   "scripts": {
     "build": "unbuild",