@zimic/interceptor 1.2.3-canary.7 → 1.2.4-canary.0

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkZU6IGW27_js = require('./chunk-ZU6IGW27.js');
+var chunkIPL73BDI_js = require('./chunk-IPL73BDI.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkIPL73BDI_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkIPL73BDI_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkIPL73BDI_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkIPL73BDI_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.createInterceptorServer; }
+  get: function () { return chunkIPL73BDI_js.createInterceptorServer; }
 });
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/server.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-XCYZ5L2M.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-OTZ5Z633.mjs';
 import './chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.2.3-canary.7",
+  "version": "1.2.4-canary.0",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -376,7 +376,7 @@ class HttpInterceptorClient<
 
   clear() {
     const clearPromises: Promise<AnyHttpRequestHandlerClient | void>[] = [
-      Promise.resolve(this.workerOrThrow.clearInterceptorHandlers(this)),
+      Promise.resolve(this.workerOrThrow.clearHandlers({ interceptor: this })),
     ];
 
     for (const method of HTTP_METHODS) {

package/src/http/interceptor/HttpInterceptorStore.ts

@@ -25,10 +25,13 @@ class HttpInterceptorStore {
   }
 
   private getRemoteWorkerKey(baseURL: URL, options: RemoteWorkerKeyOptions) {
-    if (!options.auth) {
-      return baseURL.origin;
+    const key = [`${baseURL.origin}${baseURL.pathname}`];
+
+    if (options.auth) {
+      key.push(options.auth.token);
     }
-    return `${baseURL.origin}:${options.auth.token}`;
+
+    return key.join(':');
   }
 
   remoteWorker(baseURL: URL, options: RemoteWorkerKeyOptions) {

package/src/http/interceptor/RemoteHttpInterceptor.ts

@@ -24,7 +24,7 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
       baseURL,
       createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
-          serverURL: new URL(baseURL.origin),
+          serverURL: baseURL,
           auth: this._auth,
         });
       },

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -183,11 +183,9 @@ abstract class HttpInterceptorWorker {
     return interceptor.onUnhandledRequest;
   }
 
-  abstract clearHandlers(): PossiblePromise<void>;
-
-  abstract clearInterceptorHandlers<Schema extends HttpSchema>(
-    interceptor: HttpInterceptorClient<Schema>,
-  ): PossiblePromise<void>;
+  abstract clearHandlers<Schema extends HttpSchema>(options?: {
+    interceptor?: HttpInterceptorClient<Schema>;
+  }): PossiblePromise<void>;
 
   abstract get interceptorsWithHandlers(): AnyHttpInterceptorClient[];
 

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -50,6 +50,8 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   get internalWorkerOrThrow() {
+    /* istanbul ignore if -- @preserve
+     * Trying to access the internal worker when it does not exist should not happen. */
     if (!this.internalWorker) {
       throw new NotRunningHttpInterceptorError();
     }
@@ -248,22 +250,24 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     }
   }
 
-  clearHandlers() {
-    this.internalWorkerOrThrow.resetHandlers();
-
-    for (const handlers of Object.values(this.httpHandlersByMethod)) {
-      handlers.length = 0;
-    }
-  }
-
-  clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
+  clearHandlers<Schema extends HttpSchema>(
+    options: {
+      interceptor?: HttpInterceptorClient<Schema>;
+    } = {},
+  ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
     }
 
