msw 2.5.2 → 2.6.1

package/lib/iife/index.js

@@ -13336,6 +13336,7 @@ ${operationTypes.join("\n")}
     SET_TIMEOUT_MAX_ALLOWED_INT: () => SET_TIMEOUT_MAX_ALLOWED_INT,
     SetupApi: () => SetupApi,
     SetupWorkerApi: () => SetupWorkerApi,
+    WebSocketHandler: () => WebSocketHandler,
     bypass: () => bypass,
     cleanUrl: () => cleanUrl,
     delay: () => delay,
@@ -13345,7 +13346,8 @@ ${operationTypes.join("\n")}
     http: () => http,
     matchRequestUrl: () => matchRequestUrl,
     passthrough: () => passthrough,
-    setupWorker: () => setupWorker
+    setupWorker: () => setupWorker,
+    ws: () => ws
   });
 
   // node_modules/.pnpm/outvariant@1.4.3/node_modules/outvariant/lib/index.mjs
@@ -13717,7 +13719,9 @@ ${operationTypes.join("\n")}
     }
     restoreHandlers() {
       this.handlersController.currentHandlers().forEach((handler) => {
-        handler.isUsed = false;
+        if ("isUsed" in handler) {
+          handler.isUsed = false;
+        }
       });
     }
     resetHandlers(...nextHandlers) {
@@ -13771,6 +13775,7 @@ ${operationTypes.join("\n")}
   // src/core/handlers/RequestHandler.ts
   var RequestHandler = class _RequestHandler {
     static cache = /* @__PURE__ */ new WeakMap();
+    __kind;
     info;
     /**
      * Indicates whether this request handler has been used
@@ -13790,6 +13795,7 @@ ${operationTypes.join("\n")}
         callFrame
       };
       this.isUsed = false;
+      this.__kind = "RequestHandler";
     }
     /**
      * Parse the intercepted request to extract additional information from it.
@@ -13932,9 +13938,13 @@ ${operationTypes.join("\n")}
   }
 
   // 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
@@ -15057,6 +15067,9 @@ ${operationTypes.join("\n")}
       params
     };
   }
+  function isPath(value) {
+    return typeof value === "string" || value instanceof RegExp;
+  }
 
   // src/core/utils/request/toPublicUrl.ts
   function toPublicUrl(url) {
@@ -28154,6 +28167,460 @@ 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 kStopPropagationPatched = Symbol("kStopPropagationPatched");
+  var KOnStopPropagation = Symbol("KOnStopPropagation");
+  var WebSocketHandler = class {
+    constructor(url) {
+      this.url = url;
+      this.id = createRequestId();
+      this[kEmitter] = new Emitter();
+      this.callFrame = getCallFrame(new Error());
+      this.__kind = "EventHandler";
+    }
+    __kind;
+    id;
+    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 = {
+        ...connection,
+        params: parsedResult.match.params || {}
+      };
+      connection.client.addEventListener(
+        "message",
+        createStopPropagationListener(this)
+      );
+      connection.client.addEventListener(
+        "close",
+        createStopPropagationListener(this)
+      );
+      connection.server.addEventListener(
+        "open",
+        createStopPropagationListener(this)
+      );
+      connection.server.addEventListener(
+        "message",
+        createStopPropagationListener(this)
+      );
+      connection.server.addEventListener(
+        "error",
+        createStopPropagationListener(this)
+      );
+      connection.server.addEventListener(
+        "close",
+        createStopPropagationListener(this)
+      );
+      this[kEmitter].emit("connection", resolvedConnection);
+    }
+  };
+  function createStopPropagationListener(handler) {
+    return function stopPropagationListener(event) {
+      const propagationStoppedAt = Reflect.get(event, "kPropagationStoppedAt");
+      if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
+        event.stopImmediatePropagation();
+        return;
+      }
+      Object.defineProperty(event, KOnStopPropagation, {
+        value() {
+          Object.defineProperty(event, "kPropagationStoppedAt", {
+            value: handler.id
+          });
+        },
+        configurable: true
+      });
+      if (!Reflect.get(event, kStopPropagationPatched)) {
+        event.stopPropagation = new Proxy(event.stopPropagation, {
+          apply: (target, thisArg, args) => {
+            Reflect.get(event, KOnStopPropagation)?.call(handler);
+            return Reflect.apply(target, thisArg, args);
+          }
+        });
+        Object.defineProperty(event, kStopPropagationPatched, {
+          value: true,
+          // If something else attempts to redefine this, throw.
+          configurable: false
+        });
+      }
+    };
+  }
+
+  // src/core/ws/WebSocketMemoryClientStore.ts
+  var WebSocketMemoryClientStore = class {
+    store;
+    constructor() {
+      this.store = /* @__PURE__ */ new Map();
+    }
+    async add(client) {
+      this.store.set(client.id, { id: client.id, url: client.url.href });
+    }
+    getAll() {
+      return Promise.resolve(Array.from(this.store.values()));
+    }
+    async deleteMany(clientIds) {
+      for (const clientId of clientIds) {
+        this.store.delete(clientId);
+      }
+    }
+  };
+
+  // node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+  function createDeferredExecutor() {
+    const executor = (resolve, reject) => {
+      executor.state = "pending";
+      executor.resolve = (data) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        executor.result = data;
+        const onFulfilled = (value) => {
+          executor.state = "fulfilled";
+          return value;
+        };
+        return resolve(
+          data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+        );
+      };
+      executor.reject = (reason) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        queueMicrotask(() => {
+          executor.state = "rejected";
+        });
+        return reject(executor.rejectionReason = reason);
+      };
+    };
+    return executor;
+  }
+  var DeferredPromise = class extends Promise {
+    #executor;
+    resolve;
+    reject;
+    constructor(executor = null) {
+      const deferredExecutor = createDeferredExecutor();
+      super((originalResolve, originalReject) => {
+        deferredExecutor(originalResolve, originalReject);
+        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+      });
+      this.#executor = deferredExecutor;
+      this.resolve = this.#executor.resolve;
+      this.reject = this.#executor.reject;
+    }
+    get state() {
+      return this.#executor.state;
+    }
+    get rejectionReason() {
+      return this.#executor.rejectionReason;
+    }
+    then(onFulfilled, onRejected) {
+      return this.#decorate(super.then(onFulfilled, onRejected));
+    }
+    catch(onRejected) {
+      return this.#decorate(super.catch(onRejected));
+    }
+    finally(onfinally) {
+      return this.#decorate(super.finally(onfinally));
+    }
+    #decorate(promise) {
+      return Object.defineProperties(promise, {
+        resolve: { configurable: true, value: this.resolve },
+        reject: { configurable: true, value: this.reject }
+      });
+    }
+  };
+
+  // src/core/ws/WebSocketIndexedDBClientStore.ts
+  var DB_NAME = "msw-websocket-clients";
+  var DB_STORE_NAME = "clients";
+  var WebSocketIndexedDBClientStore = class {
+    db;
+    constructor() {
+      this.db = this.createDatabase();
+    }
+    async add(client) {
+      const promise = new DeferredPromise();
+      const store2 = await this.getStore();
+      const request = store2.put({
+        id: client.id,
+        url: client.url.href
+      });
+      request.onsuccess = () => {
+        promise.resolve();
+      };
+      request.onerror = () => {
+        console.error(request.error);
+        promise.reject(
+          new Error(
+            `Failed to add WebSocket client "${client.id}". There is likely an additional output above.`
+          )
+        );
+      };
+      return promise;
+    }
+    async getAll() {
+      const promise = new DeferredPromise();
+      const store2 = await this.getStore();
+      const request = store2.getAll();
+      request.onsuccess = () => {
+        promise.resolve(request.result);
+      };
+      request.onerror = () => {
+        console.log(request.error);
+        promise.reject(
+          new Error(
+            `Failed to get all WebSocket clients. There is likely an additional output above.`
+          )
+        );
+      };
+      return promise;
+    }
+    async deleteMany(clientIds) {
+      const promise = new DeferredPromise();
+      const store2 = await this.getStore();
+      for (const clientId of clientIds) {
+        store2.delete(clientId);
+      }
+      store2.transaction.oncomplete = () => {
+        promise.resolve();
+      };
+      store2.transaction.onerror = () => {
+        console.error(store2.transaction.error);
+        promise.reject(
+          new Error(
+            `Failed to delete WebSocket clients [${clientIds.join(", ")}]. There is likely an additional output above.`
+          )
+        );
+      };
+      return promise;
+    }
+    async createDatabase() {
+      const promise = new DeferredPromise();
+      const request = indexedDB.open(DB_NAME, 1);
+      request.onsuccess = ({ currentTarget }) => {
+        const db = Reflect.get(currentTarget, "result");
+        if (db.objectStoreNames.contains(DB_STORE_NAME)) {
+          return promise.resolve(db);
+        }
+      };
+      request.onupgradeneeded = async ({ currentTarget }) => {
+        const db = Reflect.get(currentTarget, "result");
+        if (db.objectStoreNames.contains(DB_STORE_NAME)) {
+          return;
+        }
+        const store2 = db.createObjectStore(DB_STORE_NAME, { keyPath: "id" });
+        store2.transaction.oncomplete = () => {
+          promise.resolve(db);
+        };
+        store2.transaction.onerror = () => {
+          console.error(store2.transaction.error);
+          promise.reject(
+            new Error(
+              "Failed to create WebSocket client store. There is likely an additional output above."
+            )
+          );
+        };
+      };
+      request.onerror = () => {
+        console.error(request.error);
+        promise.reject(
+          new Error(
+            "Failed to open an IndexedDB database. There is likely an additional output above."
+          )
+        );
+      };
+      return promise;
+    }
+    async getStore() {
+      const db = await this.db;
+      return db.transaction(DB_STORE_NAME, "readwrite").objectStore(DB_STORE_NAME);
+    }
+  };
+
+  // src/core/ws/WebSocketClientManager.ts
+  var WebSocketClientManager = class {
+    constructor(channel) {
+      this.channel = channel;
+      this.store = typeof indexedDB !== "undefined" ? new WebSocketIndexedDBClientStore() : new WebSocketMemoryClientStore();
+      this.runtimeClients = /* @__PURE__ */ new Map();
+      this.allClients = /* @__PURE__ */ new Set();
+      this.channel.addEventListener("message", (message3) => {
+        if (message3.data?.type === "db:update") {
+          this.flushDatabaseToMemory();
+        }
+      });
+      if (typeof window !== "undefined") {
+        window.addEventListener("message", async (message3) => {
+          if (message3.data?.type === "msw/worker:stop") {
+            await this.removeRuntimeClients();
+          }
+        });
+      }
+    }
+    store;
+    runtimeClients;
+    allClients;
+    async flushDatabaseToMemory() {
+      const storedClients = await this.store.getAll();
+      this.allClients = new Set(
+        storedClients.map((client) => {
+          const runtimeClient = this.runtimeClients.get(client.id);
+          if (runtimeClient) {
+            return runtimeClient;
+          }
+          return new WebSocketRemoteClientConnection(
+            client.id,
+            new URL(client.url),
+            this.channel
+          );
+        })
+      );
+    }
+    async removeRuntimeClients() {
+      await this.store.deleteMany(Array.from(this.runtimeClients.keys()));
+      this.runtimeClients.clear();
+      await this.flushDatabaseToMemory();
+      this.notifyOthersAboutDatabaseUpdate();
+    }
+    /**
+     * All active WebSocket client connections.
+     */
+    get clients() {
+      return this.allClients;
+    }
+    /**
+     * Notify other runtimes about the database update
+     * using the shared `BroadcastChannel` instance.
+     */
+    notifyOthersAboutDatabaseUpdate() {
+      this.channel.postMessage({ type: "db:update" });
+    }
+    async addClient(client) {
+      await this.store.add(client);
+      await this.flushDatabaseToMemory();
+      this.notifyOthersAboutDatabaseUpdate();
+    }
+    /**
+     * 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.
+     */
+    async addConnection(client) {
+      this.runtimeClients.set(client.id, client);
+      await this.addClient(client);
+      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
+      });
+    }
+  };
+  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.ts
+  function isBroadcastChannelWithUnref(channel) {
+    return typeof Reflect.get(channel, "unref") !== "undefined";
+  }
+  var webSocketChannel = new BroadcastChannel("msw:websocket-client-manager");
+  if (isBroadcastChannelWithUnref(webSocketChannel)) {
+    webSocketChannel.unref();
+  }
+  function createWebSocketLinkHandler(url) {
+    invariant(url, "Expected a WebSocket server URL but got undefined");
+    invariant(
+      isPath(url),
+      "Expected a WebSocket server URL to be a valid path but got %s",
+      typeof url
+    );
+    const clientManager = new WebSocketClientManager(webSocketChannel);
+    return {
+      get clients() {
+        return clientManager.clients;
+      },
+      addEventListener(event, listener) {
+        const handler = new WebSocketHandler(url);
+        handler[kEmitter].on("connection", async ({ client }) => {
+          await clientManager.addConnection(client);
+        });
+        handler[kEmitter].on(event, listener);
+        return handler;
+      },
+      broadcast(data) {
+        this.broadcastExcept([], data);
+      },
+      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 {
@@ -28700,6 +29167,13 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     };
   }
 
+  // src/core/utils/internal/isHandlerKind.ts
+  function isHandlerKind(kind) {
+    return (input) => {
+      return input != null && typeof input === "object" && "__kind" in input && input.__kind === kind;
+    };
+  }
+
   // src/browser/setupWorker/start/createRequestListener.ts
   var createRequestListener = (context, options) => {
     return async (event, message3) => {
@@ -28714,7 +29188,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
         await handleRequest(
           request,
           requestId,
-          context.getRequestHandlers(),
+          context.getRequestHandlers().filter(isHandlerKind("RequestHandler")),
           options,
           context.emitter,
           {
@@ -28892,6 +29366,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
             context.workerChannel.send("CLIENT_CLOSED");
           }
           window.clearInterval(context.keepAliveInterval);
+          window.postMessage({ type: "msw/worker:stop" });
         });
         await checkWorkerIntegrity(context).catch((error3) => {
           devUtils.error(
@@ -28951,6 +29426,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       context.workerChannel.send("MOCK_DEACTIVATE");
       context.isMockingEnabled = false;
       window.clearInterval(context.keepAliveInterval);
+      window.postMessage({ type: "msw/worker:stop" });
       printStopMessage({ quiet: context.startOptions?.quiet });
     };
   };
@@ -28994,87 +29470,21 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
-  // node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
-  function createDeferredExecutor() {
-    const executor = (resolve, reject) => {
-      executor.state = "pending";
-      executor.resolve = (data) => {
-        if (executor.state !== "pending") {
-          return;
-        }
-        executor.result = data;
-        const onFulfilled = (value) => {
-          executor.state = "fulfilled";
-          return value;
-        };
-        return resolve(
-          data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
-        );
-      };
-      executor.reject = (reason) => {
-        if (executor.state !== "pending") {
-          return;
-        }
-        queueMicrotask(() => {
-          executor.state = "rejected";
-        });
-        return reject(executor.rejectionReason = reason);
-      };
-    };
-    return executor;
-  }
-  var DeferredPromise = class extends Promise {
-    #executor;
-    resolve;
-    reject;
-    constructor(executor = null) {
-      const deferredExecutor = createDeferredExecutor();
-      super((originalResolve, originalReject) => {
-        deferredExecutor(originalResolve, originalReject);
-        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
-      });
-      this.#executor = deferredExecutor;
-      this.resolve = this.#executor.resolve;
-      this.reject = this.#executor.reject;
-    }
-    get state() {
-      return this.#executor.state;
+  // node_modules/.pnpm/@mswjs+interceptors@0.36.5/node_modules/@mswjs/interceptors/lib/browser/chunk-THPGBWJQ.mjs
+  var InterceptorError = class extends Error {
+    constructor(message3) {
+      super(message3);
+      this.name = "InterceptorError";
+      Object.setPrototypeOf(this, InterceptorError.prototype);
     }
-    get rejectionReason() {
-      return this.#executor.rejectionReason;
-    }
-    then(onFulfilled, onRejected) {
-      return this.#decorate(super.then(onFulfilled, onRejected));
-    }
-    catch(onRejected) {
-      return this.#decorate(super.catch(onRejected));
-    }
-    finally(onfinally) {
-      return this.#decorate(super.finally(onfinally));
-    }
-    #decorate(promise) {
-      return Object.defineProperties(promise, {
-        resolve: { configurable: true, value: this.resolve },
-        reject: { configurable: true, value: this.reject }
-      });
-    }
-  };
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.36.5/node_modules/@mswjs/interceptors/lib/browser/chunk-THPGBWJQ.mjs
-  var InterceptorError = class extends Error {
-    constructor(message3) {
-      super(message3);
-      this.name = "InterceptorError";
-      Object.setPrototypeOf(this, InterceptorError.prototype);
-    }
-  };
-  var kRequestHandled = Symbol("kRequestHandled");
-  var kResponsePromise = Symbol("kResponsePromise");
-  var RequestController = class {
-    constructor(request) {
-      this.request = request;
-      this[kRequestHandled] = false;
-      this[kResponsePromise] = new DeferredPromise();
+  };
+  var kRequestHandled = Symbol("kRequestHandled");
+  var kResponsePromise = Symbol("kResponsePromise");
+  var RequestController = class {
+    constructor(request) {
+      this.request = request;
+      this[kRequestHandled] = false;
+      this[kResponsePromise] = new DeferredPromise();
     }
     /**
      * Respond to this request with the given `Response` instance.
@@ -30221,7 +30631,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       const response = await handleRequest(
         request,
         requestId,
-        context.getRequestHandlers(),
+        context.getRequestHandlers().filter(isHandlerKind("RequestHandler")),
         options,
         context.emitter,
         {
@@ -30296,6 +30706,911 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   }
 
+  // node_modules/.pnpm/@mswjs+interceptors@0.36.5/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];
+    }
+    set cancelable(nextCancelable) {
+      this[kCancelable] = nextCancelable;
+    }
+    get defaultPrevented() {
+      return this[kDefaultPrevented];
+    }
+    set defaultPrevented(nextDefaultPrevented) {
+      this[kDefaultPrevented] = nextDefaultPrevented;
+    }
+    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 CancelableCloseEvent = class extends CloseEvent {
+    constructor(type, init = {}) {
+      super(type, init);
+      this[kCancelable] = !!init.cancelable;
+      this[kDefaultPrevented] = false;
+    }
+    get cancelable() {
+      return this[kCancelable];
+    }
+    set cancelable(nextCancelable) {
+      this[kCancelable] = nextCancelable;
+    }
+    get defaultPrevented() {
+      return this[kDefaultPrevented];
+    }
+    set defaultPrevented(nextDefaultPrevented) {
+      this[kDefaultPrevented] = nextDefaultPrevented;
+    }
+    preventDefault() {
+      if (this.cancelable && !this[kDefaultPrevented]) {
+        this[kDefaultPrevented] = true;
+      }
+    }
+  };
+  var kEmitter2 = Symbol("kEmitter");
+  var kBoundListener = Symbol("kBoundListener");
+  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.addEventListener("outgoing", (event) => {
+        const message3 = bindEvent(
+          this.socket,
+          new CancelableMessageEvent("message", {
+            data: event.data,
+            origin: event.origin,
+            cancelable: true
+          })
+        );
+        this[kEmitter2].dispatchEvent(message3);
+        if (message3.defaultPrevented) {
+          event.preventDefault();
+        }
+      });
+      this.transport.addEventListener("close", (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) {
+      if (!Reflect.has(listener, kBoundListener)) {
+        const boundListener = listener.bind(this.socket);
+        Object.defineProperty(listener, kBoundListener, {
+          value: boundListener,
+          enumerable: false,
+          configurable: false
+        });
+      }
+      this[kEmitter2].addEventListener(
+        type,
+        Reflect.get(listener, kBoundListener),
+        options
+      );
+    }
+    /**
+     * Removes the listener for the given event.
+     */
+    removeEventListener(event, listener, options) {
+      this[kEmitter2].removeEventListener(
+        event,
+        Reflect.get(listener, kBoundListener),
+        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 kPassthroughPromise = Symbol("kPassthroughPromise");
+  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;
+      this[kPassthroughPromise] = new DeferredPromise();
+      queueMicrotask(async () => {
+        if (await this[kPassthroughPromise]) {
+          return;
+        }
+        this.protocol = typeof protocols === "string" ? protocols : Array.isArray(protocols) && protocols.length > 0 ? protocols[0] : "";
+        if (this.readyState === this.CONNECTING) {
+          this.readyState = this.OPEN;
+          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
+      );
+      this[kClose](code, reason);
+    }
+    [(kPassthroughPromise, kOnSend, kClose)](code = 1e3, reason, wasClean = true) {
+      if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+        return;
+      }
+      this.readyState = this.CLOSING;
+      queueMicrotask(() => {
+        this.readyState = this.CLOSED;
+        this.dispatchEvent(
+          bindEvent(
+            this,
+            new CloseEvent("close", {
+              code,
+              reason,
+              wasClean
+            })
+          )
+        );
+        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 kBoundListener2 = Symbol("kBoundListener");
+  var kSend = Symbol("kSend");
+  var WebSocketServerConnection = class {
+    constructor(client, transport, createConnection) {
+      this.client = client;
+      this.transport = transport;
+      this.createConnection = createConnection;
+      this[kEmitter22] = new EventTarget();
+      this.mockCloseController = new AbortController();
+      this.realCloseController = new AbortController();
+      this.transport.addEventListener("outgoing", (event) => {
+        if (typeof this.realWebSocket === "undefined") {
+          return;
+        }
+        queueMicrotask(() => {
+          if (!event.defaultPrevented) {
+            this[kSend](event.data);
+          }
+        });
+      });
+      this.transport.addEventListener(
+        "incoming",
+        this.handleIncomingMessage.bind(this)
+      );
+    }
+    /**
+     * The `WebSocket` instance connected to the original server.
+     * Accessing this before calling `server.connect()` will throw.
+     */
+    get socket() {
+      invariant(
+        this.realWebSocket,
+        'Cannot access "socket" on the original WebSocket server object: the connection is not open. Did you forget to call `server.connect()`?'
+      );
+      return this.realWebSocket;
+    }
+    /**
+     * 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.client.binaryType;
+      realWebSocket.addEventListener(
+        "open",
+        (event) => {
+          this[kEmitter22].dispatchEvent(
+            bindEvent(this.realWebSocket, new Event("open", event))
+          );
+        },
+        { once: true }
+      );
+      realWebSocket.addEventListener("message", (event) => {
+        this.transport.dispatchEvent(
+          bindEvent(
+            this.realWebSocket,
+            new MessageEvent("incoming", {
+              data: event.data,
+              origin: event.origin
+            })
+          )
+        );
+      });
+      this.client.addEventListener(
+        "close",
+        (event) => {
+          this.handleMockClose(event);
+        },
+        {
+          signal: this.mockCloseController.signal
+        }
+      );
+      realWebSocket.addEventListener(
+        "close",
+        (event) => {
+          this.handleRealClose(event);
+        },
+        {
+          signal: this.realCloseController.signal
+        }
+      );
+      realWebSocket.addEventListener("error", () => {
+        const errorEvent = bindEvent(
+          realWebSocket,
+          new Event("error", { cancelable: true })
+        );
+        this[kEmitter22].dispatchEvent(errorEvent);
+        if (!errorEvent.defaultPrevented) {
+          this.client.dispatchEvent(bindEvent(this.client, new Event("error")));
+        }
+      });
+      this.realWebSocket = realWebSocket;
+    }
+    /**
+     * Listen for the incoming events from the original WebSocket server.
+     */
+    addEventListener(event, listener, options) {
+      if (!Reflect.has(listener, kBoundListener2)) {
+        const boundListener = listener.bind(this.client);
+        Object.defineProperty(listener, kBoundListener2, {
+          value: boundListener,
+          enumerable: false
+        });
+      }
+      this[kEmitter22].addEventListener(
+        event,
+        Reflect.get(listener, kBoundListener2),
+        options
+      );
+    }
+    /**
+     * Remove the listener for the given event.
+     */
+    removeEventListener(event, listener, options) {
+      this[kEmitter22].removeEventListener(
+        event,
+        Reflect.get(listener, kBoundListener2),
+        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) {
+      this[kSend](data);
+    }
+    [(kEmitter22, kSend)](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.client.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.client.url
+      );
+      this.realCloseController.abort();
+      if (realWebSocket.readyState === WebSocket.CLOSING || realWebSocket.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      realWebSocket.close();
+      queueMicrotask(() => {
+        this[kEmitter22].dispatchEvent(
+          bindEvent(
+            this.realWebSocket,
+            new CancelableCloseEvent("close", {
+              /**
+               * @note `server.close()` in the interceptor
+               * always results in clean closures.
+               */
+              code: 1e3,
+              cancelable: true
+            })
+          )
+        );
+      });
+    }
+    handleIncomingMessage(event) {
+      const messageEvent = bindEvent(
+        event.target,
+        new CancelableMessageEvent("message", {
+          data: event.data,
+          origin: event.origin,
+          cancelable: true
+        })
+      );
+      this[kEmitter22].dispatchEvent(messageEvent);
+      if (!messageEvent.defaultPrevented) {
+        this.client.dispatchEvent(
+          bindEvent(
+            /**
+             * @note Bind the forwarded original server events
+             * to the mock WebSocket instance so it would
+             * dispatch them straight away.
+             */
+            this.client,
+            // Clone the message event again to prevent
+            // the "already being dispatched" exception.
+            new MessageEvent("message", {
+              data: event.data,
+              origin: event.origin
+            })
+          )
+        );
+      }
+    }
+    handleMockClose(_event) {
+      if (this.realWebSocket) {
+        this.realWebSocket.close();
+      }
+    }
+    handleRealClose(event) {
+      this.mockCloseController.abort();
+      const closeEvent = bindEvent(
+        this.realWebSocket,
+        new CancelableCloseEvent("close", {
+          code: event.code,
+          reason: event.reason,
+          wasClean: event.wasClean,
+          cancelable: true
+        })
+      );
+      this[kEmitter22].dispatchEvent(closeEvent);
+      if (!closeEvent.defaultPrevented) {
+        this.client[kClose](event.code, event.reason);
+      }
+    }
+  };
+  var WebSocketClassTransport = class extends EventTarget {
+    constructor(socket) {
+      super();
+      this.socket = socket;
+      this.socket.addEventListener("close", (event) => {
+        this.dispatchEvent(bindEvent(this.socket, new CloseEvent("close", event)));
+      });
+      this.socket[kOnSend] = (data) => {
+        this.dispatchEvent(
+          bindEvent(
+            this.socket,
+            // Dispatch this as cancelable because "client" connection
+            // re-creates this message event (cannot dispatch the same event).
+            new CancelableMessageEvent("outgoing", {
+              data,
+              origin: this.socket.url,
+              cancelable: true
+            })
+          )
+        );
+      };
+    }
+    addEventListener(type, callback, options) {
+      return super.addEventListener(type, callback, options);
+    }
+    dispatchEvent(event) {
+      return super.dispatchEvent(event);
+    }
+    send(data) {
+      queueMicrotask(() => {
+        this.socket.dispatchEvent(
+          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
+            })
+          )
+        );
+      });
+    }
+    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(() => {
+            try {
+              const server = new WebSocketServerConnection(
+                socket,
+                transport,
+                createConnection
+              );
+              const hasConnectionListeners = this.emitter.emit("connection", {
+                client: new WebSocketClientConnection(socket, transport),
+                server,
+                info: {
+                  protocols
+                }
+              });
+              if (hasConnectionListeners) {
+                socket[kPassthroughPromise].resolve(false);
+              } else {
+                socket[kPassthroughPromise].resolve(true);
+                server.connect();
+                server.addEventListener("open", () => {
+                  socket.dispatchEvent(bindEvent(socket, new Event("open")));
+                  if (server["realWebSocket"]) {
+                    socket.protocol = server["realWebSocket"].protocol;
+                  }
+                });
+              }
+            } catch (error3) {
+              if (error3 instanceof Error) {
+                socket.dispatchEvent(new Event("error"));
+                if (socket.readyState !== WebSocket.CLOSING && socket.readyState !== WebSocket.CLOSED) {
+                  socket[kClose](1011, error3.message, false);
+                }
+                console.error(error3);
+              }
+            }
+          });
+          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/ws/handleWebSocketEvent.ts
+  function handleWebSocketEvent(options) {
+    webSocketInterceptor.on("connection", async (connection) => {
+      const handlers = options.getHandlers();
+      const connectionEvent = new MessageEvent("connection", {
+        data: connection
+      });
+      const matchingHandlers = [];
+      for (const handler of handlers) {
+        if (isHandlerKind("EventHandler")(handler) && handler.predicate({
+          event: connectionEvent,
+          parsedResult: handler.parse({
+            event: connectionEvent
+          })
+        })) {
+          matchingHandlers.push(handler);
+        }
+      }
+      if (matchingHandlers.length > 0) {
+        options?.onMockedConnection(connection);
+        for (const handler of matchingHandlers) {
+          handler[kDispatchEvent](connectionEvent);
+        }
+      } else {
+        const request = new Request(connection.client.url, {
+          headers: {
+            upgrade: "websocket",
+            connection: "upgrade"
+          }
+        });
+        await onUnhandledRequest(
+          request,
+          options.getUnhandledRequestStrategy()
+        ).catch((error3) => {
+          const errorEvent = new Event("error");
+          Object.defineProperty(errorEvent, "cause", {
+            enumerable: true,
+            configurable: false,
+            value: error3
+          });
+          connection.client.socket.dispatchEvent(errorEvent);
+        });
+        options?.onPassthroughConnection(connection);
+        connection.server.connect();
+      }
+    });
+  }
+
+  // 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
+  var colors = {
+    system: "#3b82f6",
+    outgoing: "#22c55e",
+    incoming: "#ef4444",
+    mocked: "#ff6a33"
+  };
+  function attachWebSocketLogger(connection) {
+    const { client, server } = connection;
+    logConnectionOpen(client);
+    client.addEventListener("message", (event) => {
+      logOutgoingClientMessage(event);
+    });
+    client.addEventListener("close", (event) => {
+      logConnectionClose(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
+          }
+        });
+        queueMicrotask(() => {
+          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.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: server.socket
+          }
+        });
+        logOutgoingMockedClientMessage(messageEvent);
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+  }
+  function logConnectionOpen(client) {
+    const publicUrl = toPublicUrl(client.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(`${getTimestamp()} %c\u25B6%c ${publicUrl}`),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log("Client:", client.socket);
+    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:${colors.system}`,
+      "color: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:${colors.system}`,
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E1" : "\u2B06";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.outgoing}`,
+      "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\u2B06%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "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\u2B07%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingServerMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E3" : "\u2B07";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.incoming}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+
   // src/browser/setupWorker/setupWorker.ts
   var SetupWorkerApi = class extends SetupApi {
     context;
@@ -30412,6 +31727,25 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         DEFAULT_START_OPTIONS,
         options
       );
+      handleWebSocketEvent({
+        getUnhandledRequestStrategy: () => {
+          return this.context.startOptions.onUnhandledRequest;
+        },
+        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() {