@standardserver/peer 0.0.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Standard Server
+
+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/dist/index.d.mts

@@ -0,0 +1,280 @@
+import { StandardRequest, StandardResponse } from '@standardserver/core';
+import { AsyncIdQueueCloseOptions, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
+import { EventStreamMessage } from '@standardserver/core/event-stream';
+
+/**
+ * Base interface for all peer messages.
+ *
+ * SHOULD only contain data that friendly with structure clone algorithm.
+ */
+interface PeerMessage {
+    /**
+     * Correlation ID for a single request/response lifecycle.
+     *
+     * The same ID is shared by the initial request, its response,
+     * and any related stream or event messages.
+     */
+    id: string;
+    /**
+     * Discriminator that defines the message semantics and payload shape.
+     */
+    kind: string;
+    /**
+     * Structured payload.
+     *
+     * Its shape is determined by `kind`.
+     */
+    json?: unknown;
+    /**
+     * Binary payload.
+     *
+     * Only present for message kinds that support binary transfer.
+     */
+    binary?: Uint8Array<ArrayBuffer> | Blob | undefined;
+}
+/**
+ * Starts a new request from client to server.
+ *
+ * This is always the first message in a request/response cycle.
+ */
+interface PeerRequestMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'request';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: Omit<StandardRequest, 'signal'>;
+}
+/**
+ * Sends the final response from server to client.
+ *
+ * Typically sent once per `PeerRequestMessage`, unless followed by streaming messages.
+ */
+interface PeerResponseMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'response';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: StandardResponse;
+}
+/**
+ * Indicates that a request/response/stream should be terminated.
+ *
+ * - **Client → Server**: Cancel an in-flight request or stop consuming a stream.
+ * - **Server → Client**: Signal an error or premature termination.
+ */
+interface PeerAbortMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'abort';
+    /**
+     * This message does not have a JSON payload.
+     */
+    json?: undefined;
+    /**
+     * Abort messages carry no binary payload.
+     */
+    binary?: undefined;
+}
+/**
+ * Transfers a single event from an event stream/iterator.
+ *
+ * Can flow in either direction (Client ↔ Server),
+ * depending on which side owns the event iterator.
+ *
+ * **Constraint**:
+ * Must be sent after:
+ * - `PeerRequestMessage` (client-to-server streaming), or
+ * - `PeerResponseMessage` (server-to-client streaming).
+ */
+interface PeerEventStreamMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'event-stream';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: Omit<EventStreamMessage, 'data'> & {
+        /**
+         * The event data.
+         */
+        data?: unknown;
+    };
+    /**
+     * Event-stream messages never carry binary payloads.
+     */
+    binary?: undefined;
+}
+/**
+ * Transfers a binary chunk for an octet-stream.
+ *
+ * Can flow in either direction (Client ↔ Server).
+ *
+ * **Constraint**:
+ * Must be sent after:
+ * - `PeerRequestMessage` (client-to-server streaming), or
+ * - `PeerResponseMessage` (server-to-client streaming).
+ */
+interface PeerOctetStreamMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'octet-stream';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: {
+        /**
+         * Marks the final chunk of the stream.
+         *
+         * @default false
+         */
+        close: boolean;
+    };
+    /**
+     * Binary payload.
+     *
+     * SHOULD always be present even if `json.close` is `true`.
+     */
+    binary?: Uint8Array<ArrayBuffer> | Blob | undefined;
+}
+/**
+ * Indicates that an octet-stream/event-stream should be cancelled.
+ *
+ * - **Server → Client**: Server no longer needs more octet-stream/event-stream messages.
+ */
+interface PeerStreamCancelMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'stream/cancel';
+    /**
+     * This message does not have a JSON payload.
+     */
+    json?: undefined;
+    /**
+     * This message does not have a binary payload.
+     */
+    binary?: undefined;
+}
+
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions {
+}
+declare class ClientPeer {
+    private readonly send;
+    private readonly idGenerator;
+    /**
+     * Messages waiting to be processed
+     */
+    private readonly responseMessageQueue;
+    private readonly eventStreamMessageQueue;
+    private readonly octetStreamMessageQueue;
+    /**
+     * Transmitters for event streams and octet streams
+     * Should be cancelled when needed
+     */
+    private readonly requestEventStreamTransmitters;
+    private readonly requestOctetStreamTransmitters;
+    /**
+     * Cleanup functions invoked when the request/response is completed
+     */
+    private readonly cleanupFns;
+    constructor(send: (message: PeerAbortMessage | PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage) => Promise<void>);
+    /**
+     * Use to measure resources usage
+     */
+    get size(): number;
+    /**
+     * Send a request to the server peer
+     */
+    request(request: StandardRequest): Promise<StandardResponse>;
+    /**
+     * Handle a message from server
+     */
+    message(message: PeerResponseMessage | PeerAbortMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerStreamCancelMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions): Promise<void>;
+}
+
+/**
+ * Encodes a PeerMessage into a wire-safe representation.
+ *
+ * - If no binary data is present, the message is encoded as a JSON string.
+ * - If binary data exists, the output is:
+ *   [ UTF-8 JSON bytes | separator byte | raw binary bytes ]
+ */
+declare function encodePeerMessage(message: PeerMessage): Promise<string | Uint8Array<ArrayBuffer>>;
+/**
+ * Decodes a wire-encoded PeerMessage.
+ *
+ * - String input is treated as pure JSON.
+ * - Binary input may contain only JSON bytes, or JSON followed by binary data
+ *   separated by the separator byte.
+ */
+declare function decodePeerMessage(data: string | Uint8Array<ArrayBuffer>): PeerMessage;
+
+/**
+ * Creates an AsyncIterator from a queue of peer event-stream messages.
+ * The iterator yields normal events, throws error events, and completes on done.
+ */
+declare function toEventIterator(pull: () => Promise<PeerEventStreamMessage>, cleanup: AsyncCleanupFn): AsyncIteratorClass<unknown>;
+/**
+ * Transmits events to a peer event-stream.
+ */
+declare class EventStreamTransmitter {
+    private readonly iterator;
+    private readonly messageId;
+    private readonly send;
+    private isCompleted;
+    constructor(iterator: AsyncIterator<unknown>, messageId: string, send: (message: PeerEventStreamMessage) => Promise<void>);
+    cancel(): Promise<void>;
+    transmit(): Promise<void>;
+}
+
+interface HibernationEventIteratorCallback {
+    (id: string): void;
+}
+declare class HibernationEventIterator<T, TReturn = unknown, TNext = unknown> extends AsyncIteratorClass<T, TReturn, TNext> {
+    /**
+     * In the client library, server results are typically represented by an `AsyncIteratorClass`.
+     * Since `AsyncIteratorClass` does not include a `hibernationCallback` property, this property should be optional.
+     */
+    readonly hibernationCallback?: HibernationEventIteratorCallback;
+    constructor(hibernationCallback: HibernationEventIteratorCallback);
+}
+
+interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions {
+}
+declare class ServerPeer {
+    private readonly send;
+    /**
+     * Messages waiting to be processed
+     */
+    private readonly eventStreamMessageQueue;
+    private readonly octetStreamMessageQueue;
+    private readonly eventStreamTransmitters;
+    private readonly octetStreamTransmitters;
+    /**
+     * Map of abort controllers for each request
+     */
+    private readonly controller;
+    constructor(send: (message: PeerResponseMessage | PeerAbortMessage | PeerOctetStreamMessage | PeerEventStreamMessage | PeerStreamCancelMessage) => Promise<void>);
+    /**
+     * Use for measure resources usage
+     */
+    get size(): number;
+    /**
+     * Handle a message from client
+     */
+    message(message: PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerAbortMessage, handleRequest: (request: StandardRequest) => Promise<StandardResponse>): Promise<void>;
+    close(options?: ServerPeerCloseOptions): Promise<void>;
+}
+
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };
+export type { ClientPeerCloseOptions, HibernationEventIteratorCallback, PeerAbortMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerCloseOptions };

package/dist/index.d.ts

@@ -0,0 +1,280 @@
+import { StandardRequest, StandardResponse } from '@standardserver/core';
+import { AsyncIdQueueCloseOptions, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
+import { EventStreamMessage } from '@standardserver/core/event-stream';
+
+/**
+ * Base interface for all peer messages.
+ *
+ * SHOULD only contain data that friendly with structure clone algorithm.
+ */
+interface PeerMessage {
+    /**
+     * Correlation ID for a single request/response lifecycle.
+     *
+     * The same ID is shared by the initial request, its response,
+     * and any related stream or event messages.
+     */
+    id: string;
+    /**
+     * Discriminator that defines the message semantics and payload shape.
+     */
+    kind: string;
+    /**
+     * Structured payload.
+     *
+     * Its shape is determined by `kind`.
+     */
+    json?: unknown;
+    /**
+     * Binary payload.
+     *
+     * Only present for message kinds that support binary transfer.
+     */
+    binary?: Uint8Array<ArrayBuffer> | Blob | undefined;
+}
+/**
+ * Starts a new request from client to server.
+ *
+ * This is always the first message in a request/response cycle.
+ */
+interface PeerRequestMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'request';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: Omit<StandardRequest, 'signal'>;
+}
+/**
+ * Sends the final response from server to client.
+ *
+ * Typically sent once per `PeerRequestMessage`, unless followed by streaming messages.
+ */
+interface PeerResponseMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'response';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: StandardResponse;
+}
+/**
+ * Indicates that a request/response/stream should be terminated.
+ *
+ * - **Client → Server**: Cancel an in-flight request or stop consuming a stream.
+ * - **Server → Client**: Signal an error or premature termination.
+ */
+interface PeerAbortMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'abort';
+    /**
+     * This message does not have a JSON payload.
+     */
+    json?: undefined;
+    /**
+     * Abort messages carry no binary payload.
+     */
+    binary?: undefined;
+}
+/**
+ * Transfers a single event from an event stream/iterator.
+ *
+ * Can flow in either direction (Client ↔ Server),
+ * depending on which side owns the event iterator.
+ *
+ * **Constraint**:
+ * Must be sent after:
+ * - `PeerRequestMessage` (client-to-server streaming), or
+ * - `PeerResponseMessage` (server-to-client streaming).
+ */
+interface PeerEventStreamMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'event-stream';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: Omit<EventStreamMessage, 'data'> & {
+        /**
+         * The event data.
+         */
+        data?: unknown;
+    };
+    /**
+     * Event-stream messages never carry binary payloads.
+     */
+    binary?: undefined;
+}
+/**
+ * Transfers a binary chunk for an octet-stream.
+ *
+ * Can flow in either direction (Client ↔ Server).
+ *
+ * **Constraint**:
+ * Must be sent after:
+ * - `PeerRequestMessage` (client-to-server streaming), or
+ * - `PeerResponseMessage` (server-to-client streaming).
+ */
+interface PeerOctetStreamMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'octet-stream';
+    /**
+     * The actual content of the message. The structure depends on the `kind`.
+     */
+    json: {
+        /**
+         * Marks the final chunk of the stream.
+         *
+         * @default false
+         */
+        close: boolean;
+    };
+    /**
+     * Binary payload.
+     *
+     * SHOULD always be present even if `json.close` is `true`.
+     */
+    binary?: Uint8Array<ArrayBuffer> | Blob | undefined;
+}
+/**
+ * Indicates that an octet-stream/event-stream should be cancelled.
+ *
+ * - **Server → Client**: Server no longer needs more octet-stream/event-stream messages.
+ */
+interface PeerStreamCancelMessage extends PeerMessage {
+    /**
+     * The kind of the message.
+     */
+    kind: 'stream/cancel';
+    /**
+     * This message does not have a JSON payload.
+     */
+    json?: undefined;
+    /**
+     * This message does not have a binary payload.
+     */
+    binary?: undefined;
+}
+
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions {
+}
+declare class ClientPeer {
+    private readonly send;
+    private readonly idGenerator;
+    /**
+     * Messages waiting to be processed
+     */
+    private readonly responseMessageQueue;
+    private readonly eventStreamMessageQueue;
+    private readonly octetStreamMessageQueue;
+    /**
+     * Transmitters for event streams and octet streams
+     * Should be cancelled when needed
+     */
+    private readonly requestEventStreamTransmitters;
+    private readonly requestOctetStreamTransmitters;
+    /**
+     * Cleanup functions invoked when the request/response is completed
+     */
+    private readonly cleanupFns;
+    constructor(send: (message: PeerAbortMessage | PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage) => Promise<void>);
+    /**
+     * Use to measure resources usage
+     */
+    get size(): number;
+    /**
+     * Send a request to the server peer
+     */
+    request(request: StandardRequest): Promise<StandardResponse>;
+    /**
+     * Handle a message from server
+     */
+    message(message: PeerResponseMessage | PeerAbortMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerStreamCancelMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions): Promise<void>;
+}
+
+/**
+ * Encodes a PeerMessage into a wire-safe representation.
+ *
+ * - If no binary data is present, the message is encoded as a JSON string.
+ * - If binary data exists, the output is:
+ *   [ UTF-8 JSON bytes | separator byte | raw binary bytes ]
+ */
+declare function encodePeerMessage(message: PeerMessage): Promise<string | Uint8Array<ArrayBuffer>>;
+/**
+ * Decodes a wire-encoded PeerMessage.
+ *
+ * - String input is treated as pure JSON.
+ * - Binary input may contain only JSON bytes, or JSON followed by binary data
+ *   separated by the separator byte.
+ */
+declare function decodePeerMessage(data: string | Uint8Array<ArrayBuffer>): PeerMessage;
+
+/**
+ * Creates an AsyncIterator from a queue of peer event-stream messages.
+ * The iterator yields normal events, throws error events, and completes on done.
+ */
+declare function toEventIterator(pull: () => Promise<PeerEventStreamMessage>, cleanup: AsyncCleanupFn): AsyncIteratorClass<unknown>;
+/**
+ * Transmits events to a peer event-stream.
+ */
+declare class EventStreamTransmitter {
+    private readonly iterator;
+    private readonly messageId;
+    private readonly send;
+    private isCompleted;
+    constructor(iterator: AsyncIterator<unknown>, messageId: string, send: (message: PeerEventStreamMessage) => Promise<void>);
+    cancel(): Promise<void>;
+    transmit(): Promise<void>;
+}
+
+interface HibernationEventIteratorCallback {
+    (id: string): void;
+}
+declare class HibernationEventIterator<T, TReturn = unknown, TNext = unknown> extends AsyncIteratorClass<T, TReturn, TNext> {
+    /**
+     * In the client library, server results are typically represented by an `AsyncIteratorClass`.
+     * Since `AsyncIteratorClass` does not include a `hibernationCallback` property, this property should be optional.
+     */
+    readonly hibernationCallback?: HibernationEventIteratorCallback;
+    constructor(hibernationCallback: HibernationEventIteratorCallback);
+}
+
+interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions {
+}
+declare class ServerPeer {
+    private readonly send;
+    /**
+     * Messages waiting to be processed
+     */
+    private readonly eventStreamMessageQueue;
+    private readonly octetStreamMessageQueue;
+    private readonly eventStreamTransmitters;
+    private readonly octetStreamTransmitters;
+    /**
+     * Map of abort controllers for each request
+     */
+    private readonly controller;
+    constructor(send: (message: PeerResponseMessage | PeerAbortMessage | PeerOctetStreamMessage | PeerEventStreamMessage | PeerStreamCancelMessage) => Promise<void>);
+    /**
+     * Use for measure resources usage
+     */
+    get size(): number;
+    /**
+     * Handle a message from client
+     */
+    message(message: PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerAbortMessage, handleRequest: (request: StandardRequest) => Promise<StandardResponse>): Promise<void>;
+    close(options?: ServerPeerCloseOptions): Promise<void>;
+}
+
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };
+export type { ClientPeerCloseOptions, HibernationEventIteratorCallback, PeerAbortMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerCloseOptions };

package/dist/index.mjs

@@ -0,0 +1,602 @@
+import { flattenStandardHeader, getFilenameFromContentDisposition, generateContentDisposition } from '@standardserver/core';
+import { AsyncIteratorClass, isTypescriptObject, SequentialIdGenerator, AsyncIdQueue, isAsyncIteratorObject, AbortError, stringifyJSON } from '@standardserver/shared';
+import { withEventIteratorEventMeta, EventIteratorErrorEvent, resolveEventIteratorEvent } from '@standardserver/core/event-stream';
+
+function toEventIterator(pull, cleanup) {
+  return new AsyncIteratorClass(async () => {
+    while (true) {
+      const { json } = await pull();
+      switch (json.event) {
+        case "message": {
+          let data = json.data;
+          if (isTypescriptObject(data)) {
+            data = withEventIteratorEventMeta(data, json);
+          }
+          return { value: data, done: false };
+        }
+        case "error": {
+          throw withEventIteratorEventMeta(
+            new EventIteratorErrorEvent(json.data),
+            json
+          );
+        }
+        case "close": {
+          let data = json.data;
+          if (isTypescriptObject(data)) {
+            data = withEventIteratorEventMeta(data, json);
+          }
+          return { value: data, done: true };
+        }
+      }
+    }
+  }, cleanup);
+}
+class EventStreamTransmitter {
+  constructor(iterator, messageId, send) {
+    this.iterator = iterator;
+    this.messageId = messageId;
+    this.send = send;
+  }
+  isCompleted = false;
+  async cancel() {
+    if (!this.isCompleted) {
+      this.isCompleted = true;
+      await this.iterator.return?.();
+    }
+  }
+  async transmit() {
+    while (true) {
+      let json;
+      try {
+        const item = await this.iterator.next();
+        if (this.isCompleted) {
+          return;
+        }
+        if (item.done) {
+          this.isCompleted = true;
+        }
+        const [data, meta] = resolveEventIteratorEvent(item.value);
+        json = { ...meta, event: item.done ? "close" : "message", data };
+      } catch (err) {
+        if (err instanceof EventIteratorErrorEvent) {
+          if (this.isCompleted) {
+            return;
+          }
+          this.isCompleted = true;
+          const [resolvedError, meta] = resolveEventIteratorEvent(err);
+          json = { ...meta, event: "error", data: resolvedError.data };
+        } else {
+          this.isCompleted = true;
+          throw err;
+        }
+      }
+      await this.send({
+        json,
+        kind: "event-stream",
+        id: this.messageId
+      });
+      if (this.isCompleted) {
+        return;
+      }
+    }
+  }
+}
+
+function toOctetStream(pull, cleanup) {
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { json, binary } = await pull();
+        if (binary) {
+          controller.enqueue(binary instanceof Uint8Array ? binary : new Uint8Array(await binary.arrayBuffer()));
+        }
+        if (json.close) {
+          await cleanup(true);
+          controller.close();
+        }
+      } catch (err) {
+        await cleanup(true);
+        controller.error(err);
+      }
+    },
+    async cancel() {
+      await cleanup(false);
+    }
+  });
+}
+class OctetStreamTransmitter {
+  constructor(stream, messageId, send) {
+    this.messageId = messageId;
+    this.send = send;
+    this.reader = stream.getReader();
+  }
+  isCompleted = false;
+  reader;
+  async cancel() {
+    if (!this.isCompleted) {
+      this.isCompleted = true;
+      await this.reader.cancel();
+    }
+  }
+  async transmit() {
+    while (true) {
+      const { done, value } = await this.reader.read();
+      if (!this.isCompleted) {
+        try {
+          await this.send({
+            json: { close: done },
+            binary: value,
+            kind: "octet-stream",
+            id: this.messageId
+          });
+        } catch (err) {
+          await this.cancel();
+          throw err;
+        }
+      }
+      if (done) {
+        this.isCompleted = true;
+        break;
+      }
+    }
+  }
+}
+
+async function toStandardBody(message, eventStreamMessageQueue, octetStreamMessageQueue, cleanup) {
+  const bodyHint = flattenStandardHeader(message.json.headers["standard-server"]);
+  if (bodyHint === "event-stream") {
+    return toEventIterator(
+      () => eventStreamMessageQueue.pull(message.id),
+      cleanup
+    );
+  }
+  if (bodyHint === "octet-stream") {
+    return toOctetStream(
+      () => octetStreamMessageQueue.pull(message.id),
+      cleanup
+    );
+  }
+  try {
+    if (bodyHint === "file") {
+      const contentDisposition = flattenStandardHeader(message.json.headers["content-disposition"]);
+      const filename = contentDisposition !== void 0 ? getFilenameFromContentDisposition(contentDisposition) : "undefined";
+      return new File(message.binary ? [message.binary] : [], filename ?? "blob", {
+        type: flattenStandardHeader(message.json.headers["content-type"]) ?? "application/octet-stream"
+      });
+    }
+    if (bodyHint === "form-data") {
+      const res = new Response(message.binary, {
+        headers: {
+          "content-type": flattenStandardHeader(message.json.headers["content-type"]) ?? "multipart/form-data"
+        }
+      });
+      const fromData = await res.formData();
+      return fromData;
+    }
+    if (bodyHint === "url-search-params" && typeof message.json.body === "string") {
+      return new URLSearchParams(message.json.body);
+    }
+    return message.json.body;
+  } finally {
+    await cleanup(true);
+  }
+}
+
+class ClientPeer {
+  constructor(send) {
+    this.send = send;
+  }
+  idGenerator = new SequentialIdGenerator();
+  /**
+   * Messages waiting to be processed
+   */
+  responseMessageQueue = new AsyncIdQueue();
+  eventStreamMessageQueue = new AsyncIdQueue();
+  octetStreamMessageQueue = new AsyncIdQueue();
+  /**
+   * Transmitters for event streams and octet streams
+   * Should be cancelled when needed
+   */
+  requestEventStreamTransmitters = /* @__PURE__ */ new Map();
+  requestOctetStreamTransmitters = /* @__PURE__ */ new Map();
+  /**
+   * Cleanup functions invoked when the request/response is completed
+   */
+  cleanupFns = /* @__PURE__ */ new Map();
+  /**
+   * Use to measure resources usage
+   */
+  get size() {
+    return this.responseMessageQueue.length + this.eventStreamMessageQueue.length + this.octetStreamMessageQueue.length + this.requestEventStreamTransmitters.size + this.requestOctetStreamTransmitters.size + this.cleanupFns.size;
+  }
+  /**
+   * Send a request to the server peer
+   */
+  async request(request) {
+    const signal = request.signal;
+    signal?.throwIfAborted();
+    const id = this.idGenerator.generate();
+    this.eventStreamMessageQueue.open(id);
+    this.octetStreamMessageQueue.open(id);
+    this.responseMessageQueue.open(id);
+    let abortListener;
+    signal?.addEventListener("abort", abortListener = async () => {
+      await Promise.all([
+        /**
+         * Let server know request was aborted
+         *
+         * We don't need to check if is there any abort message already sent
+         * since this listener is removed when the request is closed.
+         */
+        this.send({ id, kind: "abort" }),
+        this.close({ id, reason: signal.reason })
+      ]);
+    });
+    const cleanupFns = [
+      /**
+       * Make sure to remove the abort listener when the request/response is closed.
+       * Since a signal can be reused for multiple requests, if each request
+       * adds listeners without removing them, it can lead to excessive memory usage
+       * until the signal is garbage collected.
+       */
+      () => {
+        signal?.removeEventListener("abort", abortListener);
+      }
+    ];
+    this.cleanupFns.set(id, cleanupFns);
+    try {
+      const requestMessage = {
+        id,
+        kind: "request",
+        json: {
+          ...{ ...request, signal: void 0 },
+          // clone and remove signal from request
+          headers: { ...request.headers }
+          // clone headers
+        }
+      };
+      if (request.body instanceof ReadableStream) {
+        requestMessage.json.body = void 0;
+        requestMessage.json.headers["standard-server"] = "octet-stream";
+      } else if (isAsyncIteratorObject(request.body)) {
+        requestMessage.json.body = void 0;
+        requestMessage.json.headers["standard-server"] = "event-stream";
+      } else if (request.body instanceof FormData) {
+        const res = new Response(request.body);
+        requestMessage.binary = await res.blob();
+        requestMessage.json.body = void 0;
+        requestMessage.json.headers["standard-server"] = "form-data";
+        requestMessage.json.headers["content-type"] = res.headers.get("content-type") ?? void 0;
+      } else if (request.body instanceof Blob) {
+        requestMessage.binary = request.body;
+        requestMessage.json.body = void 0;
+        requestMessage.json.headers["standard-server"] = "file";
+        requestMessage.json.headers["content-disposition"] = generateContentDisposition(request.body instanceof File ? request.body.name : "blob");
+        requestMessage.json.headers["content-type"] = request.body.type;
+      } else if (request.body instanceof URLSearchParams) {
+        requestMessage.json.body = request.body.toString();
+        requestMessage.json.headers["standard-server"] = "url-search-params";
+      }
+      signal?.throwIfAborted();
+      await this.send(requestMessage);
+      signal?.throwIfAborted();
+      if (isAsyncIteratorObject(request.body)) {
+        const transmitter = new EventStreamTransmitter(request.body, id, this.send);
+        this.requestEventStreamTransmitters.set(id, transmitter);
+        void transmitter.transmit().catch(async (reason) => {
+          await Promise.all([
+            /**
+             * We don't need to send abort message if transmitter was cancelled
+             * or request was aborted
+             */
+            this.requestEventStreamTransmitters.has(id) ? this.send({ id, kind: "abort" }) : void 0,
+            this.close({ id, reason })
+          ]);
+        });
+      } else if (request.body instanceof ReadableStream) {
+        const transmitter = new OctetStreamTransmitter(request.body, id, this.send);
+        this.requestOctetStreamTransmitters.set(id, transmitter);
+        void transmitter.transmit().catch(async (reason) => {
+          await Promise.all([
+            /**
+             * We don't need to send abort message if transmitter was cancelled
+             * or request was aborted
+             */
+            this.requestOctetStreamTransmitters.has(id) ? this.send({ id, kind: "abort" }) : void 0,
+            this.close({ id, reason })
+          ]);
+        });
+      }
+      const peerResponseMessage = await this.responseMessageQueue.pull(id);
+      return {
+        ...peerResponseMessage.json,
+        body: await toStandardBody(
+          peerResponseMessage,
+          this.eventStreamMessageQueue,
+          this.octetStreamMessageQueue,
+          async (isCompleted) => {
+            await Promise.all([
+              /**
+               * We don't need to send abort message if completed
+               * or request was aborted
+               */
+              !isCompleted && (this.eventStreamMessageQueue.isOpen(id) || this.octetStreamMessageQueue.isOpen(id)) ? this.send({ id, kind: "abort" }) : void 0,
+              this.close({ id })
+            ]);
+          }
+        )
+      };
+    } catch (reason) {
+      await this.close({ id, reason });
+      throw reason;
+    }
+  }
+  /**
+   * Handle a message from server
+   */
+  async message(message) {
+    if (message.kind === "stream/cancel") {
+      const promise = Promise.all([
+        this.requestEventStreamTransmitters.get(message.id)?.cancel(),
+        this.requestOctetStreamTransmitters.get(message.id)?.cancel()
+      ]);
+      this.requestEventStreamTransmitters.delete(message.id);
+      this.requestOctetStreamTransmitters.delete(message.id);
+      await promise;
+      return;
+    }
+    if (message.kind === "abort") {
+      await this.close({ id: message.id, reason: new AbortError("Server peer aborted the request") });
+      return;
+    }
+    if (message.kind === "event-stream") {
+      if (this.eventStreamMessageQueue.isOpen(message.id)) {
+        this.eventStreamMessageQueue.push(message.id, message);
+      }
+      return;
+    }
+    if (message.kind === "octet-stream") {
+      if (this.octetStreamMessageQueue.isOpen(message.id)) {
+        this.octetStreamMessageQueue.push(message.id, message);
+      }
+      return;
+    }
+    if (this.responseMessageQueue.isOpen(message.id)) {
+      this.responseMessageQueue.push(message.id, message);
+    }
+  }
+  async close(options = {}) {
+    const promises = [];
+    this.responseMessageQueue.close(options);
+    this.eventStreamMessageQueue.close(options);
+    this.octetStreamMessageQueue.close(options);
+    if (options.id !== void 0) {
+      promises.push(
+        this.requestEventStreamTransmitters.get(options.id)?.cancel(),
+        this.requestOctetStreamTransmitters.get(options.id)?.cancel()
+      );
+      this.requestEventStreamTransmitters.delete(options.id);
+      this.requestOctetStreamTransmitters.delete(options.id);
+      this.cleanupFns.get(options.id)?.forEach((fn) => fn());
+      this.cleanupFns.delete(options.id);
+    } else {
+      this.requestEventStreamTransmitters.forEach((t) => promises.push(t.cancel()));
+      this.requestOctetStreamTransmitters.forEach((t) => promises.push(t.cancel()));
+      this.requestEventStreamTransmitters.clear();
+      this.requestOctetStreamTransmitters.clear();
+      this.cleanupFns.forEach((fns) => fns.forEach((fn) => fn()));
+      this.cleanupFns.clear();
+    }
+    await Promise.all(promises);
+  }
+}
+
+const JSON_BINARY_SEPARATOR_BYTE = 255;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+async function encodePeerMessage(message) {
+  if (message.binary === void 0) {
+    return stringifyJSON(message);
+  }
+  const jsonBytes = textEncoder.encode(stringifyJSON(message));
+  const binaryBytes = message.binary instanceof Blob ? new Uint8Array(await message.binary.arrayBuffer()) : message.binary;
+  const output = new Uint8Array(
+    jsonBytes.length + 1 + binaryBytes.length
+  );
+  output.set(jsonBytes, 0);
+  output[jsonBytes.length] = JSON_BINARY_SEPARATOR_BYTE;
+  output.set(binaryBytes, jsonBytes.length + 1);
+  return output;
+}
+function decodePeerMessage(data) {
+  if (typeof data === "string") {
+    return JSON.parse(data);
+  }
+  const separatorIndex = data.indexOf(JSON_BINARY_SEPARATOR_BYTE);
+  if (separatorIndex === -1) {
+    return JSON.parse(textDecoder.decode(data));
+  }
+  const jsonBytes = data.subarray(0, separatorIndex);
+  const binaryBytes = data.subarray(separatorIndex + 1);
+  return {
+    ...JSON.parse(textDecoder.decode(jsonBytes)),
+    binary: binaryBytes
+  };
+}
+
+class HibernationEventIterator extends AsyncIteratorClass {
+  /**
+   * In the client library, server results are typically represented by an `AsyncIteratorClass`.
+   * Since `AsyncIteratorClass` does not include a `hibernationCallback` property, this property should be optional.
+   */
+  hibernationCallback;
+  constructor(hibernationCallback) {
+    super(async () => {
+      throw new Error("Cannot use hibernating iterator directly");
+    }, async (isCompleted) => {
+      if (!isCompleted) {
+        throw new Error("Cannot use hibernating iterator directly");
+      }
+    });
+    this.hibernationCallback = hibernationCallback;
+  }
+}
+
+class ServerPeer {
+  constructor(send) {
+    this.send = send;
+  }
+  /**
+   * Messages waiting to be processed
+   */
+  eventStreamMessageQueue = new AsyncIdQueue();
+  octetStreamMessageQueue = new AsyncIdQueue();
+  eventStreamTransmitters = /* @__PURE__ */ new Map();
+  octetStreamTransmitters = /* @__PURE__ */ new Map();
+  /**
+   * Map of abort controllers for each request
+   */
+  controller = /* @__PURE__ */ new Map();
+  /**
+   * Use for measure resources usage
+   */
+  get size() {
+    return this.eventStreamMessageQueue.length + this.octetStreamMessageQueue.length + this.controller.size + this.eventStreamTransmitters.size + this.octetStreamTransmitters.size;
+  }
+  /**
+   * Handle a message from client
+   */
+  async message(message, handleRequest) {
+    if (message.kind === "abort") {
+      await this.close({ id: message.id, reason: new AbortError("Client peer aborted the request") });
+      return;
+    }
+    if (message.kind === "event-stream") {
+      if (this.eventStreamMessageQueue.isOpen(message.id)) {
+        this.eventStreamMessageQueue.push(message.id, message);
+      }
+      return;
+    }
+    if (message.kind === "octet-stream") {
+      if (this.octetStreamMessageQueue.isOpen(message.id)) {
+        this.octetStreamMessageQueue.push(message.id, message);
+      }
+      return;
+    }
+    this.eventStreamMessageQueue.open(message.id);
+    this.octetStreamMessageQueue.open(message.id);
+    const controller = new AbortController();
+    this.controller.set(message.id, controller);
+    const signal = controller.signal;
+    try {
+      const request = {
+        ...message.json,
+        signal,
+        body: await toStandardBody(
+          message,
+          this.eventStreamMessageQueue,
+          this.octetStreamMessageQueue,
+          async (isCompleted) => {
+            this.eventStreamMessageQueue.close({ id: message.id });
+            this.octetStreamMessageQueue.close({ id: message.id });
+            if (!isCompleted && this.controller.has(message.id)) {
+              await this.send({ id: message.id, kind: "stream/cancel" });
+            }
+          }
+        )
+      };
+      const response = await handleRequest(request);
+      if (signal.aborted) {
+        return;
+      }
+      const responseMessage = {
+        id: message.id,
+        kind: "response",
+        json: {
+          ...{ ...response, signal: void 0 },
+          // clone and remove signal from request
+          headers: { ...response.headers }
+          // clone headers
+        }
+      };
+      if (response.body instanceof ReadableStream) {
+        responseMessage.json.body = void 0;
+        responseMessage.json.headers["standard-server"] = "octet-stream";
+      } else if (isAsyncIteratorObject(response.body)) {
+        responseMessage.json.body = void 0;
+        responseMessage.json.headers["standard-server"] = "event-stream";
+      } else if (response.body instanceof FormData) {
+        const res = new Response(response.body);
+        responseMessage.binary = await res.blob();
+        responseMessage.json.body = void 0;
+        responseMessage.json.headers["standard-server"] = "form-data";
+        responseMessage.json.headers["content-type"] = res.headers.get("content-type") ?? void 0;
+      } else if (response.body instanceof Blob) {
+        responseMessage.binary = response.body;
+        responseMessage.json.body = void 0;
+        responseMessage.json.headers["standard-server"] = "file";
+        responseMessage.json.headers["content-disposition"] = generateContentDisposition(response.body instanceof File ? response.body.name : "blob");
+        responseMessage.json.headers["content-type"] = response.body.type;
+      } else if (response.body instanceof URLSearchParams) {
+        responseMessage.json.body = response.body.toString();
+        responseMessage.json.headers["standard-server"] = "url-search-params";
+      }
+      if (signal.aborted) {
+        return;
+      }
+      await this.send(responseMessage);
+      if (signal.aborted) {
+        return;
+      }
+      if (isAsyncIteratorObject(response.body)) {
+        if (response.body instanceof HibernationEventIterator) {
+          response.body.hibernationCallback?.(message.id);
+        } else {
+          const transmitter = new EventStreamTransmitter(response.body, message.id, this.send);
+          this.eventStreamTransmitters.set(message.id, transmitter);
+          await transmitter.transmit();
+        }
+      } else if (response.body instanceof ReadableStream) {
+        const transmitter = new OctetStreamTransmitter(response.body, message.id, this.send);
+        this.octetStreamTransmitters.set(message.id, transmitter);
+        await transmitter.transmit();
+      }
+      this.controller.delete(message.id);
+      await this.close({ id: message.id });
+    } catch (reason) {
+      await Promise.all([
+        /**
+         * Do not need to send abort message if request was closed or aborted
+         */
+        this.controller.has(message.id) ? this.send({ id: message.id, kind: "abort" }) : void 0,
+        this.close({ id: message.id, reason })
+      ]);
+      throw reason;
+    }
+  }
+  async close(options = {}) {
+    const promises = [];
+    this.eventStreamMessageQueue.close(options);
+    this.octetStreamMessageQueue.close(options);
+    if (options.id === void 0) {
+      this.eventStreamTransmitters.forEach((t) => promises.push(t.cancel()));
+      this.octetStreamTransmitters.forEach((t) => promises.push(t.cancel()));
+      this.eventStreamTransmitters.clear();
+      this.octetStreamTransmitters.clear();
+      this.controller.forEach((c) => c.abort(options.reason));
+      this.controller.clear();
+    } else {
+      promises.push(
+        this.eventStreamTransmitters.get(options.id)?.cancel(),
+        this.octetStreamTransmitters.get(options.id)?.cancel()
+      );
+      this.eventStreamTransmitters.delete(options.id);
+      this.octetStreamTransmitters.delete(options.id);
+      this.controller.get(options.id)?.abort(options.reason);
+      this.controller.delete(options.id);
+    }
+    await Promise.all(promises);
+  }
+}
+
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@standardserver/peer",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://standardserver.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/standardserver/standardserver.git",
+    "directory": "packages/peer"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standardserver/core": "0.0.0",
+    "@standardserver/shared": "0.0.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}