@orpc/standard-server-peer 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/standard-server-peer">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fstandard-server-peer?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
+
+---
+
+## Highlights
+
+- **🔗 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), 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.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 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
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@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/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
+- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
+
+## `@orpc/standard-server-peer`
+
+Provides a standard interface for oRPC server adapters to interact with connected peers across various transports (e.g., WebSocket, IPC).
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,91 @@
+import { EventMeta, StandardRequest, StandardResponse, StandardHeaders } from '@orpc/standard-server';
+import { CreateAsyncIteratorObjectOptions } from '@orpc/shared';
+
+declare enum MessageType {
+    REQUEST = 1,
+    RESPONSE = 2,
+    EVENT_ITERATOR = 3,
+    ABORT_SIGNAL = 4
+}
+type RawMessage = string | ArrayBufferLike | Blob;
+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: number, type: K, payload: TMap[K]];
+}[keyof TMap];
+type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
+type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
+declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<RawMessage>;
+declare function decodeRequestMessage(raw: RawMessage): Promise<DecodedRequestMessage>;
+declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<RawMessage>;
+declare function decodeResponseMessage(raw: RawMessage): Promise<DecodedResponseMessage>;
+declare function isEventIteratorHeaders(headers: StandardHeaders): boolean;
+
+declare class ClientPeer {
+    private readonly idGenerator;
+    private readonly clientRequestQueue;
+    private readonly clientEventIteratorQueue;
+    private readonly clientSignalQueue;
+    private readonly serverResponseQueue;
+    private readonly serverEventIterator;
+    private readonly serverSignalQueue;
+    constructor(send: (message: RawMessage) => void);
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: RawMessage): Promise<void>;
+    open(id: number): void;
+    close(id?: number, reason?: any): void;
+}
+
+declare abstract class AsyncIdQueue<T> {
+    private readonly openIds;
+    abstract push(id: number, item: T): void;
+    open(id: number): void;
+    close(id: number): void;
+    closeAll(): void;
+    isOpen(id: number): boolean;
+    assertOpen(id: number): void;
+}
+declare class PullableAsyncIdQueue<T> extends AsyncIdQueue<T> {
+    private readonly items;
+    private readonly pendingPulls;
+    push(id: number, item: T): void;
+    pull(id: number): Promise<T>;
+    close(id: number, reason?: any): void;
+}
+
+declare function toEventIterator(queue: PullableAsyncIdQueue<EventIteratorPayload>, id: number, options?: CreateAsyncIteratorObjectOptions): AsyncGenerator;
+declare function sendEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, iterator: AsyncIterator<any>, options?: {
+    onComplete?: () => void;
+}): Promise<void>;
+
+declare class ServerPeer {
+    private readonly serverResponseQueue;
+    private readonly serverEventIteratorQueue;
+    private readonly serverSignalQueue;
+    private readonly clientEventIteratorQueue;
+    private readonly clientSignalQueue;
+    constructor(send: (message: RawMessage) => void);
+    message(raw: RawMessage): Promise<[id: number, StandardRequest | undefined]>;
+    response(id: number, response: StandardResponse): Promise<void>;
+    open(id: number): void;
+    close(id?: number, reason?: any): void;
+}
+
+declare function toAbortSignal(queue: PullableAsyncIdQueue<void>, id: number): AbortSignal;
+
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };
+export type { DecodedRequestMessage, DecodedResponseMessage, EventIteratorEvent, EventIteratorPayload, RawMessage, RequestMessageMap, ResponseMessageMap };

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import { EventMeta, StandardRequest, StandardResponse, StandardHeaders } from '@orpc/standard-server';
+import { CreateAsyncIteratorObjectOptions } from '@orpc/shared';
+
+declare enum MessageType {
+    REQUEST = 1,
+    RESPONSE = 2,
+    EVENT_ITERATOR = 3,
+    ABORT_SIGNAL = 4
+}
+type RawMessage = string | ArrayBufferLike | Blob;
+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: number, type: K, payload: TMap[K]];
+}[keyof TMap];
+type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
+type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
+declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<RawMessage>;
+declare function decodeRequestMessage(raw: RawMessage): Promise<DecodedRequestMessage>;
+declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<RawMessage>;
+declare function decodeResponseMessage(raw: RawMessage): Promise<DecodedResponseMessage>;
+declare function isEventIteratorHeaders(headers: StandardHeaders): boolean;
+
+declare class ClientPeer {
+    private readonly idGenerator;
+    private readonly clientRequestQueue;
+    private readonly clientEventIteratorQueue;
+    private readonly clientSignalQueue;
+    private readonly serverResponseQueue;
+    private readonly serverEventIterator;
+    private readonly serverSignalQueue;
+    constructor(send: (message: RawMessage) => void);
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: RawMessage): Promise<void>;
+    open(id: number): void;
+    close(id?: number, reason?: any): void;
+}
+
+declare abstract class AsyncIdQueue<T> {
+    private readonly openIds;
+    abstract push(id: number, item: T): void;
+    open(id: number): void;
+    close(id: number): void;
+    closeAll(): void;
+    isOpen(id: number): boolean;
+    assertOpen(id: number): void;
+}
+declare class PullableAsyncIdQueue<T> extends AsyncIdQueue<T> {
+    private readonly items;
+    private readonly pendingPulls;
+    push(id: number, item: T): void;
+    pull(id: number): Promise<T>;
+    close(id: number, reason?: any): void;
+}
+
+declare function toEventIterator(queue: PullableAsyncIdQueue<EventIteratorPayload>, id: number, options?: CreateAsyncIteratorObjectOptions): AsyncGenerator;
+declare function sendEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, iterator: AsyncIterator<any>, options?: {
+    onComplete?: () => void;
+}): Promise<void>;
+
+declare class ServerPeer {
+    private readonly serverResponseQueue;
+    private readonly serverEventIteratorQueue;
+    private readonly serverSignalQueue;
+    private readonly clientEventIteratorQueue;
+    private readonly clientSignalQueue;
+    constructor(send: (message: RawMessage) => void);
+    message(raw: RawMessage): Promise<[id: number, StandardRequest | undefined]>;
+    response(id: number, response: StandardResponse): Promise<void>;
+    open(id: number): void;
+    close(id?: number, reason?: any): void;
+}
+
+declare function toAbortSignal(queue: PullableAsyncIdQueue<void>, id: number): AbortSignal;
+
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };
+export type { DecodedRequestMessage, DecodedResponseMessage, EventIteratorEvent, EventIteratorPayload, RawMessage, RequestMessageMap, ResponseMessageMap };