-    for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
-      const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === interceptor);
-      removeArrayIndex(methodHandlers, groupToRemoveIndex);
+    if (options.interceptor === undefined) {
+      for (const handlers of Object.values(this.httpHandlersByMethod)) {
+        handlers.length = 0;
+      }
+    } else {
+      for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
+        const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === options.interceptor);
+        removeArrayIndex(methodHandlers, groupToRemoveIndex);
+      }
     }
   }
 

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -55,14 +55,14 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async start() {
     await super.sharedStart(async () => {
+      this.webSocketClient.onChannel('event', 'interceptors/responses/create', this.createResponse);
+      this.webSocketClient.onChannel('event', 'interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+
       await this.webSocketClient.start({
         parameters: this.auth ? { token: this.auth.token } : undefined,
         waitForAuthentication: true,
       });
 
-      this.webSocketClient.onEvent('interceptors/responses/create', this.createResponse);
-      this.webSocketClient.onEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
-
       this.platform = this.readPlatform();
       this.isRunning = true;
     });
@@ -120,10 +120,10 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async stop() {
     await super.sharedStop(async () => {
-      await this.clearHandlers();
+      this.webSocketClient.offChannel('event', 'interceptors/responses/create', this.createResponse);
+      this.webSocketClient.offChannel('event', 'interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      this.webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
-      this.webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      await this.clearHandlers();
 
       await this.webSocketClient.stop();
 
@@ -167,45 +167,22 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     });
   }
 
-  async clearHandlers() {
-    if (!this.isRunning) {
-      throw new NotRunningHttpInterceptorError();
-    }
-
-    this.httpHandlers.clear();
-
-    if (!this.webSocketClient.isRunning) {
-      return;
-    }
-
-    try {
-      await this.webSocketClient.request('interceptors/workers/reset', undefined);
-    } catch (error) {
-      /* istanbul ignore next -- @preserve
-       *
-       * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if
-       * we send a request message and the interceptor server closes the socket before sending a response. In this case,
-       * we can safely ignore the error because we know that the server is shutting down and resetting is no longer
-       * necessary.
-       *
-       * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
-      const isMessageAbortError = error instanceof WebSocketMessageAbortError;
-
-      /* istanbul ignore next -- @preserve */
-      if (!isMessageAbortError) {
-        throw error;
-      }
-    }
-  }
-
-  async clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
+  async clearHandlers<Schema extends HttpSchema>(
+    options: {
+      interceptor?: HttpInterceptorClient<Schema>;
+    } = {},
+  ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
     }
 
-    for (const handler of this.httpHandlers.values()) {
-      if (handler.interceptor === interceptor) {
-        this.httpHandlers.delete(handler.id);
+    if (options.interceptor === undefined) {
+      this.httpHandlers.clear();
+    } else {
+      for (const handler of this.httpHandlers.values()) {
+        if (handler.interceptor === options.interceptor) {
+          this.httpHandlers.delete(handler.id);
+        }
       }
     }
 
@@ -213,7 +190,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       return;
     }
 
-    const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
+    const handlersToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
       id: handler.id,
       baseURL: handler.baseURL,
       method: handler.method,
@@ -221,7 +198,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     }));
 
     try {
-      await this.webSocketClient.request('interceptors/workers/reset', groupsToRecommit);
+      await this.webSocketClient.request('interceptors/workers/reset', handlersToRecommit);
     } catch (error) {
       /* istanbul ignore next -- @preserve
        *

package/src/server/InterceptorServer.ts

@@ -164,20 +164,21 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private async startHttpServer() {
+    this.httpServerOrThrow.on('request', this.handleHttpRequest);
+
     await startHttpServer(this.httpServerOrThrow, {
       hostname: this.hostname,
       port: this.port,
     });
-    this.port = getHttpServerPort(this.httpServerOrThrow);
 
-    this.httpServerOrThrow.on('request', this.handleHttpRequest);
+    this.port = getHttpServerPort(this.httpServerOrThrow);
   }
 
   private startWebSocketServer() {
-    this.webSocketServerOrThrow.start();
+    this.webSocketServerOrThrow.onChannel('event', 'interceptors/workers/commit', this.commitWorker);
+    this.webSocketServerOrThrow.onChannel('event', 'interceptors/workers/reset', this.resetWorker);
 
-    this.webSocketServerOrThrow.onEvent('interceptors/workers/commit', this.commitWorker);
-    this.webSocketServerOrThrow.onEvent('interceptors/workers/reset', this.resetWorker);
+    this.webSocketServerOrThrow.start();
   }
 
   private commitWorker = (
@@ -193,25 +194,42 @@ class InterceptorServer implements PublicInterceptorServer {
   };
 
   private resetWorker = (
-    message: WebSocketEventMessage<InterceptorServerWebSocketSchema, 'interceptors/workers/reset'>,
+    { data: handlersToRecommit }: WebSocketEventMessage<InterceptorServerWebSocketSchema, 'interceptors/workers/reset'>,
     socket: Socket,
   ) => {
-    this.removeHttpHandlersBySocket(socket);
+    this.registerWorkerSocketIfUnknown(socket);
+
+    this.webSocketServerOrThrow.emitSocket('abortRequests', socket, {
+      shouldAbortRequest: (request) => {
+        const isResponseCreationRequest = this.webSocketServerOrThrow.isChannelEvent(
+          request,
+          'interceptors/responses/create',
+        );
 
-    const handlersToResetTo = message.data;
-    const isWorkerNoLongerCommitted = handlersToResetTo === undefined;
+        /* istanbul ignore if -- @preserve
+         * While resetting a worker, there could be other types of requests in progress. These are not guaranteed to
+         * exist and are not related to handler resets, so we let them continue. */
+        if (!isResponseCreationRequest) {
+          return false;
+        }
 
-    if (isWorkerNoLongerCommitted) {
-      // When a worker is no longer committed, we should abort all requests that were using it.
-      // This ensures that we only wait for responses from committed worker sockets.
-      this.webSocketServerOrThrow.abortSocketMessages([socket]);
-    } else {
-      for (const handler of handlersToResetTo) {
-        this.registerHttpHandler(handler, socket);
-      }
-    }
+        // TODO: create a test with two interceptors, one for each path,, and reset only one of them.
+        const isHandlerStillCommitted = handlersToRecommit.some(
+          /* istanbul ignore next -- @preserve
+           * Ensuring this function is called in tests is difficult because it requires clearing or stopping a worker
+           * at the exact moment a request is being handled, in a scenario when there are other handlers still
+           * committed. */
+          (handler) => request.data.handlerId === handler.id,
+        );
+        return !isHandlerStillCommitted;
+      },
+    });
 
