msw 2.11.5 → 2.12.0

package/lib/iife/index.js

@@ -13447,6 +13447,7 @@ ${operationTypes.join("\n")}
     onUnhandledRequest: () => onUnhandledRequest,
     passthrough: () => passthrough,
     setupWorker: () => setupWorker,
+    sse: () => sse,
     ws: () => ws
   });
 
@@ -14395,7 +14396,7 @@ ${operationTypes.join("\n")}
     return stringToRegexp(path, keys, options);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
   var encoder = new TextEncoder();
   function encodeBuffer(text) {
     return encoder.encode(text);
@@ -14411,100 +14412,6 @@ ${operationTypes.join("\n")}
     );
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-3RXCRGL2.mjs
-  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
-  function canParseUrl(url) {
-    try {
-      new URL(url);
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-  function getValueBySymbol(symbolName, source) {
-    const ownSymbols = Object.getOwnPropertySymbols(source);
-    const symbol = ownSymbols.find((symbol2) => {
-      return symbol2.description === symbolName;
-    });
-    if (symbol) {
-      return Reflect.get(source, symbol);
-    }
-    return;
-  }
-  var _FetchResponse = class extends Response {
-    static isConfigurableStatusCode(status) {
-      return status >= 200 && status <= 599;
-    }
-    static isRedirectResponse(status) {
-      return _FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status);
-    }
-    /**
-     * Returns a boolean indicating whether the given response status
-     * code represents a response that can have a body.
-     */
-    static isResponseWithBody(status) {
-      return !_FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status);
-    }
-    static setUrl(url, response) {
-      if (!url || url === "about:" || !canParseUrl(url)) {
-        return;
-      }
-      const state = getValueBySymbol("state", response);
-      if (state) {
-        state.urlList.push(new URL(url));
-      } else {
-        Object.defineProperty(response, "url", {
-          value: url,
-          enumerable: true,
-          configurable: true,
-          writable: false
-        });
-      }
-    }
-    /**
-     * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
-     */
-    static parseRawHeaders(rawHeaders) {
-      const headers = new Headers();
-      for (let line = 0; line < rawHeaders.length; line += 2) {
-        headers.append(rawHeaders[line], rawHeaders[line + 1]);
-      }
-      return headers;
-    }
-    constructor(body, init = {}) {
-      var _a2;
-      const status = (_a2 = init.status) != null ? _a2 : 200;
-      const safeStatus = _FetchResponse.isConfigurableStatusCode(status) ? status : 200;
-      const finalBody = _FetchResponse.isResponseWithBody(status) ? body : null;
-      super(finalBody, {
-        status: safeStatus,
-        statusText: init.statusText,
-        headers: init.headers
-      });
-      if (status !== safeStatus) {
-        const state = getValueBySymbol("state", this);
-        if (state) {
-          state.status = status;
-        } else {
-          Object.defineProperty(this, "status", {
-            value: status,
-            enumerable: true,
-            configurable: true,
-            writable: false
-          });
-        }
-      }
-      _FetchResponse.setUrl(init.url, this);
-    }
-  };
-  var FetchResponse = _FetchResponse;
-  FetchResponse.STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304];
-  FetchResponse.STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308];
-  var kRawRequest = Symbol("kRawRequest");
-  function setRawRequest(request, rawRequest) {
-    Reflect.set(request, kRawRequest, rawRequest);
-  }
-
   // 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") {