package/dist/index.mjs

@@ -0,0 +1,571 @@
+import { toArray, stringifyJSON, isAsyncIteratorObject, createAsyncIteratorObject, isTypescriptObject, SequentialIdGenerator, PullableAsyncIdQueue as PullableAsyncIdQueue$1, ConsumableAsyncIdQueue as ConsumableAsyncIdQueue$1 } from '@orpc/shared';
+import { getFilenameFromContentDisposition, generateContentDisposition, withEventMeta, ErrorEvent, getEventMeta } from '@orpc/standard-server';
+
+class AsyncIdQueue {
+  openIds = /* @__PURE__ */ new Set();
+  open(id) {
+    this.openIds.add(id);
+  }
+  close(id) {
+    this.openIds.delete(id);
+  }
+  closeAll() {
+    this.openIds.forEach((id) => this.close(id));
+  }
+  isOpen(id) {
+    return this.openIds.has(id);
+  }
+  assertOpen(id) {
+    if (!this.isOpen(id)) {
+      throw new Error(`[AsyncIdQueue] Cannot access queue[${id}] because it is not open.`);
+    }
+  }
+}
+class PullableAsyncIdQueue extends AsyncIdQueue {
+  items = /* @__PURE__ */ new Map();
+  pendingPulls = /* @__PURE__ */ new Map();
+  push(id, item) {
+    this.assertOpen(id);
+    const pending = this.pendingPulls.get(id);
+    if (pending?.length) {
+      pending.shift()[0](item);
+      if (pending.length === 0) {
+        this.pendingPulls.delete(id);
+      }
+    } else {
+      const items = this.items.get(id);
+      if (items) {
+        items.push(item);
+      } else {
+        this.items.set(id, [item]);
+      }
+    }
+  }
+  async pull(id) {
+    this.assertOpen(id);
+    const items = this.items.get(id);
+    if (items?.length) {
+      const item = items.shift();
+      if (items.length === 0) {
+        this.items.delete(id);
+      }
+      return item;
+    }
+    return new Promise((resolve, reject) => {
+      const waitingPulls = this.pendingPulls.get(id);
+      const pending = [resolve, reject];
+      if (waitingPulls) {
+        waitingPulls.push(pending);
+      } else {
+        this.pendingPulls.set(id, [pending]);
+      }
+    });
+  }
+  close(id, reason) {
+    const pendingPulls = this.pendingPulls.get(id);
+    if (pendingPulls) {
+      pendingPulls.forEach(([, reject]) => {
+        reject(reason ?? new Error(`[PullableAsyncIdQueue] Queue[${id}] was closed while waiting for pulling.`));
+      });
+      this.pendingPulls.delete(id);
+    }
+    super.close(id);
+    this.items.delete(id);
+  }
+}
+class ConsumableAsyncIdQueue extends AsyncIdQueue {
+  constructor(consume) {
+    super();
+    this.consume = consume;
+  }
+  push(id, item) {
+    this.assertOpen(id);
+    this.consume(id, item);
+  }
+}
+
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2[MessageType2["REQUEST"] = 1] = "REQUEST";
+  MessageType2[MessageType2["RESPONSE"] = 2] = "RESPONSE";
+  MessageType2[MessageType2["EVENT_ITERATOR"] = 3] = "EVENT_ITERATOR";
+  MessageType2[MessageType2["ABORT_SIGNAL"] = 4] = "ABORT_SIGNAL";
+  return MessageType2;
+})(MessageType || {});
+async function encodeRequestMessage(id, type, payload) {
+  if (type === 3 /* EVENT_ITERATOR */) {
+    const eventPayload = payload;
+    const serializedPayload2 = {
+      e: eventPayload.event,
+      d: eventPayload.data,
+      m: eventPayload.meta
+    };
+    return encodeRawMessage({ i: id, t: type, p: serializedPayload2 });
+  }
+  if (type === 4 /* ABORT_SIGNAL */) {
+    return encodeRawMessage({ i: id, t: type, p: payload });
+  }
+  const request = payload;
+  const { body: processedBody, headers: processedHeaders } = await prepareBodyAndHeadersForSerialization(
+    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,
+    m: request.method === "POST" ? void 0 : request.method
+  };
+  const baseMessage = {
+    i: id,
+    p: serializedPayload
+  };
+  if (processedBody instanceof Blob) {
+    return encodeRawMessage(baseMessage, processedBody);
+  }
+  return encodeRawMessage(baseMessage);
+}
+async function decodeRequestMessage(raw) {
+  const { json: message, blobData } = await decodeRawMessage(raw);
+  const id = message.i;
+  const type = message.t;
+  if (type === 3 /* EVENT_ITERATOR */) {
+    const payload2 = message.p;
+    return [id, type, { event: payload2.e, data: payload2.d, meta: payload2.m }];
+  }
+  if (type === 4 /* ABORT_SIGNAL */) {
+    return [id, type, message.p];
+  }
+  const payload = message.p;
+  const headers = payload.h ?? {};
+  let body = payload.b;
+  const contentType = toArray(headers["content-type"])[0];
+  if (blobData) {
+    const contentDisposition = toArray(headers["content-disposition"])[0];
+    if (contentDisposition === void 0 && contentType?.startsWith("multipart/form-data")) {
+      const tempRes = new Response(blobData, { headers: { "content-type": contentType } });
+      body = await tempRes.formData();
+    } else {
+      const filename = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      body = new File([blobData], filename, { type: contentType });
+    }
+  } else if (contentType?.startsWith("application/x-www-form-urlencoded") && typeof body === "string") {
+    body = new URLSearchParams(body);
+  }
+  return [id, 1 /* REQUEST */, { url: new URL(payload.u, "orpc:/"), headers, method: payload.m ?? "POST", body }];
+}
+async function encodeResponseMessage(id, type, payload) {
+  if (type === 3 /* EVENT_ITERATOR */) {
+    const eventPayload = payload;
+    const serializedPayload2 = {
+      e: eventPayload.event,
+      d: eventPayload.data,
+      m: eventPayload.meta
+    };
+    return encodeRawMessage({ i: id, t: type, p: serializedPayload2 });
+  }
+  if (type === 4 /* ABORT_SIGNAL */) {
+    return encodeRawMessage({ i: id, t: type, p: void 0 });
+  }
+  const response = payload;
+  const { body: processedBody, headers: processedHeaders } = await prepareBodyAndHeadersForSerialization(
+    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
+  };
+  const baseMessage = {
+    i: id,
+    p: serializedPayload
+  };
+  if (processedBody instanceof Blob) {
+    return encodeRawMessage(baseMessage, processedBody);
+  }
+  return encodeRawMessage(baseMessage);
+}
+async function decodeResponseMessage(raw) {
+  const { json: message, blobData } = await decodeRawMessage(raw);
+  const id = message.i;
+  const type = message.t;
+  if (type === 3 /* EVENT_ITERATOR */) {
+    const payload2 = message.p;
+    return [id, type, { event: payload2.e, data: payload2.d, meta: payload2.m }];
+  }
+  if (type === 4 /* ABORT_SIGNAL */) {
+    return [id, type, message.p];
+  }
+  const payload = message.p;
+  const headers = payload.h ?? {};
+  let body = payload.b;
+  const contentType = toArray(headers["content-type"])[0];
+  if (blobData) {
+    const contentDisposition = toArray(headers["content-disposition"])[0];
+    if (contentDisposition === void 0 && contentType?.startsWith("multipart/form-data")) {
+      const tempRes = new Response(blobData, { headers: { "content-type": contentType } });
+      body = await tempRes.formData();
+    } else {
+      const filename = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      body = new File([blobData], filename, { type: contentType });
+    }
+  } else if (contentType?.startsWith("application/x-www-form-urlencoded") && typeof body === "string") {
+    body = new URLSearchParams(body);
+  }
+  return [id, 2 /* RESPONSE */, { status: payload.s ?? 200, headers, body }];
+}
+async function prepareBodyAndHeadersForSerialization(body, originalHeaders) {
+  const headers = { ...originalHeaders };
+  const originalContentDisposition = headers["content-disposition"];
+  delete headers["content-type"];
+  delete headers["content-disposition"];
+  if (body instanceof Blob) {
+    headers["content-type"] = body.type;
+    headers["content-disposition"] = originalContentDisposition ?? generateContentDisposition(
+      body instanceof File ? body.name : "blob"
+    );
+    return { body, headers };
+  }
+  if (body instanceof FormData) {
+    const tempRes = new Response(body);
+    const formDataBlob = await tempRes.blob();
+    headers["content-type"] = tempRes.headers.get("content-type");
+    return { body: formDataBlob, headers };
+  }
+  if (body instanceof URLSearchParams) {
+    headers["content-type"] = "application/x-www-form-urlencoded";
+    return { body: body.toString(), headers };
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers["content-type"] = "text/event-stream";
+    return { body: void 0, headers };
+  }
+  return { body, headers };
+}
+function isEventIteratorHeaders(headers) {
+  return Boolean(toArray(headers["content-type"])[0]?.startsWith("text/event-stream") && headers["content-disposition"] === void 0);
+}
+const JSON_AND_BINARY_DELIMITER = 255;
+async function encodeRawMessage(data, blobData) {
+  const json = stringifyJSON(data);
+  if (blobData === void 0) {
+    return json;
+  }
+  return new Blob([
+    new TextEncoder().encode(json),
+    new Uint8Array([JSON_AND_BINARY_DELIMITER]),
+    blobData
+  ]);
+}
+async function decodeRawMessage(raw) {
+  if (typeof raw === "string") {
+    return { json: JSON.parse(raw) };
+  }
+  const buffer = new Uint8Array(raw instanceof Blob ? await raw.arrayBuffer() : raw);
+  const delimiterIndex = buffer.indexOf(JSON_AND_BINARY_DELIMITER);
+  if (delimiterIndex === -1) {
+    const jsonPart2 = new TextDecoder().decode(buffer);
+    return { json: JSON.parse(jsonPart2) };
+  }
+  const jsonPart = new TextDecoder().decode(buffer.slice(0, delimiterIndex));
+  const blobData = buffer.slice(delimiterIndex + 1);
+  return {
+    json: JSON.parse(jsonPart),
+    blobData
+  };
+}
+
+function toEventIterator(queue, id, options = {}) {
+  return createAsyncIteratorObject(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);
+        }
+        return { value: data, done: false };
+      }
+      case "error": {
+        let error = new ErrorEvent({
+          data: item.data
+        });
+        if (item.meta) {
+          error = withEventMeta(error, item.meta);
+        }
+        throw error;
+      }
+      case "done": {
+        let data = item.data;
+        if (item.meta && isTypescriptObject(data)) {
+          data = withEventMeta(data, item.meta);
+        }
+        return { value: data, done: true };
+      }
+    }
+  }, options);
+}
+async function sendEventIterator(queue, id, iterator, options = {}) {
+  let isInternal = false;
+  try {
+    while (true) {
+      isInternal = false;
+      const { value, done } = await iterator.next();
+      isInternal = true;
+      if (!queue.isOpen(id)) {
+        if (!done) {
+          isInternal = false;
+          await iterator.return?.();
+          isInternal = true;
+        }
+        return;
+      }
+      queue.push(id, {
+        event: done ? "done" : "message",
+        data: value,
+        meta: getEventMeta(value)
+      });
+      if (done) {
+        return;
+      }
+    }
+  } catch (err) {
+    let currentError = err;
+    if (isInternal) {
+      try {
+        await iterator.throw?.(currentError);
+      } catch (err2) {
+        currentError = err2;
+      }
+    }
+    if (queue.isOpen(id)) {
+      queue.push(id, {
+        meta: getEventMeta(currentError),
+        event: "error",
+        data: currentError instanceof ErrorEvent ? currentError.data : void 0
+      });
+    }
+  } finally {
+    options.onComplete?.();
+  }
+}
+
+function toAbortSignal(queue, id) {
+  const controller = new AbortController();
+  queue.pull(id).then(() => {
+    controller.abort();
+  }).catch(() => {
+  });
+  return controller.signal;
+}
+
+class ClientPeer {
+  idGenerator = new SequentialIdGenerator();
+  clientRequestQueue;
+  clientEventIteratorQueue;
+  clientSignalQueue;
+  serverResponseQueue = new PullableAsyncIdQueue();
+  serverEventIterator = new PullableAsyncIdQueue();
+  serverSignalQueue = new PullableAsyncIdQueue();
+  constructor(send) {
+    this.clientRequestQueue = new ConsumableAsyncIdQueue((id, { signal, ...request }) => {
+      encodeRequestMessage(id, MessageType.REQUEST, request).then((raw) => {
+        send(raw);
+        if (signal) {
+          if (signal.aborted) {
+            this.clientSignalQueue.push(id);
+            this.close(id, signal.reason);
+          }
+          signal.addEventListener("abort", () => {
+            this.clientSignalQueue.push(id);
+            this.close(id, signal.reason);
+          }, { once: true });
+        }
+        if (isAsyncIteratorObject(request.body)) {
+          sendEventIterator(this.clientEventIteratorQueue, id, request.body);
+          const serverSignal = toAbortSignal(this.serverSignalQueue, id);
+          serverSignal.addEventListener("abort", () => {
+            this.clientEventIteratorQueue.close(id);
+          }, { once: true });
+        }
+      }).catch((err) => {
+        this.close(id, err);
+      });
+    });
+    this.clientEventIteratorQueue = new ConsumableAsyncIdQueue((id, payload) => {
+      encodeRequestMessage(id, MessageType.EVENT_ITERATOR, payload).then(send).catch((err) => {
+        this.close(id, err);
+      });
+    });
+    this.clientSignalQueue = new ConsumableAsyncIdQueue((id, payload) => {
+      encodeRequestMessage(id, MessageType.ABORT_SIGNAL, payload).then(send).catch((err) => {
+        this.close(id, err);
+      });
+    });
+  }
+  async request(request) {
+    const signal = request.signal;
+    if (signal?.aborted) {
+      throw signal.reason;
+    }
+    const id = this.idGenerator.generate();
+    this.open(id);
+    this.clientRequestQueue.push(id, request);
+    return new Promise((resolve, reject) => {
+      this.serverResponseQueue.pull(id).then(resolve).catch(reject);
+    });
+  }
+  async message(raw) {
+    const [id, type, payload] = await decodeResponseMessage(raw);
+    if (type === MessageType.EVENT_ITERATOR) {
+      if (this.serverEventIterator.isOpen(id)) {
+        this.serverEventIterator.push(id, payload);
+      }
+      return;
+    }
+    if (type === MessageType.ABORT_SIGNAL) {
+      if (this.serverSignalQueue.isOpen(id)) {
+        this.serverSignalQueue.push(id, payload);
+      }
+      return;
+    }
+    if (isEventIteratorHeaders(payload.headers)) {
+      this.serverResponseQueue.push(id, {
+        ...payload,
+        body: toEventIterator(this.serverEventIterator, id, {
+          onComplete: (reason) => {
+            if (reason !== "next") {
+              this.clientSignalQueue.push(id);
+            }
+            this.close(id);
+          }
+        })
+      });
+    } else {
+      this.serverResponseQueue.push(id, payload);
+      this.close(id);
+    }
+  }
+  open(id) {
+    this.clientSignalQueue.open(id);
+    this.clientEventIteratorQueue.open(id);
+    this.clientRequestQueue.open(id);
+    this.serverSignalQueue.open(id);
+    this.serverEventIterator.open(id);
+    this.serverResponseQueue.open(id);
+  }
+  close(id, reason) {
+    if (id !== void 0) {
+      this.clientRequestQueue.close(id);
+      this.clientEventIteratorQueue.close(id);
+      this.clientSignalQueue.close(id);
+      this.serverResponseQueue.close(id, reason);
+      this.serverEventIterator.close(id, reason);
+      this.serverResponseQueue.close(id, reason);
+    } else {
+      this.clientRequestQueue.closeAll();
+      this.clientEventIteratorQueue.closeAll();
+      this.clientSignalQueue.closeAll();
+      this.serverResponseQueue.closeAll();
+      this.serverEventIterator.closeAll();
+      this.serverResponseQueue.closeAll();
+    }
+  }
+}
+
+class ServerPeer {
+  serverResponseQueue;
+  serverEventIteratorQueue;
+  serverSignalQueue;
+  clientEventIteratorQueue = new PullableAsyncIdQueue$1();
+  clientSignalQueue = new PullableAsyncIdQueue$1();
+  constructor(send) {
+    this.serverResponseQueue = new ConsumableAsyncIdQueue$1((id, response) => {
+      encodeResponseMessage(id, MessageType.RESPONSE, response).then(async (raw) => {
+        send(raw);
+        if (isAsyncIteratorObject(response.body)) {
+          await sendEventIterator(this.serverEventIteratorQueue, id, response.body, {
+            onComplete: () => {
+              this.close(id);
+            }
+          });
+        } else {
+          this.close(id);
+        }
+      }).catch((err) => {
+        this.close(id, err);
+      });
+    });
+    this.serverEventIteratorQueue = new ConsumableAsyncIdQueue$1((id, payload) => {
+      encodeResponseMessage(id, MessageType.EVENT_ITERATOR, payload).then(send).catch((err) => {
+        this.close(id, err);
+      });
+    });
+    this.serverSignalQueue = new ConsumableAsyncIdQueue$1((id, payload) => {
+      encodeResponseMessage(id, MessageType.ABORT_SIGNAL, payload).then(send).catch((err) => {
+        this.close(id, err);
+      });
+    });
+  }
+  async message(raw) {
+    const [id, type, payload] = await decodeRequestMessage(raw);
+    if (type === MessageType.ABORT_SIGNAL) {
+      if (this.clientSignalQueue.isOpen(id)) {
+        this.clientSignalQueue.push(id, payload);
+      }
+      return [id, void 0];
+    }
+    if (type === MessageType.EVENT_ITERATOR) {
+      if (this.clientEventIteratorQueue.isOpen(id)) {
+        this.clientEventIteratorQueue.push(id, payload);
+      }
+      return [id, void 0];
+    }
+    this.open(id);
+    const clientSignal = toAbortSignal(this.clientSignalQueue, id);
+    clientSignal.addEventListener("abort", () => {
+      this.close(id, clientSignal.reason);
+    }, { once: true });
+    const request = {
+      ...payload,
+      signal: clientSignal,
+      body: isEventIteratorHeaders(payload.headers) ? toEventIterator(this.clientEventIteratorQueue, id, {
+        onComplete: (reason) => {
+          if (reason !== "next") {
+            this.serverSignalQueue.push(id);
+          }
+        }
+      }) : payload.body
+    };
+    return [id, request];
+  }
+  async response(id, response) {
+    if (this.serverResponseQueue.isOpen(id)) {
+      this.serverResponseQueue.push(id, response);
+    }
+  }
+  open(id) {
+    this.serverSignalQueue.open(id);
+    this.serverEventIteratorQueue.open(id);
+    this.serverResponseQueue.open(id);
+    this.clientEventIteratorQueue.open(id);
+    this.clientSignalQueue.open(id);
+  }
+  close(id, reason) {
+    if (id !== void 0) {
+      this.serverResponseQueue.close(id);
+      this.serverEventIteratorQueue.close(id);
+      this.serverResponseQueue.close(id);
+      this.clientEventIteratorQueue.close(id, reason);
+      this.clientSignalQueue.close(id, reason);
+    } else {
+      this.serverResponseQueue.closeAll();
+      this.serverEventIteratorQueue.closeAll();
+      this.serverResponseQueue.closeAll();
+      this.clientEventIteratorQueue.closeAll();
+      this.clientSignalQueue.closeAll();
+    }
+  }
+}
+
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@orpc/standard-server-peer",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/standard-server-peer"
+  },
+  "keywords": [
+    "orpc"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@orpc/shared": "1.1.1",
+    "@orpc/standard-server": "1.1.1"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}