@standardserver/peer 0.0.7 → 0.0.8

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { StandardRequest, StandardResponse } from '@standardserver/core';
-import { AsyncIdQueueCloseOptions, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
+import { StandardRequest, StandardResponse, StandardLazyResponse, StandardLazyRequest } from '@standardserver/core';
 import { EventStreamMessage } from '@standardserver/core/event-stream';
+import { Queue, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
 
 /**
  * Base interface for all peer messages.
@@ -68,17 +68,17 @@ interface PeerResponseMessage extends PeerMessage {
  * - **Client → Server**: Cancel an in-flight request or stop consuming a stream.
  * - **Server → Client**: Signal an error or premature termination.
  */
-interface PeerAbortMessage extends PeerMessage {
+interface PeerCancelMessage extends PeerMessage {
     /**
      * The kind of the message.
      */
-    kind: 'abort';
+    kind: 'cancel';
     /**
      * This message does not have a JSON payload.
      */
     json?: undefined;
     /**
-     * Abort messages carry no binary payload.
+     * Cancel messages carry no binary payload.
      */
     binary?: undefined;
 }
@@ -164,29 +164,20 @@ interface PeerStreamCancelMessage extends PeerMessage {
      */
     binary?: undefined;
 }
+/**
+ * Union of all messages a client peer may send to a server peer.
+ */
+type ClientPeerSendMessage = PeerRequestMessage | PeerCancelMessage | PeerEventStreamMessage | PeerOctetStreamMessage;
+/**
+ * Union of all messages a server peer may send to a client peer.
+ */
+type ServerPeerSendMessage = PeerResponseMessage | PeerCancelMessage | PeerOctetStreamMessage | PeerEventStreamMessage | PeerStreamCancelMessage;
 
-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>);
+    private readonly requests;
+    constructor(send: (message: ClientPeerSendMessage) => Promise<void>);
     /**
      * Use to measure resources usage
      */
@@ -194,12 +185,14 @@ declare class ClientPeer {
     /**
      * Send a request to the server peer
      */
-    request(request: StandardRequest): Promise<StandardResponse>;
+    request(request: StandardRequest): Promise<StandardLazyResponse>;
     /**
      * Handle a message from server
      */
-    message(message: PeerResponseMessage | PeerAbortMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerStreamCancelMessage): Promise<void>;
-    close(options?: AsyncIdQueueCloseOptions): Promise<void>;
+    message(message: ServerPeerSendMessage): Promise<void>;
+    close(reason?: unknown): Promise<void>;
+    private closeById;
+    private abortById;
 }
 
 interface EncodePeerMessageOptions {
@@ -261,7 +254,7 @@ declare function decodePeerMessage(encoded: string | Uint8Array<ArrayBuffer>, op
  * 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>;
+declare function toEventIterator(queue: Queue<PeerEventStreamMessage>, cleanup: AsyncCleanupFn): AsyncIteratorClass<unknown>;
 /**
  * Transmits events to a peer event-stream.
  */
@@ -287,22 +280,10 @@ declare class HibernationEventIterator<T, TReturn = unknown, TNext = unknown> ex
     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>);
+    private readonly requests;
+    constructor(send: (message: ServerPeerSendMessage) => Promise<void>);
     /**
      * Use for measure resources usage
      */
@@ -310,9 +291,20 @@ declare class ServerPeer {
     /**
      * Handle a message from client
      */
-    message(message: PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerAbortMessage, handleRequest: (request: StandardRequest) => Promise<StandardResponse>): Promise<void>;
-    close(options?: ServerPeerCloseOptions): Promise<void>;
+    message(message: ClientPeerSendMessage, handleRequest: (request: StandardLazyRequest) => Promise<StandardResponse>): Promise<void>;
+    close(reason?: unknown): Promise<void>;
+    private closeById;
 }
 
-export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };
-export type { ClientPeerCloseOptions, DecodePeerMessageOptions, DecodePeerMessageResult, EncodePeerMessageOptions, HibernationEventIteratorCallback, PeerAbortMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerCloseOptions };
+declare function isPeerMessage(maybe: unknown): maybe is PeerMessage;
+declare function isPeerRequestMessage(maybe: PeerMessage): maybe is PeerRequestMessage;
+declare function isPeerResponseMessage(maybe: PeerMessage): maybe is PeerResponseMessage;
+declare function isPeerCancelMessage(maybe: PeerMessage): maybe is PeerCancelMessage;
+declare function isPeerEventStreamMessage(maybe: PeerMessage): maybe is PeerEventStreamMessage;
+declare function isPeerOctetStreamMessage(maybe: PeerMessage): maybe is PeerOctetStreamMessage;
+declare function isPeerStreamCancelMessage(maybe: PeerMessage): maybe is PeerStreamCancelMessage;
+declare function isClientPeerSendMessage(maybe: PeerMessage): maybe is ClientPeerSendMessage;
+declare function isServerPeerSendMessage(maybe: PeerMessage): maybe is ServerPeerSendMessage;
+
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerCancelMessage, isPeerEventStreamMessage, isPeerMessage, isPeerOctetStreamMessage, isPeerRequestMessage, isPeerResponseMessage, isPeerStreamCancelMessage, isServerPeerSendMessage, toEventIterator };
+export type { ClientPeerSendMessage, DecodePeerMessageOptions, DecodePeerMessageResult, EncodePeerMessageOptions, HibernationEventIteratorCallback, PeerCancelMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerSendMessage };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { StandardRequest, StandardResponse } from '@standardserver/core';
-import { AsyncIdQueueCloseOptions, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
+import { StandardRequest, StandardResponse, StandardLazyResponse, StandardLazyRequest } from '@standardserver/core';
 import { EventStreamMessage } from '@standardserver/core/event-stream';
+import { Queue, AsyncCleanupFn, AsyncIteratorClass } from '@standardserver/shared';
 
 /**
  * Base interface for all peer messages.
@@ -68,17 +68,17 @@ interface PeerResponseMessage extends PeerMessage {
  * - **Client → Server**: Cancel an in-flight request or stop consuming a stream.
  * - **Server → Client**: Signal an error or premature termination.
  */
-interface PeerAbortMessage extends PeerMessage {
+interface PeerCancelMessage extends PeerMessage {
     /**
      * The kind of the message.
      */
-    kind: 'abort';
+    kind: 'cancel';
     /**
      * This message does not have a JSON payload.
      */
     json?: undefined;
     /**
-     * Abort messages carry no binary payload.
+     * Cancel messages carry no binary payload.
      */
     binary?: undefined;
 }
@@ -164,29 +164,20 @@ interface PeerStreamCancelMessage extends PeerMessage {
      */
     binary?: undefined;
 }
+/**
+ * Union of all messages a client peer may send to a server peer.
+ */
+type ClientPeerSendMessage = PeerRequestMessage | PeerCancelMessage | PeerEventStreamMessage | PeerOctetStreamMessage;
+/**
+ * Union of all messages a server peer may send to a client peer.
+ */
+type ServerPeerSendMessage = PeerResponseMessage | PeerCancelMessage | PeerOctetStreamMessage | PeerEventStreamMessage | PeerStreamCancelMessage;
 
-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>);
+    private readonly requests;
+    constructor(send: (message: ClientPeerSendMessage) => Promise<void>);
     /**
      * Use to measure resources usage
      */
@@ -194,12 +185,14 @@ declare class ClientPeer {
     /**
      * Send a request to the server peer
      */
-    request(request: StandardRequest): Promise<StandardResponse>;
+    request(request: StandardRequest): Promise<StandardLazyResponse>;
     /**
      * Handle a message from server
      */
-    message(message: PeerResponseMessage | PeerAbortMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerStreamCancelMessage): Promise<void>;
-    close(options?: AsyncIdQueueCloseOptions): Promise<void>;
+    message(message: ServerPeerSendMessage): Promise<void>;
+    close(reason?: unknown): Promise<void>;
+    private closeById;
+    private abortById;
 }
 
 interface EncodePeerMessageOptions {
@@ -261,7 +254,7 @@ declare function decodePeerMessage(encoded: string | Uint8Array<ArrayBuffer>, op
  * 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>;
+declare function toEventIterator(queue: Queue<PeerEventStreamMessage>, cleanup: AsyncCleanupFn): AsyncIteratorClass<unknown>;
 /**
  * Transmits events to a peer event-stream.
  */
@@ -287,22 +280,10 @@ declare class HibernationEventIterator<T, TReturn = unknown, TNext = unknown> ex
     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>);
+    private readonly requests;
+    constructor(send: (message: ServerPeerSendMessage) => Promise<void>);
     /**
      * Use for measure resources usage
      */
@@ -310,9 +291,20 @@ declare class ServerPeer {
     /**
      * Handle a message from client
      */
-    message(message: PeerRequestMessage | PeerEventStreamMessage | PeerOctetStreamMessage | PeerAbortMessage, handleRequest: (request: StandardRequest) => Promise<StandardResponse>): Promise<void>;
-    close(options?: ServerPeerCloseOptions): Promise<void>;
+    message(message: ClientPeerSendMessage, handleRequest: (request: StandardLazyRequest) => Promise<StandardResponse>): Promise<void>;
+    close(reason?: unknown): Promise<void>;
+    private closeById;
 }
 
-export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };
-export type { ClientPeerCloseOptions, DecodePeerMessageOptions, DecodePeerMessageResult, EncodePeerMessageOptions, HibernationEventIteratorCallback, PeerAbortMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerCloseOptions };
+declare function isPeerMessage(maybe: unknown): maybe is PeerMessage;
+declare function isPeerRequestMessage(maybe: PeerMessage): maybe is PeerRequestMessage;
+declare function isPeerResponseMessage(maybe: PeerMessage): maybe is PeerResponseMessage;
+declare function isPeerCancelMessage(maybe: PeerMessage): maybe is PeerCancelMessage;
+declare function isPeerEventStreamMessage(maybe: PeerMessage): maybe is PeerEventStreamMessage;
+declare function isPeerOctetStreamMessage(maybe: PeerMessage): maybe is PeerOctetStreamMessage;
+declare function isPeerStreamCancelMessage(maybe: PeerMessage): maybe is PeerStreamCancelMessage;
+declare function isClientPeerSendMessage(maybe: PeerMessage): maybe is ClientPeerSendMessage;
+declare function isServerPeerSendMessage(maybe: PeerMessage): maybe is ServerPeerSendMessage;
+
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerCancelMessage, isPeerEventStreamMessage, isPeerMessage, isPeerOctetStreamMessage, isPeerRequestMessage, isPeerResponseMessage, isPeerStreamCancelMessage, isServerPeerSendMessage, toEventIterator };
+export type { ClientPeerSendMessage, DecodePeerMessageOptions, DecodePeerMessageResult, EncodePeerMessageOptions, HibernationEventIteratorCallback, PeerCancelMessage, PeerEventStreamMessage, PeerMessage, PeerOctetStreamMessage, PeerRequestMessage, PeerResponseMessage, PeerStreamCancelMessage, ServerPeerSendMessage };

package/dist/index.mjs

@@ -1,11 +1,11 @@
-import { AsyncIteratorClass, isTypescriptObject, isAsyncIteratorObject, SequentialIdGenerator, AsyncIdQueue, AbortError, stringifyJSON } from '@standardserver/shared';
-import { generateContentDisposition, flattenStandardHeader, getFilenameFromContentDisposition } from '@standardserver/core';
+import { AsyncIteratorClass, isTypescriptObject, isAsyncIteratorObject, Queue, SequentialIdGenerator, omit, emitUnhandledRejection, AbortError, stringifyJSON } from '@standardserver/shared';
+import { generateContentDisposition, flattenStandardHeader, getFilenameFromContentDisposition, isStandardRequest, isStandardResponse } from '@standardserver/core';
 import { withEventIteratorEventMeta, EventIteratorErrorEvent, unwrapEventIteratorEvent } from '@standardserver/core/event-stream';
 
-function toEventIterator(pull, cleanup) {
+function toEventIterator(queue, cleanup) {
   return new AsyncIteratorClass(async () => {
     while (true) {
-      const { json } = await pull();
+      const { json } = await queue.pull();
       switch (json.event) {
         case "message": {
           let data = json.data;
@@ -46,61 +46,69 @@ class EventStreamTransmitter {
   }
   async transmit() {
     while (true) {
-      let json;
       try {
         const item = await this.iterator.next();
         if (this.isCompleted) {
           return;
         }
+        const [data, meta] = unwrapEventIteratorEvent(item.value);
+        try {
+          await this.send({
+            kind: "event-stream",
+            id: this.messageId,
+            json: { ...meta, event: item.done ? "close" : "message", data }
+          });
+        } catch (error) {
+          if (!item.done) {
+            await this.cancel();
+          }
+          throw error;
+        }
         if (item.done) {
           this.isCompleted = true;
+          return;
         }
-        const [data, meta] = unwrapEventIteratorEvent(item.value);
-        json = { ...meta, event: item.done ? "close" : "message", data };
-      } catch (err) {
-        if (err instanceof EventIteratorErrorEvent) {
-          if (this.isCompleted) {
-            return;
-          }
+      } catch (error) {
+        if (this.isCompleted) {
+          throw error;
+        }
+        if (error instanceof EventIteratorErrorEvent) {
+          const [resolvedError, meta] = unwrapEventIteratorEvent(error);
+          await this.send({
+            kind: "event-stream",
+            id: this.messageId,
+            json: { ...meta, event: "error", data: resolvedError.data }
+          });
           this.isCompleted = true;
-          const [resolvedError, meta] = unwrapEventIteratorEvent(err);
-          json = { ...meta, event: "error", data: resolvedError.data };
+          return;
         } else {
           this.isCompleted = true;
-          throw err;
+          throw error;
         }
       }
-      await this.send({
-        json,
-        kind: "event-stream",
-        id: this.messageId
-      });
-      if (this.isCompleted) {
-        return;
-      }
     }
   }
 }
 
-function toOctetStream(pull, cleanup) {
+function toOctetStream(queue, cleanup) {
   return new ReadableStream({
     async pull(controller) {
       try {
-        const { json, binary } = await pull();
+        const { json, binary } = await queue.pull();
         if (binary) {
           controller.enqueue(binary instanceof Uint8Array ? binary : new Uint8Array(await binary.arrayBuffer()));
         }
         if (json.close) {
-          await cleanup(true);
+          await cleanup({ isCancelled: false });
           controller.close();
         }
-      } catch (err) {
-        await cleanup(true);
-        controller.error(err);
+      } catch (error) {
+        await cleanup({ isCancelled: false, error });
+        controller.error(error);
       }
     },
     async cancel() {
-      await cleanup(false);
+      await cleanup({ isCancelled: true });
     }
   });
 }
@@ -120,8 +128,11 @@ class OctetStreamTransmitter {
   }
   async transmit() {
     while (true) {
-      const { done, value } = await this.reader.read();
-      if (!this.isCompleted) {
+      try {
+        const { done, value } = await this.reader.read();
+        if (this.isCompleted) {
+          return;
+        }
         try {
           await this.send({
             json: { close: done },
@@ -130,56 +141,71 @@ class OctetStreamTransmitter {
             id: this.messageId
           });
         } catch (err) {
-          await this.cancel();
+          if (!done) {
+            await this.cancel();
+          }
           throw err;
         }
-      }
-      if (done) {
+        if (done) {
+          this.isCompleted = true;
+          return;
+        }
+      } catch (error) {
         this.isCompleted = true;
-        break;
+        throw error;
       }
     }
   }
 }
 
-async function toStandardBody(message, eventStreamMessageQueue, octetStreamMessageQueue, cleanup) {
+function toStandardBody(message, cleanup) {
   const bodyHint = flattenStandardHeader(message.json.headers["standard-server"]);
   if (bodyHint === "event-stream") {
-    return toEventIterator(
-      () => eventStreamMessageQueue.pull(message.id),
-      cleanup
-    );
+    const eventStreamMessageQueue = new Queue();
+    return {
+      resolveBody: async () => toEventIterator(eventStreamMessageQueue, cleanup),
+      eventStreamMessageQueue
+    };
   }
   if (bodyHint === "octet-stream") {
-    return toOctetStream(
-      () => octetStreamMessageQueue.pull(message.id),
-      cleanup
-    );
+    const octetStreamMessageQueue = new Queue();
+    return {
+      resolveBody: async () => toOctetStream(octetStreamMessageQueue, cleanup),
+      octetStreamMessageQueue
+    };
   }
-  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);
+  const resolveBody = async () => {
+    let errorRef;
+    try {
+      if (bodyHint === "file") {
+        const contentDisposition = flattenStandardHeader(message.json.headers["content-disposition"]);
+        const filename = contentDisposition !== void 0 ? getFilenameFromContentDisposition(contentDisposition) : void 0;
+        const body = new File(message.binary ? [message.binary] : [], filename ?? "blob", {
+          type: flattenStandardHeader(message.json.headers["content-type"]) ?? "application/octet-stream"
+        });
+        return body;
+      }
+      if (bodyHint === "form-data") {
+        const res = new Response(message.binary, {
+          headers: {
+            "content-type": flattenStandardHeader(message.json.headers["content-type"]) ?? "multipart/form-data"
+          }
+        });
+        const body = await res.formData();
+        return body;
+      }
+      if (bodyHint === "url-search-params" && typeof message.json.body === "string") {
+        return new URLSearchParams(message.json.body);
+      }
+      return message.json.body;
+    } catch (error) {
+      errorRef = { value: error };
+      throw error;
+    } finally {
+      await cleanup(errorRef ? { isCancelled: false, error: errorRef.value } : { isCancelled: false });
     }
-    return message.json.body;
-  } finally {
-    await cleanup(true);
-  }
+  };
+  return { resolveBody };
 }
 async function encodeAtomicStandardBody(body, headers) {
   headers = { ...headers };
@@ -218,27 +244,12 @@ class ClientPeer {
     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();
+  requests = /* @__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;
+    return this.requests.size;
   }
   /**
    * Send a request to the server peer
@@ -247,162 +258,228 @@ class ClientPeer {
     const signal = request.signal;
     signal?.throwIfAborted();
     const id = this.idGenerator.generate();
-    this.eventStreamMessageQueue.open(id);
-    this.octetStreamMessageQueue.open(id);
-    this.responseMessageQueue.open(id);
+    const state = {};
+    this.requests.set(id, state);
     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 })
-      ]);
+    signal?.addEventListener("abort", abortListener = () => this.abortById(id, signal.reason));
+    state.cleanupFns ??= [];
+    state.cleanupFns.push(() => {
+      signal?.removeEventListener("abort", abortListener);
     });
-    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 [jsonBody, headers, binary] = await encodeAtomicStandardBody(request.body, request.headers);
       signal?.throwIfAborted();
-      const requestMessage = {
+      await this.send({
         id,
         kind: "request",
         json: {
-          ...request,
+          ...omit(request, ["signal"]),
           headers,
-          body: jsonBody,
-          ...{ signal: void 0 }
-          // remove signal from request
+          body: jsonBody
         },
         binary
-      };
-      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 })
-          ]);
+        state.eventStreamTransmitter = transmitter;
+        void transmitter.transmit().catch(async (error) => {
+          if (state.eventStreamTransmitter) {
+            await this.abortById(id, error);
+          } else {
+            emitUnhandledRejection(error);
+          }
         });
       } 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 })
-          ]);
+        state.octetStreamTransmitter = transmitter;
+        void transmitter.transmit().catch(async (error) => {
+          if (state.octetStreamTransmitter) {
+            await this.abortById(id, error);
+          } else {
+            emitUnhandledRejection(error);
+          }
+          /* v8 ignore stop -- @preserve */
         });
       }
-      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 });
+      await this.closeById(id, reason);
       throw reason;
     }
+    return new Promise((resolve, reject) => {
+      state.resolve = resolve;
+      state.reject = reject;
+    });
   }
   /**
    * Handle a message from server
    */
   async message(message) {
+    const id = message.id;
+    const state = this.requests.get(id);
+    if (!state) {
+      return;
+    }
     if (message.kind === "stream/cancel") {
       const promise = Promise.all([
-        this.requestEventStreamTransmitters.get(message.id)?.cancel(),
-        this.requestOctetStreamTransmitters.get(message.id)?.cancel()
+        state.eventStreamTransmitter?.cancel(),
+        state.octetStreamTransmitter?.cancel()
       ]);
-      this.requestEventStreamTransmitters.delete(message.id);
-      this.requestOctetStreamTransmitters.delete(message.id);
+      state.eventStreamTransmitter = void 0;
+      state.octetStreamTransmitter = void 0;
       await promise;
       return;
     }
-    if (message.kind === "abort") {
-      await this.close({ id: message.id, reason: new AbortError("Server peer aborted the request") });
+    if (message.kind === "cancel") {
+      await this.closeById(id, new AbortError("Server canceled the request"));
       return;
     }
     if (message.kind === "event-stream") {
-      if (this.eventStreamMessageQueue.isOpen(message.id)) {
-        this.eventStreamMessageQueue.push(message.id, message);
-      }
+      state.eventStreamMessageQueue?.push(message);
       return;
     }
     if (message.kind === "octet-stream") {
-      if (this.octetStreamMessageQueue.isOpen(message.id)) {
-        this.octetStreamMessageQueue.push(message.id, message);
-      }
+      state.octetStreamMessageQueue?.push(message);
       return;
     }
-    if (this.responseMessageQueue.isOpen(message.id)) {
-      this.responseMessageQueue.push(message.id, message);
+    if (!state.resolve) {
+      return;
+    }
+    const resolve = state.resolve;
+    state.resolve = void 0;
+    try {
+      const decoded = toStandardBody(message, async ({ isCancelled, error }) => {
+        if (isCancelled) {
+          await this.abortById(id, error);
+        } else if (state.eventStreamMessageQueue || state.octetStreamMessageQueue) {
+          await this.closeById(id, error);
+        }
+      });
+      state.eventStreamMessageQueue = decoded.eventStreamMessageQueue;
+      state.octetStreamMessageQueue = decoded.octetStreamMessageQueue;
+      resolve({ ...message.json, resolveBody: decoded.resolveBody });
+      if (!state.eventStreamMessageQueue && !state.octetStreamMessageQueue) {
+        await this.closeById(id);
+      }
+    } catch (reason) {
+      await this.closeById(id, reason);
     }
   }
-  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();
+  async close(reason) {
+    reason ??= new AbortError("Peer was closed");
+    await Promise.all(
+      Array.from(this.requests.keys()).map((id) => this.closeById(id, reason))
+    );
+  }
+  async closeById(id, reason) {
+    const state = this.requests.get(id);
+    if (!state) {
+      return;
+    }
+    this.requests.delete(id);
+    reason ??= new AbortError("Request was closed");
+    state.reject?.(reason);
+    state.resolve = void 0;
+    state.reject = void 0;
+    state.eventStreamMessageQueue?.close(reason);
+    state.octetStreamMessageQueue?.close(reason);
+    state.eventStreamMessageQueue = void 0;
+    state.octetStreamMessageQueue = void 0;
+    const promises = [
+      state.eventStreamTransmitter?.cancel(),
+      state.octetStreamTransmitter?.cancel()
+    ];
+    state.eventStreamTransmitter = void 0;
+    state.octetStreamTransmitter = void 0;
+    state.cleanupFns?.forEach((fn) => fn());
+    state.cleanupFns = void 0;
+    await Promise.all(promises);
+  }
+  async abortById(id, reason) {
+    const state = this.requests.get(id);
+    if (!state) {
+      return;
     }
+    this.requests.delete(id);
+    reason ??= new AbortError("Request was aborted");
+    state.reject?.(reason);
+    state.resolve = void 0;
+    state.reject = void 0;
+    state.eventStreamMessageQueue?.abort(reason);
+    state.octetStreamMessageQueue?.abort(reason);
+    state.eventStreamMessageQueue = void 0;
+    state.octetStreamMessageQueue = void 0;
+    const promises = [
+      this.send({ id, kind: "cancel" }),
+      state.eventStreamTransmitter?.cancel(),
+      state.octetStreamTransmitter?.cancel()
+    ];
+    state.eventStreamTransmitter = void 0;
+    state.octetStreamTransmitter = void 0;
+    state.cleanupFns?.forEach((fn) => fn());
+    state.cleanupFns = void 0;
     await Promise.all(promises);
   }
 }
 
+function isPeerMessage(maybe) {
+  if (!isTypescriptObject(maybe)) {
+    return false;
+  }
+  if (typeof maybe.id !== "string") {
+    return false;
+  }
+  if (typeof maybe.kind !== "string") {
+    return false;
+  }
+  if (maybe.binary !== void 0 && !(maybe.binary instanceof Uint8Array) && !(maybe.binary instanceof Blob)) {
+    return false;
+  }
+  return true;
+}
+function isPeerRequestMessage(maybe) {
+  return maybe.kind === "request" && isStandardRequest(maybe.json);
+}
+function isPeerResponseMessage(maybe) {
+  return maybe.kind === "response" && isStandardResponse(maybe.json);
+}
+function isPeerCancelMessage(maybe) {
+  return maybe.kind === "cancel" && maybe.json === void 0 && maybe.binary === void 0;
+}
+function isPeerEventStreamMessage(maybe) {
+  if (maybe.kind !== "event-stream" || maybe.binary !== void 0) {
+    return false;
+  }
+  if (!isTypescriptObject(maybe.json)) {
+    return false;
+  }
+  if (maybe.json.id !== void 0 && typeof maybe.json.id !== "string") {
+    return false;
+  }
+  if (maybe.json.event !== void 0 && typeof maybe.json.event !== "string") {
+    return false;
+  }
+  if (maybe.json.retry !== void 0 && !Number.isFinite(maybe.json.retry)) {
+    return false;
+  }
+  if (maybe.json.comments !== void 0 && !(Array.isArray(maybe.json.comments) && maybe.json.comments.every((v) => typeof v === "string"))) {
+    return false;
+  }
+  return true;
+}
+function isPeerOctetStreamMessage(maybe) {
+  return maybe.kind === "octet-stream" && isTypescriptObject(maybe.json) && typeof maybe.json.close === "boolean";
+}
+function isPeerStreamCancelMessage(maybe) {
+  return maybe.kind === "stream/cancel" && maybe.json === void 0 && maybe.binary === void 0;
+}
+function isClientPeerSendMessage(maybe) {
+  return isPeerRequestMessage(maybe) || isPeerCancelMessage(maybe) || isPeerEventStreamMessage(maybe) || isPeerOctetStreamMessage(maybe);
+}
+function isServerPeerSendMessage(maybe) {
+  return isPeerResponseMessage(maybe) || isPeerCancelMessage(maybe) || isPeerEventStreamMessage(maybe) || isPeerOctetStreamMessage(maybe) || isPeerStreamCancelMessage(maybe);
+}
+
 const JSON_BINARY_DELIMITER = 255;
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -424,37 +501,48 @@ async function encodePeerMessage(message, options = {}) {
   return output;
 }
 function decodePeerMessage(encoded, options = {}) {
-  if (typeof encoded === "string") {
-    if (options.prefix) {
-      if (!encoded.startsWith(options.prefix)) {
+  try {
+    if (typeof encoded === "string") {
+      if (options.prefix) {
+        if (!encoded.startsWith(options.prefix)) {
+          return { matched: false };
+        }
+        encoded = encoded.slice(options.prefix.length);
+      }
+      const message2 = JSON.parse(encoded);
+      if (!isPeerMessage(message2)) {
         return { matched: false };
       }
-      encoded = encoded.slice(options.prefix.length);
+      return { matched: true, message: message2 };
     }
-    return { matched: true, message: JSON.parse(encoded) };
-  }
-  if (options.prefix) {
-    const prefixBytes = textEncoder.encode(options.prefix);
-    for (let i = 0; i < prefixBytes.length; i++) {
-      if (encoded[i] !== prefixBytes[i]) {
+    if (options.prefix) {
+      const prefixBytes = textEncoder.encode(options.prefix);
+      for (let i = 0; i < prefixBytes.length; i++) {
+        if (encoded[i] !== prefixBytes[i]) {
+          return { matched: false };
+        }
+      }
+      encoded = encoded.subarray(prefixBytes.length);
+    }
+    const separatorIndex = encoded.indexOf(JSON_BINARY_DELIMITER);
+    if (separatorIndex === -1) {
+      const message2 = JSON.parse(textDecoder.decode(encoded));
+      if (!isPeerMessage(message2)) {
         return { matched: false };
       }
+      return { matched: true, message: message2 };
     }
-    encoded = encoded.subarray(prefixBytes.length);
-  }
-  const separatorIndex = encoded.indexOf(JSON_BINARY_DELIMITER);
-  if (separatorIndex === -1) {
-    return { matched: true, message: JSON.parse(textDecoder.decode(encoded)) };
-  }
-  const jsonBytes = encoded.subarray(0, separatorIndex);
-  const binaryBytes = encoded.subarray(separatorIndex + 1);
-  return {
-    matched: true,
-    message: {
-      ...JSON.parse(textDecoder.decode(jsonBytes)),
-      binary: binaryBytes
+    const jsonBytes = encoded.subarray(0, separatorIndex);
+    const binaryBytes = encoded.subarray(separatorIndex + 1);
+    const message = JSON.parse(textDecoder.decode(jsonBytes));
+    if (!isPeerMessage(message)) {
+      return { matched: false };
     }
-  };
+    message.binary = binaryBytes;
+    return { matched: true, message };
+  } catch {
+    return { matched: false };
+  }
 }
 
 class HibernationEventIterator extends AsyncIteratorClass {
@@ -466,8 +554,8 @@ class HibernationEventIterator extends AsyncIteratorClass {
   constructor(hibernationCallback) {
     super(async () => {
       throw new Error("Cannot use hibernating iterator directly");
-    }, async (isCompleted) => {
-      if (!isCompleted) {
+    }, async ({ isCancelled }) => {
+      if (isCancelled) {
         throw new Error("Cannot use hibernating iterator directly");
       }
     });
@@ -479,66 +567,48 @@ 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();
+  requests = /* @__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;
+    return this.requests.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") });
+    const id = message.id;
+    if (message.kind === "cancel") {
+      await this.closeById(id, new AbortError("Client aborted the request"));
       return;
     }
     if (message.kind === "event-stream") {
-      if (this.eventStreamMessageQueue.isOpen(message.id)) {
-        this.eventStreamMessageQueue.push(message.id, message);
-      }
+      this.requests.get(id)?.eventStreamMessageQueue?.push(message);
       return;
     }
     if (message.kind === "octet-stream") {
-      if (this.octetStreamMessageQueue.isOpen(message.id)) {
-        this.octetStreamMessageQueue.push(message.id, message);
-      }
+      this.requests.get(id)?.octetStreamMessageQueue?.push(message);
+      return;
+    }
+    if (this.requests.has(id)) {
       return;
     }
-    this.eventStreamMessageQueue.open(message.id);
-    this.octetStreamMessageQueue.open(message.id);
     const controller = new AbortController();
-    this.controller.set(message.id, controller);
+    const state = { controller };
+    this.requests.set(id, state);
     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);
+      const decoded = toStandardBody(message, async ({ isCancelled }) => {
+        if (isCancelled && (state.eventStreamMessageQueue || state.octetStreamMessageQueue)) {
+          state.eventStreamMessageQueue = void 0;
+          state.octetStreamMessageQueue = void 0;
+          await this.send({ id, kind: "stream/cancel" });
+        }
+      });
+      state.eventStreamMessageQueue = decoded.eventStreamMessageQueue;
+      state.octetStreamMessageQueue = decoded.octetStreamMessageQueue;
+      const response = await handleRequest({ ...message.json, signal, resolveBody: decoded.resolveBody });
       if (signal.aborted) {
         return;
       }
@@ -549,13 +619,7 @@ class ServerPeer {
       const responseMessage = {
         id: message.id,
         kind: "response",
-        json: {
-          ...response,
-          headers,
-          body: jsonBody,
-          ...{ signal: void 0 }
-          // remove signal from request
-        },
+        json: { ...response, headers, body: jsonBody },
         binary
       };
       await this.send(responseMessage);
@@ -567,50 +631,54 @@ class ServerPeer {
           response.body.hibernationCallback?.(message.id);
         } else {
           const transmitter = new EventStreamTransmitter(response.body, message.id, this.send);
-          this.eventStreamTransmitters.set(message.id, transmitter);
+          state.eventStreamTransmitter = 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);
+        state.octetStreamTransmitter = transmitter;
         await transmitter.transmit();
       }
-      this.controller.delete(message.id);
-      await this.close({ id: message.id });
+      state.controller = void 0;
+      await this.closeById(id);
     } catch (reason) {
       await Promise.all([
         /**
-         * Do not need to send abort message if request was closed or aborted
+         * Do not need to send cancel 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 })
+        this.requests.has(message.id) ? this.send({ id: message.id, kind: "cancel" }) : void 0,
+        this.closeById(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);
+  async close(reason) {
+    reason ??= new AbortError("Peer was closed");
+    await Promise.all(
+      Array.from(this.requests.keys()).map((id) => this.closeById(id, reason))
+    );
+  }
+  async closeById(id, reason) {
+    const state = this.requests.get(id);
+    if (!state) {
+      return;
     }
+    this.requests.delete(id);
+    reason ??= new AbortError("Request was closed");
+    state.controller?.abort(reason);
+    state.controller = void 0;
+    state.eventStreamMessageQueue?.close(reason);
+    state.octetStreamMessageQueue?.close(reason);
+    state.eventStreamMessageQueue = void 0;
+    state.octetStreamMessageQueue = void 0;
+    const promises = [
+      state.eventStreamTransmitter?.cancel(),
+      state.octetStreamTransmitter?.cancel()
+    ];
+    state.eventStreamTransmitter = void 0;
+    state.octetStreamTransmitter = void 0;
     await Promise.all(promises);
   }
 }
 
-export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, toEventIterator };
+export { ClientPeer, EventStreamTransmitter, HibernationEventIterator, ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerCancelMessage, isPeerEventStreamMessage, isPeerMessage, isPeerOctetStreamMessage, isPeerRequestMessage, isPeerResponseMessage, isPeerStreamCancelMessage, isServerPeerSendMessage, toEventIterator };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@standardserver/peer",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "license": "MIT",
   "homepage": "https://standardserver.dev",
   "repository": {
@@ -20,8 +20,8 @@
     "dist"
   ],
   "dependencies": {
-    "@standardserver/core": "0.0.7",
-    "@standardserver/shared": "0.0.7"
+    "@standardserver/core": "0.0.8",
+    "@standardserver/shared": "0.0.8"
   },
   "scripts": {
     "build": "unbuild",