@@ -14792,7 +14699,20 @@ ${operationTypes.join("\n")}
     return message4.toString();
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-QED3Q6Z2.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-Z5TSB3T6.mjs
+  var __accessCheck = (obj, member, msg) => {
+    if (!member.has(obj))
+      throw TypeError("Cannot " + msg);
+  };
+  var __privateGet = (obj, member, getter) => {
+    __accessCheck(obj, member, "read from private field");
+    return getter ? getter.call(obj) : member.get(obj);
+  };
+  var __privateAdd = (obj, member, value) => {
+    if (member.has(obj))
+      throw TypeError("Cannot add the same private member more than once");
+    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  };
   var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
   function getGlobalSymbol(symbol) {
     return (
@@ -14940,92 +14860,339 @@ ${operationTypes.join("\n")}
     return Math.random().toString(16).slice(2);
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/index.mjs
-  var BatchInterceptor = class extends Interceptor {
-    constructor(options) {
-      BatchInterceptor.symbol = Symbol(options.name);
-      super(BatchInterceptor.symbol);
-      this.interceptors = options.interceptors;
+  // 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;
     }
-    setup() {
-      const logger = this.logger.extend("setup");
-      logger.info("applying all %d interceptors...", this.interceptors.length);
-      for (const interceptor of this.interceptors) {
-        logger.info('applying "%s" interceptor...', interceptor.constructor.name);
-        interceptor.apply();
-        logger.info("adding interceptor dispose subscription");
-        this.subscriptions.push(() => interceptor.dispose());
-      }
+    get state() {
+      return this.#executor.state;
     }
-    on(event, listener) {
-      for (const interceptor of this.interceptors) {
-        interceptor.on(event, listener);
-      }
-      return this;
+    get rejectionReason() {
+      return this.#executor.rejectionReason;
     }
-    once(event, listener) {
-      for (const interceptor of this.interceptors) {
-        interceptor.once(event, listener);
-      }
-      return this;
+    then(onFulfilled, onRejected) {
+      return this.#decorate(super.then(onFulfilled, onRejected));
     }
-    off(event, listener) {
-      for (const interceptor of this.interceptors) {
-        interceptor.off(event, listener);
-      }
-      return this;
+    catch(onRejected) {
+      return this.#decorate(super.catch(onRejected));
     }
-    removeAllListeners(event) {
-      for (const interceptors of this.interceptors) {
-        interceptors.removeAllListeners(event);
-      }
-      return this;
+    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 }
+      });
     }
   };
-  function getCleanUrl(url, isAbsolute = true) {
-    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
-  }
 
-  // src/core/utils/url/cleanUrl.ts
-  var REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g;
-  function cleanUrl(path) {
-    if (path.endsWith("?")) {
-      return path;
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-LIKZF2VU.mjs
+  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+  var InterceptorError = class extends Error {
+    constructor(message4) {
+      super(message4);
+      this.name = "InterceptorError";
+      Object.setPrototypeOf(this, InterceptorError.prototype);
     }
-    return path.replace(REDUNDANT_CHARACTERS_EXP, "");
-  }
-
-  // src/core/utils/url/isAbsoluteUrl.ts
-  function isAbsoluteUrl(url) {
-    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
-  }
-
-  // src/core/utils/url/getAbsoluteUrl.ts
-  function getAbsoluteUrl(path, baseUrl) {
-    if (isAbsoluteUrl(path)) {
-      return path;
+  };
+  var _handled;
+  var handled_get;
+  var _RequestController = class {
+    constructor(request, source) {
+      this.request = request;
+      this.source = source;
+      __privateAdd(this, _handled);
+      this.readyState = _RequestController.PENDING;
+      this.handled = new DeferredPromise();
     }
-    if (path.startsWith("*")) {
-      return path;
+    /**
+     * Perform this request as-is.
+     */
+    async passthrough() {
+      invariant.as(
+        InterceptorError,
+        this.readyState === _RequestController.PENDING,
+        'Failed to passthrough the "%s %s" request: the request has already been handled',
+        this.request.method,
+        this.request.url
+      );
+      this.readyState = _RequestController.PASSTHROUGH;
+      await this.source.passthrough();
+      __privateGet(this, _handled, handled_get).resolve();
     }
-    const origin = baseUrl || typeof location !== "undefined" && location.href;
-    return origin ? (
-      // Encode and decode the path to preserve escaped characters.
-      decodeURI(new URL(encodeURI(path), origin).href)
-    ) : path;
-  }
-
-  // src/core/utils/matching/normalizePath.ts
-  function normalizePath(path, baseUrl) {
-    if (path instanceof RegExp) {
-      return path;
+    /**
+     * Respond to this request with the given `Response` instance.
+     *
+     * @example
+     * controller.respondWith(new Response())
+     * controller.respondWith(Response.json({ id }))
+     * controller.respondWith(Response.error())
+     */
+    respondWith(response) {
+      invariant.as(
+        InterceptorError,
+        this.readyState === _RequestController.PENDING,
+        'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)',
+        this.request.method,
+        this.request.url,
+        response.status,
+        response.statusText || "OK",
+        this.readyState
+      );
+      this.readyState = _RequestController.RESPONSE;
+      __privateGet(this, _handled, handled_get).resolve();
+      this.source.respondWith(response);
     }
-    const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
-    return cleanUrl(maybeAbsoluteUrl);
-  }
-
-  // src/core/utils/matching/matchRequestUrl.ts
-  function coercePath(path) {
+    /**
+     * Error this request with the given reason.
+     *
+     * @example
+     * controller.errorWith()
+     * controller.errorWith(new Error('Oops!'))
+     * controller.errorWith({ message: 'Oops!'})
+     */
+    errorWith(reason) {
+      invariant.as(
+        InterceptorError,
+        this.readyState === _RequestController.PENDING,
+        'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)',
+        this.request.method,
+        this.request.url,
+        reason == null ? void 0 : reason.toString(),
+        this.readyState
+      );
+      this.readyState = _RequestController.ERROR;
+      this.source.errorWith(reason);
+      __privateGet(this, _handled, handled_get).resolve();
+    }
+  };
+  var RequestController = _RequestController;
+  _handled = /* @__PURE__ */ new WeakSet();
+  handled_get = function() {
+    return this.handled;
+  };
+  RequestController.PENDING = 0;
+  RequestController.PASSTHROUGH = 1;
+  RequestController.RESPONSE = 2;
+  RequestController.ERROR = 3;
+  function canParseUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+  function getValueBySymbol(symbolName, source) {
+    const ownSymbols = Object.getOwnPropertySymbols(source);
+    const symbol = ownSymbols.find((symbol2) => {
+      return symbol2.description === symbolName;
+    });
+    if (symbol) {
+      return Reflect.get(source, symbol);
+    }
+    return;
+  }
+  var _FetchResponse = class extends Response {
+    static isConfigurableStatusCode(status) {
+      return status >= 200 && status <= 599;
+    }
+    static isRedirectResponse(status) {
+      return _FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status);
+    }
+    /**
+     * Returns a boolean indicating whether the given response status
+     * code represents a response that can have a body.
+     */
+    static isResponseWithBody(status) {
+      return !_FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status);
+    }
+    static setUrl(url, response) {
+      if (!url || url === "about:" || !canParseUrl(url)) {
+        return;
+      }
+      const state = getValueBySymbol("state", response);
+      if (state) {
+        state.urlList.push(new URL(url));
+      } else {
+        Object.defineProperty(response, "url", {
+          value: url,
+          enumerable: true,
+          configurable: true,
+          writable: false
+        });
+      }
+    }
+    /**
+     * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+     */
+    static parseRawHeaders(rawHeaders) {
+      const headers = new Headers();
+      for (let line = 0; line < rawHeaders.length; line += 2) {
+        headers.append(rawHeaders[line], rawHeaders[line + 1]);
+      }
+      return headers;
+    }
+    constructor(body, init = {}) {
+      var _a2;
+      const status = (_a2 = init.status) != null ? _a2 : 200;
+      const safeStatus = _FetchResponse.isConfigurableStatusCode(status) ? status : 200;
+      const finalBody = _FetchResponse.isResponseWithBody(status) ? body : null;
+      super(finalBody, {
+        status: safeStatus,
+        statusText: init.statusText,
+        headers: init.headers
+      });
+      if (status !== safeStatus) {
+        const state = getValueBySymbol("state", this);
+        if (state) {
+          state.status = status;
+        } else {
+          Object.defineProperty(this, "status", {
+            value: status,
+            enumerable: true,
+            configurable: true,
+            writable: false
+          });
+        }
+      }
+      _FetchResponse.setUrl(init.url, this);
+    }
+  };
+  var FetchResponse = _FetchResponse;
+  FetchResponse.STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304];
+  FetchResponse.STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308];
+  var kRawRequest = Symbol("kRawRequest");
+  function setRawRequest(request, rawRequest) {
+    Reflect.set(request, kRawRequest, rawRequest);
+  }
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+  var BatchInterceptor = class extends Interceptor {
+    constructor(options) {
+      BatchInterceptor.symbol = Symbol(options.name);
+      super(BatchInterceptor.symbol);
+      this.interceptors = options.interceptors;
+    }
+    setup() {
+      const logger = this.logger.extend("setup");
+      logger.info("applying all %d interceptors...", this.interceptors.length);
+      for (const interceptor of this.interceptors) {
+        logger.info('applying "%s" interceptor...', interceptor.constructor.name);
+        interceptor.apply();
+        logger.info("adding interceptor dispose subscription");
+        this.subscriptions.push(() => interceptor.dispose());
+      }
+    }
+    on(event, listener) {
+      for (const interceptor of this.interceptors) {
+        interceptor.on(event, listener);
+      }
+      return this;
+    }
+    once(event, listener) {
+      for (const interceptor of this.interceptors) {
+        interceptor.once(event, listener);
+      }
+      return this;
+    }
+    off(event, listener) {
+      for (const interceptor of this.interceptors) {
+        interceptor.off(event, listener);
+      }
+      return this;
+    }
+    removeAllListeners(event) {
+      for (const interceptors of this.interceptors) {
+        interceptors.removeAllListeners(event);
+      }
+      return this;
+    }
+  };
+  function getCleanUrl(url, isAbsolute = true) {
+    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
+  }
+
+  // src/core/utils/url/cleanUrl.ts
+  var REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g;
+  function cleanUrl(path) {
+    if (path.endsWith("?")) {
+      return path;
+    }
+    return path.replace(REDUNDANT_CHARACTERS_EXP, "");
+  }
+
+  // src/core/utils/url/isAbsoluteUrl.ts
+  function isAbsoluteUrl(url) {
+    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+  }
+
+  // src/core/utils/url/getAbsoluteUrl.ts
+  function getAbsoluteUrl(path, baseUrl) {
+    if (isAbsoluteUrl(path)) {
+      return path;
+    }
+    if (path.startsWith("*")) {
+      return path;
+    }
+    const origin = baseUrl || typeof location !== "undefined" && location.href;
+    return origin ? (
+      // Encode and decode the path to preserve escaped characters.
+      decodeURI(new URL(encodeURI(path), origin).href)
+    ) : path;
+  }
+
+  // src/core/utils/matching/normalizePath.ts
+  function normalizePath(path, baseUrl) {
+    if (path instanceof RegExp) {
+      return path;
+    }
+    const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
+    return cleanUrl(maybeAbsoluteUrl);
+  }
+
+  // src/core/utils/matching/matchRequestUrl.ts
+  function coercePath(path) {
     return path.replace(
       /([:a-zA-Z_-]*)(\*{1,2})+/g,
       (_, parameterName, wildcard) => {
@@ -18836,106 +19003,40 @@ Consider naming this operation or using "graphql.operation()" request handler to
     }
   };
 
-  // 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)
+  // 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 store = await this.getStore();
+      const request = store.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.`
+          )
         );
       };
-      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 store = await this.getStore();
-      const request = store.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 store = await this.getStore();
-      const request = store.getAll();
-      request.onsuccess = () => {
-        promise.resolve(request.result);
+      return promise;
+    }
+    async getAll() {
+      const promise = new DeferredPromise();
+      const store = await this.getStore();
+      const request = store.getAll();
+      request.onsuccess = () => {
+        promise.resolve(request.result);
       };
       request.onerror = () => {
         console.log(request.error);
@@ -19180,12 +19281,826 @@ Consider naming this operation or using "graphql.operation()" request handler to
           if (!ignoreClients.includes(otherClient.id)) {
             otherClient.send(data);
           }
-        });
+        });
+      }
+    };
+  }
+  var ws = {
+    link: createWebSocketLinkHandler
+  };
+
+  // src/core/delay.ts
+  var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+  var MIN_SERVER_RESPONSE_TIME = 100;
+  var MAX_SERVER_RESPONSE_TIME = 400;
+  var NODE_SERVER_RESPONSE_TIME = 5;
+  function getRealisticResponseTime() {
+    if (isNodeProcess()) {
+      return NODE_SERVER_RESPONSE_TIME;
+    }
+    return Math.floor(
+      Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
+    );
+  }
+  async function delay(durationOrMode) {
+    let delayTime;
+    if (typeof durationOrMode === "string") {
+      switch (durationOrMode) {
+        case "infinite": {
+          delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+          break;
+        }
+        case "real": {
+          delayTime = getRealisticResponseTime();
+          break;
+        }
+        default: {
+          throw new Error(
+            `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
+          );
+        }
+      }
+    } else if (typeof durationOrMode === "undefined") {
+      delayTime = getRealisticResponseTime();
+    } else {
+      if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+        throw new Error(
+          `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
+        );
+      }
+      delayTime = durationOrMode;
+    }
+    return new Promise((resolve) => setTimeout(resolve, delayTime));
+  }
+
+  // src/core/utils/internal/isObject.ts
+  function isObject2(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+  }
+
+  // src/core/ws/utils/getMessageLength.ts
+  function getMessageLength(data) {
+    if (data instanceof Blob) {
+      return data.size;
+    }
+    if (isObject2(data) && "byteLength" in data) {
+      return data.byteLength;
+    }
+    return new Blob([data]).size;
+  }
+
+  // src/core/ws/utils/truncateMessage.ts
+  var MAX_LENGTH = 24;
+  function truncateMessage(message4) {
+    if (message4.length <= MAX_LENGTH) {
+      return message4;
+    }
+    return `${message4.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 (isObject2(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/core/sse.ts
+  var sse = (path, resolver) => {
+    return new ServerSentEventHandler(path, resolver);
+  };
+  var ServerSentEventHandler = class extends HttpHandler {
+    constructor(path, resolver) {
+      invariant(
+        typeof EventSource !== "undefined",
+        'Failed to construct a Server-Sent Event handler for path "%s": the EventSource API is not supported in this environment',
+        path
+      );
+      const clientEmitter = new Emitter();
+      super("GET", path, async (info) => {
+        const responseInit = {
+          headers: {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            connection: "keep-alive"
+          }
+        };
+        await super.log({
+          request: info.request,
+          /**
+           * @note Construct a placeholder response since SSE response
+           * is being streamed and cannot be cloned/consumed for logging.
+           */
+          response: new Response("[streaming]", responseInit)
+        });
+        this.#attachClientLogger(info.request, clientEmitter);
+        const stream = new ReadableStream({
+          async start(controller) {
+            const client = new ServerSentEventClient({
+              controller,
+              emitter: clientEmitter
+            });
+            const server = new ServerSentEventServer({
+              request: info.request,
+              client
+            });
+            await resolver({
+              ...info,
+              client,
+              server
+            });
+          }
+        });
+        return new Response(stream, responseInit);
+      });
+    }
+    async predicate(args) {
+      if (args.request.headers.get("accept") !== "text/event-stream") {
+        return false;
+      }
+      return super.predicate(args);
+    }
+    async log(_args) {
+      return;
+    }
+    #attachClientLogger(request, emitter) {
+      const publicUrl = toPublicUrl(request.url);
+      emitter.on("message", (payload) => {
+        console.groupCollapsed(
+          devUtils.formatMessage(
+            `${getTimestamp()} SSE %s %c\u21E3%c ${payload.event}`
+          ),
+          publicUrl,
+          `color:${colors.mocked}`,
+          "color:inherit"
+        );
+        console.log(payload.frames);
+        console.groupEnd();
+      });
+      emitter.on("error", () => {
+        console.groupCollapsed(
+          devUtils.formatMessage(`${getTimestamp()} SSE %s %c\xD7%c error`),
+          publicUrl,
+          `color: ${colors.system}`,
+          "color:inherit"
+        );
+        console.log("Handler:", this);
+        console.groupEnd();
+      });
+      emitter.on("close", () => {
+        console.groupCollapsed(
+          devUtils.formatMessage(`${getTimestamp()} SSE %s %c\u25A0%c close`),
+          publicUrl,
+          `colors:${colors.system}`,
+          "color:inherit"
+        );
+        console.log("Handler:", this);
+        console.groupEnd();
+      });
+    }
+  };
+  var ServerSentEventClient = class {
+    #encoder;
+    #controller;
+    #emitter;
+    constructor(args) {
+      this.#encoder = new TextEncoder();
+      this.#controller = args.controller;
+      this.#emitter = args.emitter;
+    }
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload) {
+      if ("retry" in payload && payload.retry != null) {
+        this.#sendRetry(payload.retry);
+        return;
+      }
+      this.#sendMessage({
+        id: payload.id,
+        event: payload.event,
+        data: typeof payload.data === "object" ? JSON.stringify(payload.data) : payload.data
+      });
+    }
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event) {
+      if (event instanceof MessageEvent) {
+        this.#sendMessage({
+          id: event.lastEventId || void 0,
+          event: event.type === "message" ? void 0 : event.type,
+          data: event.data
+        });
+        return;
+      }
+      if (event.type === "error") {
+        this.error();
+        return;
+      }
+      if (event.type === "close") {
+        this.close();
+        return;
+      }
+    }
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error() {
+      this.#controller.error();
+      this.#emitter.emit("error");
+    }
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close() {
+      this.#controller.close();
+      this.#emitter.emit("close");
+    }
+    #sendRetry(retry) {
+      if (typeof retry === "number") {
+        this.#controller.enqueue(this.#encoder.encode(`retry:${retry}
+
+`));
+      }
+    }
+    #sendMessage(message4) {
+      const frames = [];
+      if (message4.id) {
+        frames.push(`id:${message4.id}`);
+      }
+      if (message4.event) {
+        frames.push(`event:${message4.event?.toString()}`);
+      }
+      frames.push(`data:${message4.data}`);
+      frames.push("", "");
+      this.#controller.enqueue(this.#encoder.encode(frames.join("\n")));
+      this.#emitter.emit("message", {
+        id: message4.id,
+        event: message4.event?.toString() || "message",
+        data: message4.data,
+        frames
+      });
+    }
+  };
+  var ServerSentEventServer = class {
+    #request;
+    #client;
+    constructor(args) {
+      this.#request = args.request;
+      this.#client = args.client;
+    }
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect() {
+      const source = new ObservableEventSource(this.#request.url, {
+        withCredentials: this.#request.credentials === "include",
+        headers: {
+          /**
+           * @note Mark this request as passthrough so it doesn't trigger
+           * an infinite loop matching against the existing request handler.
+           */
+          accept: "msw/passthrough"
+        }
+      });
+      source[kOnAnyMessage] = (event) => {
+        Object.defineProperties(event, {
+          target: {
+            value: this,
+            enumerable: true,
+            writable: true,
+            configurable: true
+          }
+        });
+        queueMicrotask(() => {
+          if (!event.defaultPrevented) {
+            this.#client.dispatchEvent(event);
+          }
+        });
+      };
+      source.addEventListener("error", (event) => {
+        Object.defineProperties(event, {
+          target: {
+            value: this,
+            enumerable: true,
+            writable: true,
+            configurable: true
+          }
+        });
+        queueMicrotask(() => {
+          if (!event.defaultPrevented) {
+            this.#client.dispatchEvent(event);
+          }
+        });
+      });
+      return source;
+    }
+  };
+  var kRequest = Symbol("kRequest");
+  var kReconnectionTime = Symbol("kReconnectionTime");
+  var kLastEventId = Symbol("kLastEventId");
+  var kAbortController = Symbol("kAbortController");
+  var kOnOpen = Symbol("kOnOpen");
+  var kOnMessage = Symbol("kOnMessage");
+  var kOnAnyMessage = Symbol("kOnAnyMessage");
+  var kOnError = Symbol("kOnError");
+  var ObservableEventSource = class _ObservableEventSource extends EventTarget {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSED = 2;
+    CONNECTING = _ObservableEventSource.CONNECTING;
+    OPEN = _ObservableEventSource.OPEN;
+    CLOSED = _ObservableEventSource.CLOSED;
+    readyState;
+    url;
+    withCredentials;
+    [kRequest];
+    [kReconnectionTime];
+    [kLastEventId];
+    [kAbortController];
+    [kOnOpen] = null;
+    [kOnMessage] = null;
+    [kOnAnyMessage] = null;
+    [kOnError] = null;
+    constructor(url, init) {
+      super();
+      this.url = new URL(url).href;
+      this.withCredentials = init?.withCredentials ?? false;
+      this.readyState = this.CONNECTING;
+      const headers = new Headers(init?.headers || {});
+      headers.append("accept", "text/event-stream");
+      this[kAbortController] = new AbortController();
+      this[kReconnectionTime] = 2e3;
+      this[kLastEventId] = "";
+      this[kRequest] = new Request(this.url, {
+        method: "GET",
+        headers,
+        credentials: this.withCredentials ? "include" : "omit",
+        signal: this[kAbortController].signal
+      });
+      this.connect();
+    }
+    get onopen() {
+      return this[kOnOpen];
+    }
+    set onopen(handler) {
+      if (this[kOnOpen]) {
+        this.removeEventListener("open", this[kOnOpen]);
+      }
+      this[kOnOpen] = handler.bind(this);
+      this.addEventListener("open", this[kOnOpen]);
+    }
+    get onmessage() {
+      return this[kOnMessage];
+    }
+    set onmessage(handler) {
+      if (this[kOnMessage]) {
+        this.removeEventListener("message", { handleEvent: this[kOnMessage] });
+      }
+      this[kOnMessage] = handler.bind(this);
+      this.addEventListener("message", { handleEvent: this[kOnMessage] });
+    }
+    get onerror() {
+      return this[kOnError];
+    }
+    set oneerror(handler) {
+      if (this[kOnError]) {
+        this.removeEventListener("error", { handleEvent: this[kOnError] });
+      }
+      this[kOnError] = handler.bind(this);
+      this.addEventListener("error", { handleEvent: this[kOnError] });
+    }
+    addEventListener(type, listener, options) {
+      super.addEventListener(
+        type,
+        listener,
+        options
+      );
+    }
+    removeEventListener(type, listener, options) {
+      super.removeEventListener(
+        type,
+        listener,
+        options
+      );
+    }
+    dispatchEvent(event) {
+      return super.dispatchEvent(event);
+    }
+    close() {
+      this[kAbortController].abort();
+      this.readyState = this.CLOSED;
+    }
+    async connect() {
+      await fetch(this[kRequest]).then((response) => {
+        this.processResponse(response);
+      }).catch(() => {
+        this.failConnection();
+      });
+    }
+    processResponse(response) {
+      if (!response.body) {
+        this.failConnection();
+        return;
+      }
+      if (isNetworkError(response)) {
+        this.reestablishConnection();
+        return;
+      }
+      if (response.status !== 200 || response.headers.get("content-type") !== "text/event-stream") {
+        this.failConnection();
+        return;
+      }
+      this.announceConnection();
+      this.interpretResponseBody(response);
+    }
+    announceConnection() {
+      queueMicrotask(() => {
+        if (this.readyState !== this.CLOSED) {
+          this.readyState = this.OPEN;
+          this.dispatchEvent(new Event("open"));
+        }
+      });
+    }
+    interpretResponseBody(response) {
+      const parsingStream = new EventSourceParsingStream({
+        message: (message4) => {
+          if (message4.id) {
+            this[kLastEventId] = message4.id;
+          }
+          if (message4.retry) {
+            this[kReconnectionTime] = message4.retry;
+          }
+          const messageEvent = new MessageEvent(
+            message4.event ? message4.event : "message",
+            {
+              data: message4.data,
+              origin: this[kRequest].url,
+              lastEventId: this[kLastEventId],
+              cancelable: true
+            }
+          );
+          this[kOnAnyMessage]?.(messageEvent);
+          this.dispatchEvent(messageEvent);
+        },
+        abort: () => {
+          throw new Error("Stream abort is not implemented");
+        },
+        close: () => {
+          this.failConnection();
+        }
+      });
+      response.body.pipeTo(parsingStream).then(() => {
+        this.processResponseEndOfBody(response);
+      }).catch(() => {
+        this.failConnection();
+      });
+    }
+    processResponseEndOfBody(response) {
+      if (!isNetworkError(response)) {
+        this.reestablishConnection();
       }
-    };
+    }
+    async reestablishConnection() {
+      queueMicrotask(() => {
+        if (this.readyState === this.CLOSED) {
+          return;
+        }
+        this.readyState = this.CONNECTING;
+        this.dispatchEvent(new Event("error"));
+      });
+      await delay(this[kReconnectionTime]);
+      queueMicrotask(async () => {
+        if (this.readyState !== this.CONNECTING) {
+          return;
+        }
+        if (this[kLastEventId] !== "") {
+          this[kRequest].headers.set("last-event-id", this[kLastEventId]);
+        }
+        await this.connect();
+      });
+    }
+    failConnection() {
+      queueMicrotask(() => {
+        if (this.readyState !== this.CLOSED) {
+          this.readyState = this.CLOSED;
+          this.dispatchEvent(new Event("error"));
+        }
+      });
+    }
+  };
+  function isNetworkError(response) {
+    return response.type === "error" && response.status === 0 && response.statusText === "" && Array.from(response.headers.entries()).length === 0 && response.body === null;
   }
-  var ws = {
-    link: createWebSocketLinkHandler
+  var EventSourceParsingStream = class extends WritableStream {
+    constructor(underlyingSink) {
+      super({
+        write: (chunk) => {
+          this.processResponseBodyChunk(chunk);
+        },
+        abort: (reason) => {
+          this.underlyingSink.abort?.(reason);
+        },
+        close: () => {
+          this.underlyingSink.close?.();
+        }
+      });
+      this.underlyingSink = underlyingSink;
+      this.decoder = new TextDecoder();
+      this.position = 0;
+    }
+    decoder;
+    buffer;
+    position;
+    fieldLength;
+    discardTrailingNewline = false;
+    message = {
+      id: void 0,
+      event: void 0,
+      data: void 0,
+      retry: void 0
+    };
+    resetMessage() {
+      this.message = {
+        id: void 0,
+        event: void 0,
+        data: void 0,
+        retry: void 0
+      };
+    }
+    processResponseBodyChunk(chunk) {
+      if (this.buffer == null) {
+        this.buffer = chunk;
+        this.position = 0;
+        this.fieldLength = -1;
+      } else {
+        const nextBuffer = new Uint8Array(this.buffer.length + chunk.length);
+        nextBuffer.set(this.buffer);
+        nextBuffer.set(chunk, this.buffer.length);
+        this.buffer = nextBuffer;
+      }
+      const bufferLength = this.buffer.length;
+      let lineStart = 0;
+      while (this.position < bufferLength) {
+        if (this.discardTrailingNewline) {
+          if (this.buffer[this.position] === 10 /* NewLine */) {
+            lineStart = ++this.position;
+          }
+          this.discardTrailingNewline = false;
+        }
+        let lineEnd = -1;
+        for (; this.position < bufferLength && lineEnd === -1; ++this.position) {
+          switch (this.buffer[this.position]) {
+            case 58 /* Colon */: {
+              if (this.fieldLength === -1) {
+                this.fieldLength = this.position - lineStart;
+              }
+              break;
+            }
+            case 13 /* CarriageReturn */: {
+              this.discardTrailingNewline = true;
+              break;
+            }
+            case 10 /* NewLine */: {
+              lineEnd = this.position;
+              break;
+            }
+          }
+        }
+        if (lineEnd === -1) {
+          break;
+        }
+        this.processLine(
+          this.buffer.subarray(lineStart, lineEnd),
+          this.fieldLength
+        );
+        lineStart = this.position;
+        this.fieldLength = -1;
+      }
+      if (lineStart === bufferLength) {
+        this.buffer = void 0;
+      } else if (lineStart !== 0) {
+        this.buffer = this.buffer.subarray(lineStart);
+        this.position -= lineStart;
+      }
+    }
+    processLine(line, fieldLength) {
+      if (line.length === 0) {
+        if (this.message.data === void 0) {
+          this.message.event = void 0;
+          return;
+        }
+        this.underlyingSink.message(this.message);
+        this.resetMessage();
+        return;
+      }
+      if (fieldLength > 0) {
+        const field = this.decoder.decode(line.subarray(0, fieldLength));
+        const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* Space */ ? 2 : 1);
+        const value = this.decoder.decode(line.subarray(valueOffset));
+        switch (field) {
+          case "data": {
+            this.message.data = this.message.data ? this.message.data + "\n" + value : value;
+            break;
+          }
+          case "event": {
+            this.message.event = value;
+            break;
+          }
+          case "id": {
+            this.message.id = value;
+            break;
+          }
+          case "retry": {
+            const retry = parseInt(value, 10);
+            if (!isNaN(retry)) {
+              this.message.retry = retry;
+            }
+            break;
+          }
+        }
+      }
+    }
   };
 
   // node_modules/.pnpm/until-async@3.0.2/node_modules/until-async/lib/index.js
@@ -19517,50 +20432,6 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
     }
   };
 
-  // src/core/delay.ts
-  var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
-  var MIN_SERVER_RESPONSE_TIME = 100;
-  var MAX_SERVER_RESPONSE_TIME = 400;
-  var NODE_SERVER_RESPONSE_TIME = 5;
-  function getRealisticResponseTime() {
-    if (isNodeProcess()) {
-      return NODE_SERVER_RESPONSE_TIME;
-    }
-    return Math.floor(
-      Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
-    );
-  }
-  async function delay(durationOrMode) {
-    let delayTime;
-    if (typeof durationOrMode === "string") {
-      switch (durationOrMode) {
-        case "infinite": {
-          delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
-          break;
-        }
-        case "real": {
-          delayTime = getRealisticResponseTime();
-          break;
-        }
-        default: {
-          throw new Error(
-            `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
-          );
-        }
-      }
-    } else if (typeof durationOrMode === "undefined") {
-      delayTime = getRealisticResponseTime();
-    } else {
-      if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
-        throw new Error(
-          `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
-        );
-      }
-      delayTime = durationOrMode;
-    }
-    return new Promise((resolve) => setTimeout(resolve, delayTime));
-  }
-
   // src/core/bypass.ts
   function bypass(input, init) {
     const request = new Request(
@@ -19594,11 +20465,6 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
   // src/core/index.ts
   checkGlobals();
 
-  // src/core/utils/internal/isObject.ts
-  function isObject2(value) {
-    return value != null && typeof value === "object" && !Array.isArray(value);
-  }
-
   // src/core/utils/internal/mergeRight.ts
   function mergeRight(left, right) {
     return Object.entries(right).reduce(
@@ -20042,7 +20908,16 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     };
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-TX5GBTFY.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-VYSDLBSS.mjs
+  async function emitAsync(emitter, eventName, ...data) {
+    const listeners = emitter.listeners(eventName);
+    if (listeners.length === 0) {
+      return;
+    }
+    for (const listener of listeners) {
+      await listener.apply(emitter, data);
+    }
+  }
   function hasConfigurableGlobal(propertyName) {
     const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
     if (typeof descriptor === "undefined") {
@@ -20063,7 +20938,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     return true;
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
   function bindEvent(target, event) {
     Object.defineProperties(event, {
       target: {
@@ -20685,14 +21560,15 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           };
           const socket = new WebSocketOverride(url, protocols);
           const transport = new WebSocketClassTransport(socket);
-          queueMicrotask(() => {
+          queueMicrotask(async () => {
             try {
               const server = new WebSocketServerConnection(
                 socket,
                 transport,
                 createConnection
               );
-              const hasConnectionListeners = this.emitter.emit("connection", {
+              const hasConnectionListeners = this.emitter.listenerCount("connection") > 0;
+              await emitAsync(this.emitter, "connection", {
                 client: new WebSocketClientConnection(socket, transport),
                 server,
                 info: {
@@ -20747,240 +21623,37 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   function handleWebSocketEvent(options) {
     webSocketInterceptor.on("connection", async (connection) => {
       const handlers = options.getHandlers().filter(isHandlerKind("EventHandler"));
-      if (handlers.length > 0) {
-        options?.onMockedConnection(connection);
-        await Promise.all(
-          handlers.map((handler) => {
-            return handler.run(connection);
-          })
-        );
-        return;
-      }
-      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(message4) {
-    if (message4.length <= MAX_LENGTH) {
-      return message4;
-    }
-    return `${message4.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);
+      if (handlers.length > 0) {
+        options?.onMockedConnection(connection);
+        await Promise.all(
+          handlers.map((handler) => {
+            return handler.run(connection);
+          })
+        );
+        return;
       }
+      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();
     });
   }
