msw 2.2.13 → 2.3.0-ws.rc-2

package/lib/iife/index.js

@@ -32,6 +32,7 @@ var MockServiceWorker = (() => {
     SET_TIMEOUT_MAX_ALLOWED_INT: () => SET_TIMEOUT_MAX_ALLOWED_INT,
     SetupApi: () => SetupApi,
     SetupWorkerApi: () => SetupWorkerApi,
+    WebSocketHandler: () => WebSocketHandler,
     bypass: () => bypass,
     cleanUrl: () => cleanUrl,
     delay: () => delay,
@@ -41,7 +42,8 @@ var MockServiceWorker = (() => {
     http: () => http,
     matchRequestUrl: () => matchRequestUrl,
     passthrough: () => passthrough,
-    setupWorker: () => setupWorker
+    setupWorker: () => setupWorker,
+    ws: () => ws
   });
 
   // node_modules/.pnpm/outvariant@1.4.2/node_modules/outvariant/lib/index.mjs
@@ -402,7 +404,9 @@ var MockServiceWorker = (() => {
     }
     restoreHandlers() {
       this.handlersController.currentHandlers().forEach((handler) => {
-        handler.isUsed = false;
+        if ("isUsed" in handler) {
+          handler.isUsed = false;
+        }
       });
     }
     resetHandlers(...nextHandlers) {
@@ -623,9 +627,13 @@ var MockServiceWorker = (() => {
   }
 
   // src/core/utils/logging/getTimestamp.ts
-  function getTimestamp() {
+  function getTimestamp(options) {
     const now = /* @__PURE__ */ new Date();
-    return [now.getHours(), now.getMinutes(), now.getSeconds()].map(String).map((chunk) => chunk.slice(0, 2)).map((chunk) => chunk.padStart(2, "0")).join(":");
+    const timestamp = `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}`;
+    if (options?.milliseconds) {
+      return `${timestamp}.${now.getMilliseconds().toString().padStart(3, "0")}`;
+    }
+    return timestamp;
   }
 
   // src/core/utils/logging/serializeRequest.ts
@@ -1121,7 +1129,7 @@ var MockServiceWorker = (() => {
     return stringToRegexp(path, keys, options);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-UJZOJSMP.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-UJZOJSMP.mjs
   var encoder = new TextEncoder();
   function encodeBuffer(text) {
     return encoder.encode(text);
@@ -1147,7 +1155,7 @@ var MockServiceWorker = (() => {
     return RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-HAGW22AN.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-HAGW22AN.mjs
   var IS_PATCHED_MODULE = Symbol("isPatchedModule");
 
   // node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
@@ -1437,7 +1445,7 @@ var MockServiceWorker = (() => {
     return message3.toString();
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
   var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
   function getGlobalSymbol(symbol) {
     return (
@@ -1585,7 +1593,7 @@ var MockServiceWorker = (() => {
     return Math.random().toString(16).slice(2);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/index.mjs
   var BatchInterceptor = class extends Interceptor {
     constructor(options) {
       BatchInterceptor.symbol = Symbol(options.name);
@@ -1693,6 +1701,9 @@ var MockServiceWorker = (() => {
       params
     };
   }
+  function isPath(value) {
+    return typeof value === "string" || value instanceof RegExp;
+  }
 
   // src/core/utils/request/toPublicUrl.ts
   function toPublicUrl(url) {
@@ -5613,6 +5624,195 @@ Consider naming this operation or using "graphql.operation()" request handler to
     link: createGraphQLLink
   };
 
+  // src/core/handlers/WebSocketHandler.ts
+  var kEmitter = Symbol("kEmitter");
+  var kDispatchEvent = Symbol("kDispatchEvent");
+  var kSender = Symbol("kSender");
+  var WebSocketHandler = class {
+    constructor(url) {
+      this.url = url;
+      this[kEmitter] = new Emitter();
+      this.callFrame = getCallFrame(new Error());
+    }
+    callFrame;
+    [kEmitter];
+    parse(args) {
+      const connection = args.event.data;
+      const match2 = matchRequestUrl(connection.client.url, this.url);
+      return {
+        match: match2
+      };
+    }
+    predicate(args) {
+      return args.parsedResult.match.matches;
+    }
+    async [kDispatchEvent](event) {
+      const parsedResult = this.parse({ event });
+      const connection = event.data;
+      const resolvedConnection = {
+        client: connection.client,
+        server: connection.server,
+        params: parsedResult.match.params || {}
+      };
+      this[kEmitter].emit("connection", resolvedConnection);
+    }
+  };
+
+  // src/core/ws/WebSocketClientManager.ts
+  var kAddByClientId = Symbol("kAddByClientId");
+  var WebSocketClientManager = class {
+    constructor(channel) {
+      this.channel = channel;
+      this.clients = /* @__PURE__ */ new Set();
+      this.channel.addEventListener("message", (message3) => {
+        const { type, payload } = message3.data;
+        switch (type) {
+          case "connection:open": {
+            this.onRemoteConnection(payload.clientId, new URL(payload.url));
+            break;
+          }
+        }
+      });
+    }
+    /**
+     * All active WebSocket client connections.
+     */
+    clients;
+    /**
+     * Adds the given `WebSocket` client connection to the set
+     * of all connections. The given connection is always the complete
+     * connection object because `addConnection()` is called only
+     * for the opened connections in the same runtime.
+     */
+    addConnection(client) {
+      this.clients.add(client);
+      this.channel.postMessage({
+        type: "connection:open",
+        payload: {
+          clientId: client.id,
+          url: client.url.toString()
+        }
+      });
+      const handleExtraneousMessage = (message3) => {
+        const { type, payload } = message3.data;
+        if (typeof payload === "object" && "clientId" in payload && payload.clientId !== client.id) {
+          return;
+        }
+        switch (type) {
+          case "extraneous:send": {
+            client.send(payload.data);
+            break;
+          }
+          case "extraneous:close": {
+            client.close(payload.code, payload.reason);
+            break;
+          }
+        }
+      };
+      const abortController = new AbortController();
+      this.channel.addEventListener("message", handleExtraneousMessage, {
+        signal: abortController.signal
+      });
+      client.addEventListener("close", () => abortController.abort(), {
+        once: true
+      });
+    }
+    /**
+     * Adds a client connection wrapper to operate with
+     * WebSocket client connections in other runtimes.
+     */
+    onRemoteConnection(id, url) {
+      this.clients.add(
+        // Create a connection-compatible instance that can
+        // operate with this client from a different runtime
+        // using the BroadcastChannel messages.
+        new WebSocketRemoteClientConnection(id, url, this.channel)
+      );
+    }
+  };
+  var WebSocketRemoteClientConnection = class {
+    constructor(id, url, channel) {
+      this.id = id;
+      this.url = url;
+      this.channel = channel;
+    }
+    send(data) {
+      this.channel.postMessage({
+        type: "extraneous:send",
+        payload: {
+          clientId: this.id,
+          data
+        }
+      });
+    }
+    close(code, reason) {
+      this.channel.postMessage({
+        type: "extraneous:close",
+        payload: {
+          clientId: this.id,
+          code,
+          reason
+        }
+      });
+    }
+  };
+
+  // src/core/ws/ws.ts
+  var wsBroadcastChannel = new BroadcastChannel("msw:ws-client-manager");
+  function createWebSocketLinkHandler(url) {
+    invariant(url, "Expected a WebSocket server URL but got undefined");
+    invariant(
+      isPath(url),
+      "Expected a WebSocket server URL but got %s",
+      typeof url
+    );
+    const clientManager = new WebSocketClientManager(wsBroadcastChannel);
+    return {
+      clients: clientManager.clients,
+      on(event, listener) {
+        const handler = new WebSocketHandler(url);
+        handler[kEmitter].on("connection", ({ client }) => {
+          clientManager.addConnection(client);
+        });
+        handler[kEmitter].on(event, listener);
+        return handler;
+      },
+      /**
+       * Broadcasts the given data to all WebSocket clients.
+       *
+       * @example
+       * const service = ws.link('wss://example.com')
+       * service.on('connection', () => {
+       *   service.broadcast('hello, everyone!')
+       * })
+       */
+      broadcast(data) {
+        this.broadcastExcept([], data);
+      },
+      /**
+       * Broadcasts the given data to all WebSocket clients
+       * except the ones provided in the `clients` argument.
+       *
+       * @example
+       * const service = ws.link('wss://example.com')
+       * service.on('connection', ({ client }) => {
+       *   service.broadcastExcept(client, 'hi, the rest of you!')
+       * })
+       */
+      broadcastExcept(clients, data) {
+        const ignoreClients = Array.prototype.concat(clients).map((client) => client.id);
+        clientManager.clients.forEach((otherClient) => {
+          if (!ignoreClients.includes(otherClient.id)) {
+            otherClient.send(data);
+          }
+        });
+      }
+    };
+  }
+  var ws = {
+    link: createWebSocketLinkHandler
+  };
+
   // node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
   var until = async (promise) => {
     try {
@@ -5635,6 +5835,9 @@ Consider naming this operation or using "graphql.operation()" request handler to
     let matchingHandler = null;
     let result = null;
     for (const handler of handlers) {
+      if (!(handler instanceof RequestHandler)) {
+        continue;
+      }
       result = await handler.run({ request, requestId, resolutionContext });
       if (result !== null) {
         matchingHandler = handler;
@@ -6488,7 +6691,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-OUWBQF3Z.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-OUWBQF3Z.mjs
   var RequestController = class {
     constructor(request) {
       this.request = request;
@@ -6526,7 +6729,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-3FNUI33J.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-3FNUI33J.mjs
   function isPropertyAccessible2(obj, key) {
     try {
       obj[key];
@@ -6673,7 +6876,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     });
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.26.14/node_modules/@mswjs/interceptors/lib/browser/chunk-VYFS2IF2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/chunk-VYFS2IF2.mjs
   function concatArrayBuffer(left, right) {
     const result = new Uint8Array(left.byteLength + right.byteLength);
     result.set(left, 0);
@@ -7498,6 +7701,743 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   }
 
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.15/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
+  function bindEvent(target, event) {
+    Object.defineProperties(event, {
+      target: {
+        value: target,
+        enumerable: true,
+        writable: true
+      },
+      currentTarget: {
+        value: target,
+        enumerable: true,
+        writable: true
+      }
+    });
+    return event;
+  }
+  var kCancelable = Symbol("kCancelable");
+  var kDefaultPrevented = Symbol("kDefaultPrevented");
+  var CancelableMessageEvent = class extends MessageEvent {
+    constructor(type, init) {
+      super(type, init);
+      this[kCancelable] = !!init.cancelable;
+      this[kDefaultPrevented] = false;
+    }
+    get cancelable() {
+      return this[kCancelable];
+    }
+    get defaultPrevented() {
+      return this[kDefaultPrevented];
+    }
+    preventDefault() {
+      if (this.cancelable && !this[kDefaultPrevented]) {
+        this[kDefaultPrevented] = true;
+      }
+    }
+  };
+  var CloseEvent = class extends Event {
+    constructor(type, init = {}) {
+      super(type, init);
+      this.code = init.code === void 0 ? 0 : init.code;
+      this.reason = init.reason === void 0 ? "" : init.reason;
+      this.wasClean = init.wasClean === void 0 ? false : init.wasClean;
+    }
+  };
+  var kEmitter2 = Symbol("kEmitter");
+  var WebSocketClientConnection = class {
+    constructor(socket, transport) {
+      this.socket = socket;
+      this.transport = transport;
+      this.id = createRequestId();
+      this.url = new URL(socket.url);
+      this[kEmitter2] = new EventTarget();
+      this.transport.onOutgoing = (data) => {
+        this[kEmitter2].dispatchEvent(
+          bindEvent(this.socket, new MessageEvent("message", { data }))
+        );
+      };
+      this.transport.onClose = (event) => {
+        this[kEmitter2].dispatchEvent(
+          bindEvent(this.socket, new CloseEvent("close", event))
+        );
+      };
+    }
+    /**
+     * Listen for the outgoing events from the connected WebSocket client.
+     */
+    addEventListener(type, listener, options) {
+      this[kEmitter2].addEventListener(type, listener, options);
+    }
+    /**
+     * Removes the listener for the given event.
+     */
+    removeEventListener(event, listener, options) {
+      this[kEmitter2].removeEventListener(
+        event,
+        listener,
+        options
+      );
+    }
+    /**
+     * Send data to the connected client.
+     */
+    send(data) {
+      this.transport.send(data);
+    }
+    /**
+     * Close the WebSocket connection.
+     * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).
+     * @param {string} reason A custom connection close reason.
+     */
+    close(code, reason) {
+      this.transport.close(code, reason);
+    }
+  };
+  var WEBSOCKET_CLOSE_CODE_RANGE_ERROR = "InvalidAccessError: close code out of user configurable range";
+  var kOnSend = Symbol("kOnSend");
+  var kClose = Symbol("kClose");
+  var WebSocketOverride = class extends EventTarget {
+    constructor(url, protocols) {
+      super();
+      this.CONNECTING = 0;
+      this.OPEN = 1;
+      this.CLOSING = 2;
+      this.CLOSED = 3;
+      this._onopen = null;
+      this._onmessage = null;
+      this._onerror = null;
+      this._onclose = null;
+      this.url = url.toString();
+      this.protocol = "";
+      this.extensions = "";
+      this.binaryType = "blob";
+      this.readyState = this.CONNECTING;
+      this.bufferedAmount = 0;
+      Reflect.set(this, "readyState", this.CONNECTING);
+      queueMicrotask(() => {
+        Reflect.set(this, "readyState", this.OPEN);
+        this.protocol = protocols ? protocols[0] : "ws";
+        this.dispatchEvent(bindEvent(this, new Event("open")));
+      });
+    }
+    set onopen(listener) {
+      this.removeEventListener("open", this._onopen);
+      this._onopen = listener;
+      if (listener !== null) {
+        this.addEventListener("open", listener);
+      }
+    }
+    get onopen() {
+      return this._onopen;
+    }
+    set onmessage(listener) {
+      this.removeEventListener(
+        "message",
+        this._onmessage
+      );
+      this._onmessage = listener;
+      if (listener !== null) {
+        this.addEventListener("message", listener);
+      }
+    }
+    get onmessage() {
+      return this._onmessage;
+    }
+    set onerror(listener) {
+      this.removeEventListener("error", this._onerror);
+      this._onerror = listener;
+      if (listener !== null) {
+        this.addEventListener("error", listener);
+      }
+    }
+    get onerror() {
+      return this._onerror;
+    }
+    set onclose(listener) {
+      this.removeEventListener("close", this._onclose);
+      this._onclose = listener;
+      if (listener !== null) {
+        this.addEventListener("close", listener);
+      }
+    }
+    get onclose() {
+      return this._onclose;
+    }
+    /**
+     * @see https://websockets.spec.whatwg.org/#ref-for-dom-websocket-send%E2%91%A0
+     */
+    send(data) {
+      if (this.readyState === this.CONNECTING) {
+        this.close();
+        throw new DOMException("InvalidStateError");
+      }
+      if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+        return;
+      }
+      this.bufferedAmount += getDataSize(data);
+      queueMicrotask(() => {
+        var _a2;
+        this.bufferedAmount = 0;
+        (_a2 = this[kOnSend]) == null ? void 0 : _a2.call(this, data);
+      });
+    }
+    close(code = 1e3, reason) {
+      invariant(code, WEBSOCKET_CLOSE_CODE_RANGE_ERROR);
+      invariant(
+        code === 1e3 || code >= 3e3 && code <= 4999,
+        WEBSOCKET_CLOSE_CODE_RANGE_ERROR
+      );
+      if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+        return;
+      }
+      this[kClose](code, reason);
+    }
+    [(kOnSend, kClose)](code = 1e3, reason) {
+      this.readyState = this.CLOSING;
+      queueMicrotask(() => {
+        this.readyState = this.CLOSED;
+        if (code > 1e3 && code <= 1015) {
+          this.dispatchEvent(bindEvent(this, new Event("error")));
+        }
+        this.dispatchEvent(
+          bindEvent(
+            this,
+            new CloseEvent("close", {
+              code,
+              reason,
+              wasClean: code === 1e3
+            })
+          )
+        );
+        this._onopen = null;
+        this._onmessage = null;
+        this._onerror = null;
+        this._onclose = null;
+      });
+    }
+    addEventListener(type, listener, options) {
+      return super.addEventListener(
+        type,
+        listener,
+        options
+      );
+    }
+    removeEventListener(type, callback, options) {
+      return super.removeEventListener(type, callback, options);
+    }
+  };
+  WebSocketOverride.CONNECTING = 0;
+  WebSocketOverride.OPEN = 1;
+  WebSocketOverride.CLOSING = 2;
+  WebSocketOverride.CLOSED = 3;
+  function getDataSize(data) {
+    if (typeof data === "string") {
+      return data.length;
+    }
+    if (data instanceof Blob) {
+      return data.size;
+    }
+    return data.byteLength;
+  }
+  var kEmitter22 = Symbol("kEmitter");
+  var WebSocketServerConnection = class {
+    constructor(socket, transport, createConnection) {
+      this.socket = socket;
+      this.transport = transport;
+      this.createConnection = createConnection;
+      this[kEmitter22] = new EventTarget();
+      this.mockCloseController = new AbortController();
+      this.transport.onIncoming = (event) => {
+        const messageEvent = bindEvent(
+          this.realWebSocket,
+          new CancelableMessageEvent("message", {
+            data: event.data,
+            origin: event.origin,
+            cancelable: true
+          })
+        );
+        this[kEmitter22].dispatchEvent(messageEvent);
+        if (!messageEvent.defaultPrevented) {
+          this.socket.dispatchEvent(
+            bindEvent(
+              /**
+               * @note Bind the forwarded original server events
+               * to the mock WebSocket instance so it would
+               * dispatch them straight away.
+               */
+              this.socket,
+              // Clone the message event again to prevent
+              // the "already being dispatched" exception.
+              new MessageEvent("message", {
+                data: event.data,
+                origin: event.origin
+              })
+            )
+          );
+        }
+      };
+    }
+    /**
+     * Server ready state.
+     * Proxies the ready state of the original WebSocket instance,
+     * if set. If the original connection hasn't been established,
+     * defaults to `-1`.
+     */
+    get readyState() {
+      if (this.realWebSocket) {
+        return this.realWebSocket.readyState;
+      }
+      return -1;
+    }
+    /**
+     * Open connection to the original WebSocket server.
+     */
+    connect() {
+      invariant(
+        !this.realWebSocket || this.realWebSocket.readyState !== WebSocket.OPEN,
+        'Failed to call "connect()" on the original WebSocket instance: the connection already open'
+      );
+      const realWebSocket = this.createConnection();
+      realWebSocket.binaryType = this.socket.binaryType;
+      realWebSocket.addEventListener(
+        "open",
+        (event) => {
+          this[kEmitter22].dispatchEvent(
+            bindEvent(this.realWebSocket, new Event("open", event))
+          );
+        },
+        { once: true }
+      );
+      realWebSocket.addEventListener("message", (event) => {
+        this.transport.onIncoming(event);
+      });
+      this.socket.addEventListener("close", this.handleMockClose.bind(this), {
+        signal: this.mockCloseController.signal
+      });
+      realWebSocket.addEventListener("close", this.handleRealClose.bind(this));
+      realWebSocket.addEventListener("error", () => {
+        this.socket.dispatchEvent(bindEvent(this.socket, new Event("error")));
+      });
+      this.realWebSocket = realWebSocket;
+    }
+    /**
+     * Listen for the incoming events from the original WebSocket server.
+     */
+    addEventListener(event, listener, options) {
+      this[kEmitter22].addEventListener(
+        event,
+        listener.bind(this.realWebSocket),
+        options
+      );
+    }
+    /**
+     * Remove the listener for the given event.
+     */
+    removeEventListener(event, listener, options) {
+      this[kEmitter22].removeEventListener(
+        event,
+        listener,
+        options
+      );
+    }
+    /**
+     * Send data to the original WebSocket server.
+     * @example
+     * server.send('hello')
+     * server.send(new Blob(['hello']))
+     * server.send(new TextEncoder().encode('hello'))
+     */
+    send(data) {
+      const { realWebSocket } = this;
+      invariant(
+        realWebSocket,
+        'Failed to call "server.send()" for "%s": the connection is not open. Did you forget to call "server.connect()"?',
+        this.socket.url
+      );
+      if (realWebSocket.readyState === WebSocket.CLOSING || realWebSocket.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      if (realWebSocket.readyState === WebSocket.CONNECTING) {
+        realWebSocket.addEventListener(
+          "open",
+          () => {
+            realWebSocket.send(data);
+          },
+          { once: true }
+        );
+        return;
+      }
+      realWebSocket.send(data);
+    }
+    /**
+     * Close the actual server connection.
+     */
+    close() {
+      const { realWebSocket } = this;
+      invariant(
+        realWebSocket,
+        'Failed to close server connection for "%s": the connection is not open. Did you forget to call "server.connect()"?',
+        this.socket.url
+      );
+      realWebSocket.removeEventListener("close", this.handleRealClose);
+      if (realWebSocket.readyState === WebSocket.CLOSING || realWebSocket.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      realWebSocket.close();
+      queueMicrotask(() => {
+        this[kEmitter22].dispatchEvent(
+          bindEvent(this.realWebSocket, new CloseEvent("close"))
+        );
+      });
+    }
+    handleMockClose(_event) {
+      if (this.realWebSocket) {
+        this.realWebSocket.close();
+      }
+    }
+    handleRealClose(event) {
+      this.mockCloseController.abort();
+      const closeEvent = bindEvent(
+        this.realWebSocket,
+        new CloseEvent("close", event)
+      );
+      this[kEmitter22].dispatchEvent(closeEvent);
+      if (!closeEvent.defaultPrevented) {
+        this.socket[kClose](event.code, event.reason);
+      }
+    }
+  };
+  var WebSocketTransport = class {
+  };
+  var WebSocketClassTransport = class extends WebSocketTransport {
+    constructor(socket) {
+      super();
+      this.socket = socket;
+      this.onOutgoing = () => {
+      };
+      this.onIncoming = () => {
+      };
+      this.onClose = () => {
+      };
+      this.socket.addEventListener("close", (event) => this.onClose(event), {
+        once: true
+      });
+      this.socket[kOnSend] = (...args) => this.onOutgoing(...args);
+    }
+    send(data) {
+      queueMicrotask(() => {
+        const message3 = bindEvent(
+          /**
+           * @note Setting this event's "target" to the
+           * WebSocket override instance is important.
+           * This way it can tell apart original incoming events
+           * (must be forwarded to the transport) from the
+           * mocked message events like the one below
+           * (must be dispatched on the client instance).
+           */
+          this.socket,
+          new MessageEvent("message", {
+            data,
+            origin: this.socket.url
+          })
+        );
+        this.socket.dispatchEvent(message3);
+      });
+    }
+    close(code, reason) {
+      this.socket[kClose](code, reason);
+    }
+  };
+  var _WebSocketInterceptor = class extends Interceptor {
+    constructor() {
+      super(_WebSocketInterceptor.symbol);
+    }
+    checkEnvironment() {
+      return typeof globalThis.WebSocket !== "undefined";
+    }
+    setup() {
+      const originalWebSocket = globalThis.WebSocket;
+      const webSocketProxy = new Proxy(globalThis.WebSocket, {
+        construct: (target, args, newTarget) => {
+          const [url, protocols] = args;
+          const createConnection = () => {
+            return Reflect.construct(target, args, newTarget);
+          };
+          const socket = new WebSocketOverride(url, protocols);
+          const transport = new WebSocketClassTransport(socket);
+          queueMicrotask(() => {
+            this.emitter.emit("connection", {
+              client: new WebSocketClientConnection(socket, transport),
+              server: new WebSocketServerConnection(
+                socket,
+                transport,
+                createConnection
+              )
+            });
+          });
+          return socket;
+        }
+      });
+      globalThis.WebSocket = webSocketProxy;
+      this.subscriptions.push(() => {
+        globalThis.WebSocket = originalWebSocket;
+      });
+    }
+  };
+  var WebSocketInterceptor = _WebSocketInterceptor;
+  WebSocketInterceptor.symbol = Symbol("websocket");
+
+  // src/core/ws/webSocketInterceptor.ts
+  var webSocketInterceptor = new WebSocketInterceptor();
+
+  // src/core/utils/handleWebSocketEvent.ts
+  function handleWebSocketEvent(options) {
+    webSocketInterceptor.on("connection", (connection) => {
+      const handlers = options.getHandlers();
+      const connectionEvent = new MessageEvent("connection", {
+        data: connection
+      });
+      const matchingHandlers = handlers.filter(
+        (handler) => {
+          if (handler instanceof WebSocketHandler) {
+            return handler.predicate({
+              event: connectionEvent,
+              parsedResult: handler.parse({
+                event: connectionEvent
+              })
+            });
+          }
+          return false;
+        }
+      );
+      if (matchingHandlers.length > 0) {
+        options?.onMockedConnection(connection);
+        for (const handler of matchingHandlers) {
+          handler[kDispatchEvent](connectionEvent);
+        }
+      } else {
+        options?.onPassthroughConnection(connection);
+        connection.server.connect();
+        connection.client.addEventListener("message", (event) => {
+          connection.server.send(event.data);
+        });
+      }
+    });
+  }
+
+  // src/core/ws/utils/getMessageLength.ts
+  function getMessageLength(data) {
+    if (data instanceof Blob) {
+      return data.size;
+    }
+    if (data instanceof ArrayBuffer) {
+      return data.byteLength;
+    }
+    return new Blob([data]).size;
+  }
+
+  // src/core/ws/utils/truncateMessage.ts
+  var MAX_LENGTH = 24;
+  function truncateMessage(message3) {
+    if (message3.length <= MAX_LENGTH) {
+      return message3;
+    }
+    return `${message3.slice(0, MAX_LENGTH)}\u2026`;
+  }
+
+  // src/core/ws/utils/getPublicData.ts
+  async function getPublicData(data) {
+    if (data instanceof Blob) {
+      const text = await data.text();
+      return `Blob(${truncateMessage(text)})`;
+    }
+    if (typeof data === "object" && "byteLength" in data) {
+      const text = new TextDecoder().decode(data);
+      return `ArrayBuffer(${truncateMessage(text)})`;
+    }
+    return truncateMessage(data);
+  }
+
+  // src/core/ws/utils/attachWebSocketLogger.ts
+  function attachWebSocketLogger(connection) {
+    const { client, server } = connection;
+    logConnectionOpen(client);
+    client.addEventListener("message", (event) => {
+      logOutgoingClientMessage(event);
+    });
+    client.addEventListener("close", (event) => {
+      logConnectionClose(event);
+    });
+    client.socket.addEventListener("message", (event) => {
+      logIncomingClientMessage(event);
+    });
+    client.socket.addEventListener("error", (event) => {
+      logClientError(event);
+    });
+    client.send = new Proxy(client.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          }
+        });
+        logIncomingMockedClientMessage(messageEvent);
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+    server.addEventListener(
+      "open",
+      () => {
+        server.addEventListener("message", (event) => {
+          logIncomingServerMessage(event);
+        });
+      },
+      { once: true }
+    );
+    server.send = new Proxy(server.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: server["realWebSocket"]
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: server["realWebSocket"]
+          }
+        });
+        logOutgoingMockedClientMessage(messageEvent);
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+  }
+  function logConnectionOpen(client) {
+    const publicUrl = toPublicUrl(client.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(`${getTimestamp()} %c\u25B8%c ${publicUrl}`),
+      "color:blue",
+      "color:inherit"
+    );
+    console.log("Client:", client.socket);
+    console.groupEnd();
+  }
+  async function logOutgoingClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2191%c ${publicData} %c${byteLength}%c`
+      ),
+      "color:green",
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u21E1%c ${publicData} %c${byteLength}%c`
+      ),
+      "color:orangered",
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2193%c ${publicData} %c${byteLength}%c`
+      ),
+      "color:red",
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u21E3%c ${publicData} %c${byteLength}%c`
+      ),
+      "color:orangered",
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  function logConnectionClose(event) {
+    const target = event.target;
+    const publicUrl = toPublicUrl(target.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u25A0%c ${publicUrl}`
+      ),
+      "color:blue",
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingServerMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u21E3%c ${publicData} %c${byteLength}%c`
+      ),
+      "color:orangered",
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  function logClientError(event) {
+    const socket = event.target;
+    const publicUrl = toPublicUrl(socket.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\xD7%c ${publicUrl}`
+      ),
+      "color:red",
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+
   // src/browser/setupWorker/setupWorker.ts
   var SetupWorkerApi = class extends SetupApi {
     context;
@@ -7614,6 +8554,22 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         DEFAULT_START_OPTIONS,
         options
       );
+      handleWebSocketEvent({
+        getHandlers: () => {
+          return this.handlersController.currentHandlers();
+        },
+        onMockedConnection: (connection) => {
+          if (!this.context.startOptions.quiet) {
+            attachWebSocketLogger(connection);
+          }
+        },
+        onPassthroughConnection() {
+        }
+      });
+      webSocketInterceptor.apply();
+      this.subscriptions.push(() => {
+        webSocketInterceptor.dispose();
+      });
       return await this.startHandler(this.context.startOptions, options);
     }
     stop() {