msw 2.11.5 → 2.11.6

package/lib/iife/index.js

@@ -14395,7 +14395,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 +14411,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 +14698,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,7 +14859,254 @@ ${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
+  // node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+  function createDeferredExecutor() {
+    const executor = (resolve, reject) => {
+      executor.state = "pending";
+      executor.resolve = (data) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        executor.result = data;
+        const onFulfilled = (value) => {
+          executor.state = "fulfilled";
+          return value;
+        };
+        return resolve(
+          data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+        );
+      };
+      executor.reject = (reason) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        queueMicrotask(() => {
+          executor.state = "rejected";
+        });
+        return reject(executor.rejectionReason = reason);
+      };
+    };
+    return executor;
+  }
+  var DeferredPromise = class extends Promise {
+    #executor;
+    resolve;
+    reject;
+    constructor(executor = null) {
+      const deferredExecutor = createDeferredExecutor();
+      super((originalResolve, originalReject) => {
+        deferredExecutor(originalResolve, originalReject);
+        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+      });
+      this.#executor = deferredExecutor;
+      this.resolve = this.#executor.resolve;
+      this.reject = this.#executor.reject;
+    }
+    get state() {
+      return this.#executor.state;
+    }
+    get rejectionReason() {
+      return this.#executor.rejectionReason;
+    }
+    then(onFulfilled, onRejected) {
+      return this.#decorate(super.then(onFulfilled, onRejected));
+    }
+    catch(onRejected) {
+      return this.#decorate(super.catch(onRejected));
+    }
+    finally(onfinally) {
+      return this.#decorate(super.finally(onfinally));
+    }
+    #decorate(promise) {
+      return Object.defineProperties(promise, {
+        resolve: { configurable: true, value: this.resolve },
+        reject: { configurable: true, value: this.reject }
+      });
+    }
+  };
+
+  // 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);
+    }
+  };
+  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 _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);
@@ -18836,72 +19002,6 @@ 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)
-        );
-      };
-      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";
@@ -20042,7 +20142,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 +20172,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 +20794,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: {
@@ -21286,69 +21396,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 +21444,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 +21466,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 +21474,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 +21498,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 +21605,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 +21708,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 +21774,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 +21813,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 +21981,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 +22038,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 +22088,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 +22398,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 +22507,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,