-  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();
-  }
 
   // node_modules/.pnpm/rettime@0.7.0/node_modules/rettime/build/index.js
   var kDefaultPrevented2 = Symbol("kDefaultPrevented");
@@ -21286,69 +21959,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-L37TY7LC.mjs
-  var InterceptorError = class extends Error {
-    constructor(message4) {
-      super(message4);
-      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();
-    }
-    /**
-     * Respond to this request with the given `Response` instance.
-     * @example
-     * controller.respondWith(new Response())
-     * controller.respondWith(Response.json({ id }))
-     * controller.respondWith(Response.error())
-     */
-    respondWith(response) {
-      invariant.as(
-        InterceptorError,
-        !this[kRequestHandled],
-        'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
-        this.request.method,
-        this.request.url
-      );
-      this[kRequestHandled] = true;
-      this[kResponsePromise].resolve(response);
-    }
-    /**
-     * Error this request with the given reason.
-     *
-     * @example
-     * controller.errorWith()
-     * controller.errorWith(new Error('Oops!'))
-     * controller.errorWith({ message: 'Oops!'})
-     */
-    errorWith(reason) {
-      invariant.as(
-        InterceptorError,
-        !this[kRequestHandled],
-        'Failed to error the "%s %s" request: the "request" event has already been handled.',
-        this.request.method,
-        this.request.url
-      );
-      this[kRequestHandled] = true;
-      this[kResponsePromise].resolve(reason);
-    }
-  };
-  async function emitAsync(emitter, eventName, ...data) {
-    const listners = emitter.listeners(eventName);
-    if (listners.length === 0) {
-      return;
-    }
-    for (const listener of listners) {
-      await listener.apply(emitter, data);
-    }
-  }
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-VOUOVDAW.mjs
   function isObject3(value, loose = false) {
     return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
   }
