msw 2.11.5 → 2.11.6

package/lib/browser/index.mjs

@@ -464,7 +464,7 @@ You can also automate this process and make the worker script update automatical
   return integrityCheckPromise;
 }
 
-// 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);
@@ -480,100 +480,6 @@ function toArrayBuffer(array) {
   );
 }
 
-// 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 _a;
-    const status = (_a = init.status) != null ? _a : 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/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -1011,7 +917,20 @@ var _Emitter = class {
 var Emitter = _Emitter;
 Emitter.defaultMaxListeners = 10;
 
-// 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 (
@@ -1159,7 +1078,188 @@ function createRequestId() {
   return Math.random().toString(16).slice(2);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+// 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(message) {
+    super(message);
+    this.name = "InterceptorError";
+    Object.setPrototypeOf(this, InterceptorError.prototype);
+  }
+};
+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();
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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 _a;
+    const status = (_a = init.status) != null ? _a : 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);
@@ -1635,6 +1735,36 @@ var WorkerChannel = class extends Emitter2 {
   }
 };
 
+// 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") {
+    return false;
+  }
+  if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") {
+    return false;
+  }
+  if (typeof descriptor.get === "undefined" && descriptor.value == null) {
+    return false;
+  }
+  if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
+    console.error(
+      `[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`
+    );
+    return false;
+  }
+  return true;
+}
+
 // node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
 var until2 = async (promise) => {
   try {
@@ -1647,69 +1777,7 @@ var until2 = async (promise) => {
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-L37TY7LC.mjs
-var InterceptorError = class extends Error {
-  constructor(message) {
-    super(message);
-    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 isObject2(value, loose = false) {
   return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
 }
@@ -1757,19 +1825,19 @@ function isNodeLikeError(error2) {
 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 (isObject2(response)) {
-      options.onError(response);
+      await options.controller.errorWith(response);
       return true;
     }
     return false;
@@ -1779,7 +1847,7 @@ async function handleRequest2(options) {
       throw result.error;
     }
     if (isNodeLikeError(error2)) {
-      options.onError(error2);
+      await options.controller.errorWith(error2);
       return true;
     }
     if (error2 instanceof Response) {
@@ -1787,27 +1855,19 @@ async function handleRequest2(options) {
     }
     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", {
@@ -1819,73 +1879,58 @@ async function handleRequest2(options) {
       // 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;
-  }
-  if (result.data) {
-    return handleResponse(result.data);
-  }
-  return false;
-}
-
-// node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-TX5GBTFY.mjs
-function hasConfigurableGlobal(propertyName) {
-  const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
-  if (typeof descriptor === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "undefined" && descriptor.value == null) {
-    return false;
-  }
-  if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
-    console.error(
-      `[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`
+    await options.controller.respondWith(
+      createServerErrorResponse(result.error)
     );
-    return false;
+    return;
   }
-  return true;
+  if (options.controller.readyState === RequestController.PENDING) {
+    return await options.controller.passthrough();
+  }
+  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
@@ -1941,7 +1986,12 @@ async function followFetchRedirect(request, response) {
     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") {
@@ -2039,19 +2089,35 @@ var _FetchInterceptor = class extends Interceptor {
         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
           });
@@ -2089,37 +2155,24 @@ var _FetchInterceptor = class extends Interceptor {
           }
           responsePromise.resolve(response);
         },
-        onRequestError: (response) => {
-          this.logger.info("request has errored!", { response });
-          responsePromise.reject(createNetworkError(response));
-        },
-        onError: (error2) => {
-          this.logger.info("request has been aborted!", { error: error2 });
-          responsePromise.reject(error2);
+        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,
@@ -2141,7 +2194,7 @@ var _FetchInterceptor = class extends Interceptor {
 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);
@@ -2309,12 +2362,12 @@ function createResponse(request, body) {
     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) {
@@ -2366,7 +2419,6 @@ var XMLHttpRequestController = class {
         }
       },
       methodCall: ([methodName, args], invoke) => {
-        var _a;
         switch (methodName) {
           case "open": {
             const [method, url] = args;
@@ -2417,24 +2469,27 @@ var XMLHttpRequestController = class {
             const requestBody = typeof body === "string" ? encodeBuffer(body) : body;
             const fetchRequest = this.toFetchApiRequest(requestBody);
             this[kFetchRequest] = fetchRequest.clone();
-            const onceRequestSettled = ((_a = this.onRequest) == null ? void 0 : _a.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 _a;
+              const onceRequestSettled = ((_a = this.onRequest) == null ? void 0 : _a.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;
           }
@@ -2724,7 +2779,7 @@ var XMLHttpRequestController = class {
     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);
     }
   }
@@ -2833,35 +2888,37 @@ function createXMLHttpRequestProxy({
         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: (error2) => {
-            this.logger.info("request errored!", { error: error2 });
-            if (error2 instanceof Error) {
-              this.errorWith(error2);
-            }
-          }
+          emitter
         });
-        if (!isRequestHandled) {
-          this.logger.info(
-            "no mocked response received, performing request as-is..."
-          );
-        }
       };
       xhrRequestController.onResponse = async function({
         response,