-    this.registerWorkerSocketIfUnknown(socket);
+    this.removeHttpHandlersBySocket(socket);
+
+    for (const handler of handlersToRecommit) {
+      this.registerHttpHandler(handler, socket);
+    }
 
     return {};
   };
@@ -263,8 +281,8 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private async stopWebSocketServer() {
-    this.webSocketServerOrThrow.offEvent('interceptors/workers/commit', this.commitWorker);
-    this.webSocketServerOrThrow.offEvent('interceptors/workers/reset', this.resetWorker);
+    this.webSocketServerOrThrow.offChannel('event', 'interceptors/workers/commit', this.commitWorker);
+    this.webSocketServerOrThrow.offChannel('event', 'interceptors/workers/reset', this.resetWorker);
 
     await this.webSocketServerOrThrow.stop();
 

package/src/server/types/schema.ts

@@ -17,7 +17,7 @@ export type InterceptorServerWebSocketSchema = WebSocketSchema<{
   };
 
   'interceptors/workers/reset': {
-    event?: HttpHandlerCommit[];
+    event: HttpHandlerCommit[];
     reply: {};
   };
 

package/src/webSocket/WebSocketClient.ts

@@ -49,11 +49,11 @@ class WebSocketClient<Schema extends WebSocketSchema> extends WebSocketHandler<S
   }
 
   async stop() {
-    super.removeAllChannelListeners();
+    super.offAny();
 
-    const sockets = this.socket ? [this.socket] : [];
-    super.abortSocketMessages(sockets);
-    await super.closeClientSockets(sockets);
+    if (this.socket) {
+      await super.closeClientSockets([this.socket]);
+    }
 
     this.socket = undefined;
   }

package/src/webSocket/WebSocketHandler.ts

@@ -26,6 +26,10 @@ import {
   WebSocketMessage,
 } from './types';
 
+interface WebSocketRequestAbortOptions<Schema extends WebSocketSchema> {
+  shouldAbortRequest?: (request: WebSocketEventMessage<Schema>) => boolean;
+}
+
 abstract class WebSocketHandler<Schema extends WebSocketSchema> {
   private sockets = new Set<ClientSocket>();
 
@@ -40,7 +44,7 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
   } = {};
 
   private socketListeners = {
-    messageAbort: new Map<ClientSocket, Set<(error: unknown) => void>>(),
+    abortRequests: new Map<ClientSocket, Set<(options: WebSocketRequestAbortOptions<Schema>) => void>>(),
   };
 
   protected constructor(options: { socketTimeout?: number; messageTimeout?: number }) {
@@ -71,11 +75,14 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     socket.addEventListener('error', handleSocketError);
 
     const handleSocketClose = () => {
+      this.sockets.delete(socket);
+
+      this.emitSocket('abortRequests', socket);
+      this.socketListeners.abortRequests.delete(socket);
+
       socket.removeEventListener('message', handleSocketMessage);
       socket.removeEventListener('close', handleSocketClose);
       socket.removeEventListener('error', handleSocketError);
-
-      this.removeSocket(socket);
     };
 
     socket.addEventListener('close', handleSocketClose);
@@ -154,6 +161,13 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     );
   }
 