@@ -21396,19 +22007,19 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   async function handleRequest2(options) {
     const handleResponse = async (response) => {
       if (response instanceof Error) {
-        options.onError(response);
+        await options.controller.errorWith(response);
         return true;
       }
       if (isResponseError(response)) {
-        options.onRequestError(response);
+        await options.controller.respondWith(response);
         return true;
       }
       if (isResponseLike(response)) {
-        await options.onResponse(response);
+        await options.controller.respondWith(response);
         return true;
       }
       if (isObject3(response)) {
-        options.onError(response);
+        await options.controller.errorWith(response);
         return true;
       }
       return false;
@@ -21418,7 +22029,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         throw result.error;
       }
       if (isNodeLikeError(error3)) {
-        options.onError(error3);
+        await options.controller.errorWith(error3);
         return true;
       }
       if (error3 instanceof Response) {
@@ -21426,27 +22037,19 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       }
       return false;
     };
-    options.emitter.once("request", ({ requestId: pendingRequestId }) => {
-      if (pendingRequestId !== options.requestId) {
-        return;
-      }
-      if (options.controller[kResponsePromise].state === "pending") {
-        options.controller[kResponsePromise].resolve(void 0);
-      }
-    });
     const requestAbortPromise = new DeferredPromise();
     if (options.request.signal) {
       if (options.request.signal.aborted) {
-        requestAbortPromise.reject(options.request.signal.reason);
-      } else {
-        options.request.signal.addEventListener(
-          "abort",
-          () => {
-            requestAbortPromise.reject(options.request.signal.reason);
-          },
-          { once: true }
-        );
+        await options.controller.errorWith(options.request.signal.reason);
+        return;
       }
+      options.request.signal.addEventListener(
+        "abort",
+        () => {
+          requestAbortPromise.reject(options.request.signal.reason);
+        },
+        { once: true }
+      );
     }
     const result = await until2(async () => {
       const requestListenersPromise = emitAsync(options.emitter, "request", {
@@ -21458,52 +22061,58 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         // Short-circuit the request handling promise if the request gets aborted.
         requestAbortPromise,
         requestListenersPromise,
-        options.controller[kResponsePromise]
+        options.controller.handled
       ]);
-      return await options.controller[kResponsePromise];
     });
     if (requestAbortPromise.state === "rejected") {
-      options.onError(requestAbortPromise.rejectionReason);
-      return true;
+      await options.controller.errorWith(requestAbortPromise.rejectionReason);
+      return;
     }
     if (result.error) {
       if (await handleResponseError(result.error)) {
-        return true;
+        return;
       }
       if (options.emitter.listenerCount("unhandledException") > 0) {
         const unhandledExceptionController = new RequestController(
-          options.request
+          options.request,
+          {
+            /**
+             * @note Intentionally empty passthrough handle.
+             * This controller is created within another controller and we only need
+             * to know if `unhandledException` listeners handled the request.
+             */
+            passthrough() {
+            },
+            async respondWith(response) {
+              await handleResponse(response);
+            },
+            async errorWith(reason) {
+              await options.controller.errorWith(reason);
+            }
+          }
         );
         await emitAsync(options.emitter, "unhandledException", {
           error: result.error,
           request: options.request,
           requestId: options.requestId,
           controller: unhandledExceptionController
-        }).then(() => {
-          if (unhandledExceptionController[kResponsePromise].state === "pending") {
-            unhandledExceptionController[kResponsePromise].resolve(void 0);
-          }
         });
-        const nextResult = await until2(
-          () => unhandledExceptionController[kResponsePromise]
-        );
-        if (nextResult.error) {
-          return handleResponseError(nextResult.error);
-        }
-        if (nextResult.data) {
-          return handleResponse(nextResult.data);
+        if (unhandledExceptionController.readyState !== RequestController.PENDING) {
+          return;
         }
       }
-      options.onResponse(createServerErrorResponse(result.error));
-      return true;
+      await options.controller.respondWith(
+        createServerErrorResponse(result.error)
+      );
+      return;
     }
-    if (result.data) {
-      return handleResponse(result.data);
+    if (options.controller.readyState === RequestController.PENDING) {
+      return await options.controller.passthrough();
     }
-    return false;
+    return options.controller.handled;
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-ARPHZXGT.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-WOWPV4GR.mjs
   function createNetworkError(cause) {
     return Object.assign(new TypeError("Failed to fetch"), {
       cause
@@ -21559,7 +22168,12 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       request.headers.delete("host");
     }
     requestInit.headers = request.headers;
-    return fetch(new Request(locationUrl, requestInit));
+    const finalResponse = await fetch(new Request(locationUrl, requestInit));
+    Object.defineProperty(finalResponse, "redirected", {
+      value: true,
+      configurable: true
+    });
+    return finalResponse;
   }
   function sameOrigin(left, right) {
     if (left.origin === right.origin && left.origin === "null") {
@@ -21657,19 +22271,35 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           setRawRequest(request, input);
         }
         const responsePromise = new DeferredPromise();
-        const controller = new RequestController(request);
-        this.logger.info("[%s] %s", request.method, request.url);
-        this.logger.info("awaiting for the mocked response...");
-        this.logger.info(
-          'emitting the "request" event for %s listener(s)...',
-          this.emitter.listenerCount("request")
-        );
-        const isRequestHandled = await handleRequest2({
-          request,
-          requestId,
-          emitter: this.emitter,
-          controller,
-          onResponse: async (rawResponse) => {
+        const controller = new RequestController(request, {
+          passthrough: async () => {
+            this.logger.info("request has not been handled, passthrough...");
+            const requestCloneForResponseEvent = request.clone();
+            const { error: responseError, data: originalResponse } = await until2(
+              () => pureFetch(request)
+            );
+            if (responseError) {
+              return responsePromise.reject(responseError);
+            }
+            this.logger.info("original fetch performed", originalResponse);
+            if (this.emitter.listenerCount("response") > 0) {
+              this.logger.info('emitting the "response" event...');
+              const responseClone = originalResponse.clone();
+              await emitAsync(this.emitter, "response", {
+                response: responseClone,
+                isMockedResponse: false,
+                request: requestCloneForResponseEvent,
+                requestId
+              });
+            }
+            responsePromise.resolve(originalResponse);
+          },
+          respondWith: async (rawResponse) => {
+            if (isResponseError(rawResponse)) {
+              this.logger.info("request has errored!", { response: rawResponse });
+              responsePromise.reject(createNetworkError(rawResponse));
+              return;
+            }
             this.logger.info("received mocked response!", {
               rawResponse
             });
@@ -21707,37 +22337,24 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
             }
             responsePromise.resolve(response);
           },
-          onRequestError: (response) => {
-            this.logger.info("request has errored!", { response });
-            responsePromise.reject(createNetworkError(response));
-          },
-          onError: (error3) => {
-            this.logger.info("request has been aborted!", { error: error3 });
-            responsePromise.reject(error3);
+          errorWith: (reason) => {
+            this.logger.info("request has been aborted!", { reason });
+            responsePromise.reject(reason);
           }
         });
-        if (isRequestHandled) {
-          this.logger.info("request has been handled, returning mock promise...");
-          return responsePromise;
-        }
+        this.logger.info("[%s] %s", request.method, request.url);
+        this.logger.info("awaiting for the mocked response...");
         this.logger.info(
-          "no mocked response received, performing request as-is..."
+          'emitting the "request" event for %s listener(s)...',
+          this.emitter.listenerCount("request")
         );
-        const requestCloneForResponseEvent = request.clone();
-        return pureFetch(request).then(async (response) => {
-          this.logger.info("original fetch performed", response);
-          if (this.emitter.listenerCount("response") > 0) {
-            this.logger.info('emitting the "response" event...');
-            const responseClone = response.clone();
-            await emitAsync(this.emitter, "response", {
-              response: responseClone,
-              isMockedResponse: false,
-              request: requestCloneForResponseEvent,
-              requestId
-            });
-          }
-          return response;
+        await handleRequest2({
+          request,
+          requestId,
+          emitter: this.emitter,
+          controller
         });
+        return responsePromise;
       };
       Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
         enumerable: true,
@@ -21759,7 +22376,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   var FetchInterceptor = _FetchInterceptor;
   FetchInterceptor.symbol = Symbol("fetch");
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-QKSBFQDK.mjs
+  // node_modules/.pnpm/@mswjs+interceptors@0.40.0/node_modules/@mswjs/interceptors/lib/browser/chunk-WADP6VHN.mjs
   function concatArrayBuffer(left, right) {
     const result = new Uint8Array(left.byteLength + right.byteLength);
     result.set(left, 0);
@@ -21927,12 +22544,12 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       url: request.responseURL,
       status: request.status,
       statusText: request.statusText,
-      headers: createHeadersFromXMLHttpReqestHeaders(
+      headers: createHeadersFromXMLHttpRequestHeaders(
         request.getAllResponseHeaders()
       )
     });
   }
-  function createHeadersFromXMLHttpReqestHeaders(headersString) {
+  function createHeadersFromXMLHttpRequestHeaders(headersString) {
     const headers = new Headers();
     const lines = headersString.split(/[\r\n]+/);
     for (const line of lines) {
@@ -21984,7 +22601,6 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           }
         },
         methodCall: ([methodName, args], invoke) => {
-          var _a2;
           switch (methodName) {
             case "open": {
               const [method, url] = args;
@@ -22035,24 +22651,27 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
               const requestBody = typeof body === "string" ? encodeBuffer(body) : body;
               const fetchRequest = this.toFetchApiRequest(requestBody);
               this[kFetchRequest] = fetchRequest.clone();
-              const onceRequestSettled = ((_a2 = this.onRequest) == null ? void 0 : _a2.call(this, {
-                request: fetchRequest,
-                requestId: this.requestId
-              })) || Promise.resolve();
-              onceRequestSettled.finally(() => {
-                if (!this[kIsRequestHandled]) {
-                  this.logger.info(
-                    "request callback settled but request has not been handled (readystate %d), performing as-is...",
-                    this.request.readyState
-                  );
-                  if (IS_NODE2) {
-                    this.request.setRequestHeader(
-                      INTERNAL_REQUEST_ID_HEADER_NAME,
-                      this.requestId
+              queueMicrotask(() => {
+                var _a2;
+                const onceRequestSettled = ((_a2 = this.onRequest) == null ? void 0 : _a2.call(this, {
+                  request: fetchRequest,
+                  requestId: this.requestId
+                })) || Promise.resolve();
+                onceRequestSettled.finally(() => {
+                  if (!this[kIsRequestHandled]) {
+                    this.logger.info(
+                      "request callback settled but request has not been handled (readystate %d), performing as-is...",
+                      this.request.readyState
                     );
+                    if (IS_NODE2) {
+                      this.request.setRequestHeader(
+                        INTERNAL_REQUEST_ID_HEADER_NAME,
+                        this.requestId
+                      );
+                    }
+                    return invoke();
                   }
-                  return invoke();
-                }
+                });
               });
               break;
             }
@@ -22342,7 +22961,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       define(this.request, "readyState", nextReadyState);
       this.logger.info("set readyState to: %d", nextReadyState);
       if (nextReadyState !== this.request.UNSENT) {
-        this.logger.info('triggerring "readystatechange" event...');
+        this.logger.info('triggering "readystatechange" event...');
         this.trigger("readystatechange", this.request);
       }
     }
@@ -22451,35 +23070,37 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
           logger
         );
         xhrRequestController.onRequest = async function({ request, requestId }) {
-          const controller = new RequestController(request);
+          const controller = new RequestController(request, {
+            passthrough: () => {
+              this.logger.info(
+                "no mocked response received, performing request as-is..."
+              );
+            },
+            respondWith: async (response) => {
+              if (isResponseError(response)) {
+                this.errorWith(new TypeError("Network error"));
+                return;
+              }
+              await this.respondWith(response);
+            },
+            errorWith: (reason) => {
+              this.logger.info("request errored!", { error: reason });
+              if (reason instanceof Error) {
+                this.errorWith(reason);
+              }
+            }
+          });
           this.logger.info("awaiting mocked response...");
           this.logger.info(
             'emitting the "request" event for %s listener(s)...',
             emitter.listenerCount("request")
           );
-          const isRequestHandled = await handleRequest2({
+          await handleRequest2({
             request,
             requestId,
             controller,
-            emitter,
-            onResponse: async (response) => {
-              await this.respondWith(response);
-            },
-            onRequestError: () => {
-              this.errorWith(new TypeError("Network error"));
-            },
-            onError: (error3) => {
-              this.logger.info("request errored!", { error: error3 });
-              if (error3 instanceof Error) {
-                this.errorWith(error3);
-              }
-            }
+            emitter
           });
-          if (!isRequestHandled) {
-            this.logger.info(
-              "no mocked response received, performing request as-is..."
-            );
-          }
         };
         xhrRequestController.onResponse = async function({
           response,