msw 2.2.2 → 2.3.0-ws.rc-1

package/lib/iife/index.js

@@ -41,7 +41,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 +403,9 @@ var MockServiceWorker = (() => {
     }
     restoreHandlers() {
       this.handlersController.currentHandlers().forEach((handler) => {
-        handler.isUsed = false;
+        if ("isUsed" in handler) {
+          handler.isUsed = false;
+        }
       });
     }
     resetHandlers(...nextHandlers) {
@@ -1121,7 +1124,7 @@ var MockServiceWorker = (() => {
     return stringToRegexp(path, keys, options);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/chunk-UJZOJSMP.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-UJZOJSMP.mjs
   var encoder = new TextEncoder();
   function encodeBuffer(text) {
     return encoder.encode(text);
@@ -1147,6 +1150,9 @@ var MockServiceWorker = (() => {
     return RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
   }
 
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/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
   function isNodeProcess() {
     if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
@@ -1434,8 +1440,7 @@ var MockServiceWorker = (() => {
     return message3.toString();
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/chunk-WZQN3FMY.mjs
-  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-SGO3INLV.mjs
   function getGlobalSymbol(symbol) {
     return (
       // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
@@ -1579,7 +1584,7 @@ var MockServiceWorker = (() => {
     }
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/index.mjs
   var BatchInterceptor = class extends Interceptor {
     constructor(options) {
       BatchInterceptor.symbol = Symbol(options.name);
@@ -1687,6 +1692,9 @@ var MockServiceWorker = (() => {
       params
     };
   }
+  function isPath(value) {
+    return typeof value === "string" || value instanceof RegExp;
+  }
 
   // src/core/utils/request/toPublicUrl.ts
   function toPublicUrl(url) {
@@ -5607,6 +5615,199 @@ 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 kDefaultPrevented = Symbol("kDefaultPrevented");
+  var WebSocketHandler = class {
+    constructor(url) {
+      this.url = url;
+      this[kEmitter] = new Emitter();
+    }
+    [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 shouldIntercept = this.predicate({ event, parsedResult });
+      if (!shouldIntercept) {
+        return;
+      }
+      if (!Reflect.get(event, kDefaultPrevented)) {
+        Reflect.set(event, kDefaultPrevented, true);
+      }
+      const connection = event.data;
+      this[kEmitter].emit("connection", {
+        client: connection.client,
+        server: connection.server,
+        params: parsedResult.match.params || {}
+      });
+    }
+  };
+
+  // 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 {
@@ -5629,6 +5830,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;
@@ -6481,14 +6685,7 @@ If this message still persists after updating, please report an issue: https://g
     }
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/chunk-72HT65NX.mjs
-  function uuidv4() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-      const r = Math.random() * 16 | 0;
-      const v = c == "x" ? r : r & 3 | 8;
-      return v.toString(16);
-    });
-  }
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-OUWBQF3Z.mjs
   var RequestController = class {
     constructor(request) {
       this.request = request;
@@ -6526,7 +6723,16 @@ If this message still persists after updating, please report an issue: https://g
     }
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/chunk-XQZ6GVNB.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-CEKC26XE.mjs
+  function uuidv4() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c == "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-65OQZE6W.mjs
   function isPropertyAccessible2(obj, key) {
     try {
       obj[key];
@@ -6673,7 +6879,7 @@ If this message still persists after updating, please report an issue: https://g
     });
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.16/node_modules/@mswjs/interceptors/lib/browser/chunk-DZVB7JEV.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/chunk-6ZIL5FW4.mjs
   function concatArrayBuffer(left, right) {
     const result = new Uint8Array(left.byteLength + right.byteLength);
     result.set(left, 0);
@@ -7272,7 +7478,11 @@ If this message still persists after updating, please report an issue: https://g
     const XMLHttpRequestProxy = new Proxy(globalThis.XMLHttpRequest, {
       construct(target, args, newTarget) {
         logger.info("constructed new XMLHttpRequest");
-        const originalRequest = Reflect.construct(target, args, newTarget);
+        const originalRequest = Reflect.construct(
+          target,
+          args,
+          newTarget
+        );
         const prototypeDescriptors = Object.getOwnPropertyDescriptors(
           target.prototype
         );
@@ -7491,6 +7701,475 @@ If this message still persists after updating, please report an issue: https://g
     }
   }
 
+  // node_modules/.pnpm/@mswjs+interceptors@0.26.8/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
+  function bindEvent(target, event) {
+    Object.defineProperty(event, "target", {
+      enumerable: true,
+      writable: true,
+      value: target
+    });
+    return event;
+  }
+  var kCancelable = Symbol("kCancelable");
+  var kDefaultPrevented2 = Symbol("kDefaultPrevented");
+  var CancelableMessageEvent = class extends MessageEvent {
+    constructor(type, init) {
+      super(type, init);
+      this[kCancelable] = !!init.cancelable;
+      this[kDefaultPrevented2] = false;
+    }
+    get cancelable() {
+      return this[kCancelable];
+    }
+    get defaultPrevented() {
+      return this[kDefaultPrevented2];
+    }
+    preventDefault() {
+      if (this.cancelable && !this[kDefaultPrevented2]) {
+        this[kDefaultPrevented2] = 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 = uuidv4();
+      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(event, listener, options) {
+      this[kEmitter2].addEventListener(event, 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 kEmitter22 = Symbol("kEmitter");
+  var WebSocketServerConnection = class {
+    constructor(socket, transport, createConnection) {
+      this.socket = socket;
+      this.transport = transport;
+      this.createConnection = createConnection;
+      this[kEmitter22] = new EventTarget();
+      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.readyState === -1,
+        'Failed to call "connect()" on the original WebSocket instance: the connection already open'
+      );
+      const ws2 = this.createConnection();
+      ws2.binaryType = this.socket.binaryType;
+      this.socket.addEventListener(
+        "close",
+        (event) => {
+          ws2.close(event.code, event.reason);
+        },
+        { once: true }
+      );
+      ws2.addEventListener("message", (event) => {
+        this.transport.onIncoming(event);
+      });
+      ws2.addEventListener("error", () => {
+        this.socket.dispatchEvent(bindEvent(this.socket, new Event("error")));
+      });
+      this.realWebSocket = ws2;
+    }
+    /**
+     * Listen for the incoming events from the original WebSocket server.
+     */
+    addEventListener(event, listener, options) {
+      this[kEmitter22].addEventListener(
+        event,
+        listener.bind(this.realWebSocket),
+        options
+      );
+    }
+    /**
+     * Removes 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 "await server.connect()"?',
+        this.socket.url
+      );
+      if (realWebSocket.readyState === realWebSocket.CONNECTING) {
+        realWebSocket.addEventListener(
+          "open",
+          () => {
+            realWebSocket.send(data);
+          },
+          { once: true }
+        );
+        return;
+      }
+      realWebSocket.send(data);
+    }
+  };
+  var WebSocketTransport = class {
+  };
+  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 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(getCurrentHandlers) {
+    webSocketInterceptor.on("connection", (connection) => {
+      const handlers = getCurrentHandlers();
+      const connectionEvent = new MessageEvent("connection", {
+        data: connection
+        /**
+         * @note This message event should be marked as "cancelable"
+         * to have its default prevented using "event.preventDefault()".
+         * There's a bug in Node.js that breaks the "cancelable" flag.
+         * @see https://github.com/nodejs/node/issues/51767
+         */
+      });
+      Object.defineProperty(connectionEvent, kDefaultPrevented, {
+        enumerable: false,
+        writable: true,
+        value: false
+      });
+      for (const handler of handlers) {
+        if (handler instanceof WebSocketHandler) {
+          handler[kDispatchEvent](connectionEvent);
+        }
+      }
+      if (!Reflect.get(connectionEvent, kDefaultPrevented)) {
+        connection.server.connect();
+        connection.client.addEventListener("message", (event) => {
+          connection.server.send(event.data);
+        });
+      }
+    });
+  }
+
   // src/browser/setupWorker/setupWorker.ts
   var SetupWorkerApi = class extends SetupApi {
     context;
@@ -7607,6 +8286,13 @@ If this message still persists after updating, please report an issue: https://g
         DEFAULT_START_OPTIONS,
         options
       );
+      handleWebSocketEvent(() => {
+        return this.handlersController.currentHandlers();
+      });
+      webSocketInterceptor.apply();
+      this.subscriptions.push(() => {
+        webSocketInterceptor.dispose();
+      });
       return await this.startHandler(this.context.startOptions, options);
     }
     stop() {