+  isChannelEvent<Channel extends WebSocketChannel<Schema>>(
+    event: WebSocketEventMessage<Schema>,
+    channel: Channel,
+  ): event is WebSocketEventMessage<Schema, Channel> {
+    return event.channel === channel;
+  }
+
   private async notifyListeners(message: WebSocketMessage<Schema>, socket: ClientSocket) {
     if (this.isReplyMessage(message)) {
       await this.notifyReplyListeners(message, socket);
@@ -193,11 +207,6 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     await Promise.all(closingPromises);
   }
 
-  private removeSocket(socket: ClientSocket) {
-    this.abortSocketMessages([socket]);
-    this.sockets.delete(socket);
-  }
-
   private async createEventMessage<Channel extends WebSocketChannel<Schema>>(
     channel: Channel,
     eventData: WebSocketEventMessage<Schema, Channel>['data'],
@@ -233,43 +242,67 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     const request = await this.createEventMessage(channel, requestData);
     this.sendMessage(request, options.sockets);
 
-    const response = await this.waitForReply(channel, request.id, options.sockets);
+    const response = await this.waitForReply(channel, request, options.sockets);
     return response.data;
   }
 
   async waitForReply<Channel extends WebSocketChannelWithReply<Schema>>(
     channel: Channel,
-    requestId: WebSocketEventMessage<Schema, Channel>['id'],
+    request: WebSocketEventMessage<Schema, Channel>,
     sockets: Collection<ClientSocket> = this.sockets,
   ) {
     return new Promise<WebSocketReplyMessage<Schema, Channel>>((resolve, reject) => {
       const replyTimeout = setTimeout(() => {
-        this.offReply(channel, replyListener); // eslint-disable-line @typescript-eslint/no-use-before-define
-        this.offAbortSocketMessages(sockets, abortListener); // eslint-disable-line @typescript-eslint/no-use-before-define
+        this.offChannel('reply', channel, replyListener); // eslint-disable-line @typescript-eslint/no-use-before-define
+
+        for (const socket of sockets) {
+          this.offSocket('abortRequests', socket, abortRequestsHandler); // eslint-disable-line @typescript-eslint/no-use-before-define
+        }
 
         const timeoutError = new WebSocketMessageTimeoutError(this.messageTimeout);
         reject(timeoutError);
       }, this.messageTimeout);
 
-      const abortListener = this.onAbortSocketMessages(sockets, (error) => {
+      const replyListener = this.onChannel('reply', channel, (message) => {
+        if (message.requestId !== request.id) {
+          return;
+        }
+
         clearTimeout(replyTimeout);
 
-        this.offReply(channel, replyListener); // eslint-disable-line @typescript-eslint/no-use-before-define
-        this.offAbortSocketMessages(sockets, abortListener);
+        this.offChannel('reply', channel, replyListener);
+
+        for (const socket of sockets) {
+          this.offSocket('abortRequests', socket, abortRequestsHandler); // eslint-disable-line @typescript-eslint/no-use-before-define
+        }
 
-        reject(error);
+        resolve(message);
       });
 
-      const replyListener = this.onReply(channel, (message) => {
-        if (message.requestId === requestId) {
-          clearTimeout(replyTimeout);
+      const abortRequestsHandler = (options: WebSocketRequestAbortOptions<Schema>) => {
+        const shouldAbortRequest = options.shouldAbortRequest === undefined || options.shouldAbortRequest(request);
+
+        /* istanbul ignore if -- @preserve
+         * Aborting requests is highly non-deterministic because it depends on specific timing of socket events. */
+        if (!shouldAbortRequest) {
+          return;
+        }
+
+        clearTimeout(replyTimeout);
 
-          this.offReply(channel, replyListener);
-          this.offAbortSocketMessages(sockets, abortListener);
+        this.offChannel('reply', channel, replyListener);
 
-          resolve(message);
+        for (const socket of sockets) {
+          this.offSocket('abortRequests', socket, abortRequestsHandler);
         }
-      });
+
+        const abortError = new WebSocketMessageAbortError();
+        reject(abortError);
+      };
+
+      for (const socket of sockets) {
+        this.onSocket('abortRequests', socket, abortRequestsHandler);
+      }
     });
   }
 
@@ -322,12 +355,22 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     }
   }
 
-  onEvent<Channel extends WebSocketChannel<Schema>, Listener extends WebSocketEventMessageListener<Schema, Channel>>(
+  onChannel<Channel extends WebSocketChannel<Schema>, Listener extends WebSocketEventMessageListener<Schema, Channel>>(
+    type: 'event',
     channel: Channel,
-    listener: Listener,
-  ): Listener {
+    eventListener: Listener,
+  ): Listener;
+  onChannel<Channel extends WebSocketChannel<Schema>, Listener extends WebSocketReplyMessageListener<Schema, Channel>>(
+    type: 'reply',
+    channel: Channel,
+    replyListener: Listener,
+  ): Listener;
+  onChannel<
+    Channel extends WebSocketChannel<Schema>,
+    Listener extends WebSocketEventMessageListener<Schema, Channel> & WebSocketReplyMessageListener<Schema, Channel>,
+  >(type: 'event' | 'reply', channel: Channel, listener: Listener): Listener {
     const listeners = this.getOrCreateChannelListeners<Channel>(channel);
-    listeners.event.add(listener);
+    listeners[type].add(listener);
     return listener;
   }
 
@@ -344,59 +387,66 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     return listeners;
   }
 
-  onReply<
-    Channel extends WebSocketChannelWithReply<Schema>,
-    Listener extends WebSocketReplyMessageListener<Schema, Channel>,
-  >(channel: Channel, listener: Listener): Listener {
-    const listeners = this.getOrCreateChannelListeners<Channel>(channel);
-    listeners.reply.add(listener);
-    return listener;
-  }
-
-  offEvent<Channel extends WebSocketChannel<Schema>>(
+  offChannel<Channel extends WebSocketChannel<Schema>>(
+    type: 'event',
     channel: Channel,
-    listener: WebSocketEventMessageListener<Schema, Channel>,
-  ) {
-    this.channelListeners[channel]?.event.delete(listener);
-  }
-
-  offReply<Channel extends WebSocketChannelWithReply<Schema>>(
+    eventListener: WebSocketEventMessageListener<Schema, Channel>,
+  ): void;
+  offChannel<Channel extends WebSocketChannel<Schema>>(
+    type: 'reply',
+    channel: Channel,
+    replyListener: WebSocketReplyMessageListener<Schema, Channel>,
+  ): void;
+  offChannel<Channel extends WebSocketChannel<Schema>>(
+    type: 'event' | 'reply',
     channel: Channel,
-    listener: WebSocketReplyMessageListener<Schema, Channel>,
+    listener: WebSocketEventMessageListener<Schema, Channel> & WebSocketReplyMessageListener<Schema, Channel>,
   ) {
-    this.channelListeners[channel]?.reply.delete(listener);
+    const listeners = this.channelListeners[channel];
+    listeners?.[type].delete(listener);
   }
 
-  removeAllChannelListeners() {
-    this.channelListeners = {};
+  onSocket<Listener extends (options: WebSocketRequestAbortOptions<Schema>) => void>(
+    type: 'abortRequests',
+    socket: ClientSocket,
+    listener: Listener,
+  ): Listener {
+    const listeners = this.getOrCreateSocketListeners(type, socket);
+    listeners.add(listener);
+    return listener;
   }
 
-  private onAbortSocketMessages(sockets: Collection<ClientSocket>, listener: (error: unknown) => void) {
-    for (const socket of sockets) {
-      let listeners = this.socketListeners.messageAbort.get(socket);
-      if (!listeners) {
-        listeners = new Set();
-        this.socketListeners.messageAbort.set(socket, listeners);
-      }
-      listeners.add(listener);
+  private getOrCreateSocketListeners(type: 'abortRequests', socket: ClientSocket) {
+    const listeners = this.socketListeners[type].get(socket) ?? new Set();
+
+    if (!this.socketListeners[type].has(socket)) {
+      this.socketListeners[type].set(socket, listeners);
     }
 
-    return listener;
+    return listeners;
   }
 
-  private offAbortSocketMessages(sockets: Collection<ClientSocket>, listener: (error: unknown) => void) {
-    for (const socket of sockets) {
-      this.socketListeners.messageAbort.get(socket)?.delete(listener);
+  offSocket<Listener extends (options: WebSocketRequestAbortOptions<Schema>) => void>(
+    type: 'abortRequests',
+    socket: ClientSocket,
+    listener: Listener,
+  ) {
+    const listeners = this.socketListeners[type].get(socket);
+    listeners?.delete(listener);
+  }
+
+  emitSocket(type: 'abortRequests', socket: ClientSocket, options: WebSocketRequestAbortOptions<Schema> = {}) {
+    for (const listener of this.socketListeners[type].get(socket) ?? []) {
+      listener(options);
     }
   }
 
-  abortSocketMessages(sockets: Collection<ClientSocket> = this.sockets) {
-    const abortError = new WebSocketMessageAbortError();
+  offAny() {
+    this.channelListeners = {};
 
-    for (const socket of sockets) {
-      const listeners = this.socketListeners.messageAbort.get(socket) ?? [];
-      for (const listener of listeners) {
-        listener(abortError);
+    for (const listenersBySocket of Object.values(this.socketListeners)) {
+      for (const listeners of listenersBySocket.values()) {
+        listeners.clear();
       }
     }
   }