msw 0.43.1 → 0.44.2

package/lib/index.js

@@ -52,6 +52,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   GraphQLHandler: () => GraphQLHandler,
+  MockedRequest: () => MockedRequest,
   RESTMethods: () => RESTMethods,
   RequestHandler: () => RequestHandler,
   RestHandler: () => RestHandler,
@@ -65,7 +66,6 @@ __export(src_exports, {
   graphqlContext: () => graphqlContext,
   handleRequest: () => handleRequest,
   matchRequestUrl: () => matchRequestUrl,
-  parseIsomorphicRequest: () => parseIsomorphicRequest,
   response: () => response,
   rest: () => rest,
   restContext: () => restContext,
@@ -425,17 +425,15 @@ async function enableMocking(context, options) {
 }
 
 // src/setupWorker/start/utils/createMessageChannel.ts
-function createMessageChannel(event) {
-  const port = event.ports[0];
-  return {
-    send(message) {
-      if (!port) {
-        return;
-      }
-      port.postMessage(message);
-    }
-  };
-}
+var WorkerChannel = class {
+  constructor(port) {
+    this.port = port;
+  }
+  postMessage(event, ...rest2) {
+    const [data2, transfer] = rest2;
+    this.port.postMessage({ type: event, data: data2 }, { transfer });
+  }
+};
 
 // src/utils/NetworkError.ts
 var NetworkError = class extends Error {
@@ -446,166 +444,15 @@ var NetworkError = class extends Error {
 };
 
 // src/utils/request/parseWorkerRequest.ts
-var import_headers_polyfill6 = require("headers-polyfill");
-
-// src/handlers/RequestHandler.ts
+var import_interceptors2 = require("@mswjs/interceptors");
 var import_headers_polyfill4 = require("headers-polyfill");
 
-// src/response.ts
-var import_headers_polyfill3 = require("headers-polyfill");
-
-// src/utils/internal/compose.ts
-function compose(...fns) {
-  return (...args) => {
-    return fns.reduceRight((leftFn, rightFn) => {
-      return leftFn instanceof Promise ? Promise.resolve(leftFn).then(rightFn) : rightFn(leftFn);
-    }, args[0]);
-  };
-}
-
-// src/response.ts
-var defaultResponse = {
-  status: 200,
-  statusText: "OK",
-  body: null,
-  delay: 0,
-  once: false,
-  passthrough: false
-};
-var defaultResponseTransformers = [];
-function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
-  return async (...transformers) => {
-    const initialResponse = Object.assign({}, defaultResponse, {
-      headers: new import_headers_polyfill3.Headers({
-        "x-powered-by": "msw"
-      })
-    }, responseOverrides);
-    const resolvedTransformers = [
-      ...defaultTransformers,
-      ...transformers
-    ].filter(Boolean);
-    const resolvedResponse = resolvedTransformers.length > 0 ? compose(...resolvedTransformers)(initialResponse) : initialResponse;
-    return resolvedResponse;
-  };
-}
-var response = Object.assign(createResponseComposition(), {
-  once: createResponseComposition({ once: true }),
-  networkError(message) {
-    throw new NetworkError(message);
-  }
-});
-
-// src/utils/internal/getCallFrame.ts
-var SOURCE_FRAME = /\/msw\/src\/(.+)/;
-var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-function getCallFrame(error2) {
-  const stack = error2.stack;
-  if (!stack) {
-    return;
-  }
-  const frames = stack.split("\n").slice(1);
-  const declarationFrame = frames.find((frame) => {
-    return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
-  });
-  if (!declarationFrame) {
-    return;
-  }
-  const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
-  return declarationPath;
-}
-
-// src/utils/internal/isIterable.ts
-function isIterable(fn) {
-  if (!fn) {
-    return false;
-  }
-  return typeof fn[Symbol.iterator] == "function";
-}
-
-// src/handlers/RequestHandler.ts
-var defaultContext = {
-  status,
-  set,
-  delay,
-  fetch
-};
-var RequestHandler = class {
-  constructor(options) {
-    this.shouldSkip = false;
-    this.ctx = options.ctx || defaultContext;
-    this.resolver = options.resolver;
-    const callFrame = getCallFrame(new Error());
-    this.info = __spreadProps(__spreadValues({}, options.info), {
-      callFrame
-    });
-  }
-  parse(_request, _resolutionContext) {
-    return null;
-  }
-  test(request, resolutionContext) {
-    return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
-  }
-  getPublicRequest(request, _parsedResult) {
-    return request;
-  }
-  markAsSkipped(shouldSkip = true) {
-    this.shouldSkip = shouldSkip;
-  }
-  async run(request, resolutionContext) {
-    if (this.shouldSkip) {
-      return null;
-    }
-    const parsedResult = this.parse(request, resolutionContext);
-    const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
-    if (!shouldIntercept) {
-      return null;
-    }
-    const publicRequest = this.getPublicRequest(request, parsedResult);
-    const executeResolver = this.wrapResolver(this.resolver);
-    const mockedResponse = await executeResolver(publicRequest, response, this.ctx);
-    return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
-  }
-  wrapResolver(resolver) {
-    return async (req, res, ctx) => {
-      const result = this.resolverGenerator || await resolver(req, res, ctx);
-      if (isIterable(result)) {
-        const { value, done } = result[Symbol.iterator]().next();
-        const nextResponse = await value;
-        if (!nextResponse && done) {
-          return this.resolverGeneratorResult;
-        }
-        if (!this.resolverGenerator) {
-          this.resolverGenerator = result;
-        }
-        this.resolverGeneratorResult = nextResponse;
-        return nextResponse;
-      }
-      return result;
-    };
-  }
-  createExecutionResult(parsedResult, request, response2) {
-    return {
-      handler: this,
-      parsedResult: parsedResult || null,
-      request,
-      response: response2 || null
-    };
-  }
-};
-function passthrough() {
-  return {
-    status: 101,
-    statusText: "Continue",
-    headers: new import_headers_polyfill4.Headers(),
-    body: null,
-    passthrough: true,
-    once: false
-  };
-}
-
-// src/utils/request/setRequestCookies.ts
+// src/utils/request/MockedRequest.ts
 var cookieUtils3 = __toESM(require("cookie"));
 var import_cookies = require("@mswjs/cookies");
+var import_interceptors = require("@mswjs/interceptors");
+var import_bufferUtils = require("@mswjs/interceptors/lib/utils/bufferUtils");
+var import_lib = require("headers-polyfill/lib");
 
 // src/utils/request/getRequestCookies.ts
 var cookieUtils2 = __toESM(require("cookie"));
@@ -629,28 +476,11 @@ function getRequestCookies(request) {
   }
 }
 
-// src/utils/request/setRequestCookies.ts
-function setRequestCookies(request) {
-  var _a;
-  const requestCookiesString = request.headers.get("cookie");
-  import_cookies.store.hydrate();
-  const cookiesFromStore = Array.from((_a = import_cookies.store.get(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }))) == null ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
-    return Object.assign(cookies, { [name.trim()]: value });
-  }, {});
-  const cookiesFromDocument = getRequestCookies(request);
-  const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
-  for (const [name, value] of Object.entries(forwardedCookies)) {
-    request.headers.append("cookie", `${name}=${value}`);
-  }
-  const ownCookies = requestCookiesString ? cookieUtils3.parse(requestCookiesString) : {};
-  request.cookies = __spreadValues(__spreadValues(__spreadValues({}, request.cookies), forwardedCookies), ownCookies);
-}
-
 // src/utils/internal/parseMultipartData.ts
-var import_headers_polyfill5 = require("headers-polyfill");
+var import_headers_polyfill3 = require("headers-polyfill");
 function parseContentHeaders(headersString) {
   var _a, _b;
-  const headers = (0, import_headers_polyfill5.stringToHeaders)(headersString);
+  const headers = (0, import_headers_polyfill3.stringToHeaders)(headersString);
   const contentType = headers.get("content-type") || "text/plain";
   const disposition = headers.get("content-disposition");
   if (!disposition) {
@@ -729,39 +559,67 @@ function isStringEqual(actual, expected) {
   return actual.toLowerCase() === expected.toLowerCase();
 }
 
-// src/utils/request/pruneGetRequestBody.ts
-function pruneGetRequestBody(request) {
-  if (request.method && isStringEqual(request.method, "GET") && request.body === "") {
-    return void 0;
+// src/utils/request/MockedRequest.ts
+var MockedRequest = class extends import_interceptors.IsomorphicRequest {
+  constructor(url, init = {}) {
+    super(url, init);
+    if (init.id) {
+      this.id = init.id;
+    }
+    this.cache = init.cache || "default";
+    this.destination = init.destination || "";
+    this.integrity = init.integrity || "";
+    this.keepalive = init.keepalive || false;
+    this.mode = init.mode || "cors";
+    this.priority = init.priority || "auto";
+    this.redirect = init.redirect || "follow";
+    this.referrer = init.referrer || "";
+    this.referrerPolicy = init.referrerPolicy || "no-referrer";
+    this.cookies = init.cookies || this.getCookies();
+  }
+  get body() {
+    const text2 = (0, import_bufferUtils.decodeBuffer)(this["_body"]);
+    const body2 = parseBody(text2, this.headers);
+    if (isStringEqual(this.method, "GET") && body2 === "") {
+      return void 0;
+    }
+    return body2;
   }
-  return request.body;
-}
+  passthrough() {
+    return {
+      status: 101,
+      statusText: "Continue",
+      headers: new import_lib.Headers(),
+      body: null,
+      passthrough: true,
+      once: false
+    };
+  }
+  getCookies() {
+    var _a;
+    const requestCookiesString = this.headers.get("cookie");
+    const ownCookies = requestCookiesString ? cookieUtils3.parse(requestCookiesString) : {};
+    import_cookies.store.hydrate();
+    const cookiesFromStore = Array.from((_a = import_cookies.store.get(__spreadProps(__spreadValues({}, this), { url: this.url.href }))) == null ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+      return Object.assign(cookies, { [name.trim()]: value });
+    }, {});
+    const cookiesFromDocument = getRequestCookies(this);
+    const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
+    for (const [name, value] of Object.entries(forwardedCookies)) {
+      this.headers.append("cookie", `${name}=${value}`);
+    }
+    return __spreadValues(__spreadValues({}, forwardedCookies), ownCookies);
+  }
+};
 
 // src/utils/request/parseWorkerRequest.ts
 function parseWorkerRequest(rawRequest) {
-  const request = {
-    id: rawRequest.id,
-    cache: rawRequest.cache,
-    credentials: rawRequest.credentials,
-    method: rawRequest.method,
-    url: new URL(rawRequest.url),
-    referrer: rawRequest.referrer,
-    referrerPolicy: rawRequest.referrerPolicy,
-    redirect: rawRequest.redirect,
-    mode: rawRequest.mode,
-    params: {},
-    cookies: {},
-    integrity: rawRequest.integrity,
-    keepalive: rawRequest.keepalive,
-    destination: rawRequest.destination,
-    body: pruneGetRequestBody(rawRequest),
-    bodyUsed: rawRequest.bodyUsed,
-    headers: new import_headers_polyfill6.Headers(rawRequest.headers),
-    passthrough
-  };
-  setRequestCookies(request);
-  request.body = parseBody(request.body, request.headers);
-  return request;
+  const url = new URL(rawRequest.url);
+  const headers = new import_headers_polyfill4.Headers(rawRequest.headers);
+  return new MockedRequest(url, __spreadProps(__spreadValues({}, rawRequest), {
+    body: (0, import_interceptors2.encodeBuffer)(rawRequest.body || ""),
+    headers
+  }));
 }
 
 // src/utils/handleRequest.ts
@@ -940,14 +798,15 @@ function getTimestamp() {
 // src/utils/logging/prepareRequest.ts
 function prepareRequest(request) {
   return __spreadProps(__spreadValues({}, request), {
+    body: request.body,
     headers: request.headers.all()
   });
 }
 
 // src/utils/logging/prepareResponse.ts
-var import_headers_polyfill7 = require("headers-polyfill");
+var import_headers_polyfill5 = require("headers-polyfill");
 function prepareResponse(res) {
-  const responseHeaders = (0, import_headers_polyfill7.objectToHeaders)(res.headers);
+  const responseHeaders = (0, import_headers_polyfill5.objectToHeaders)(res.headers);
   return __spreadProps(__spreadValues({}, res), {
     body: parseBody(res.body, responseHeaders)
   });
@@ -1014,6 +873,151 @@ function matchRequestUrl(url, path, baseUrl) {
   };
 }
 
+// src/handlers/RequestHandler.ts
+var import_headers_polyfill7 = require("headers-polyfill");
+
+// src/response.ts
+var import_headers_polyfill6 = require("headers-polyfill");
+
+// src/utils/internal/compose.ts
+function compose(...fns) {
+  return (...args) => {
+    return fns.reduceRight((leftFn, rightFn) => {
+      return leftFn instanceof Promise ? Promise.resolve(leftFn).then(rightFn) : rightFn(leftFn);
+    }, args[0]);
+  };
+}
+
+// src/response.ts
+var defaultResponse = {
+  status: 200,
+  statusText: "OK",
+  body: null,
+  delay: 0,
+  once: false,
+  passthrough: false
+};
+var defaultResponseTransformers = [];
+function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+  return async (...transformers) => {
+    const initialResponse = Object.assign({}, defaultResponse, {
+      headers: new import_headers_polyfill6.Headers({
+        "x-powered-by": "msw"
+      })
+    }, responseOverrides);
+    const resolvedTransformers = [
+      ...defaultTransformers,
+      ...transformers
+    ].filter(Boolean);
+    const resolvedResponse = resolvedTransformers.length > 0 ? compose(...resolvedTransformers)(initialResponse) : initialResponse;
+    return resolvedResponse;
+  };
+}
+var response = Object.assign(createResponseComposition(), {
+  once: createResponseComposition({ once: true }),
+  networkError(message) {
+    throw new NetworkError(message);
+  }
+});
+
+// src/utils/internal/getCallFrame.ts
+var SOURCE_FRAME = /\/msw\/src\/(.+)/;
+var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+function getCallFrame(error2) {
+  const stack = error2.stack;
+  if (!stack) {
+    return;
+  }
+  const frames = stack.split("\n").slice(1);
+  const declarationFrame = frames.find((frame) => {
+    return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
+  });
+  if (!declarationFrame) {
+    return;
+  }
+  const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
+  return declarationPath;
+}
+
+// src/utils/internal/isIterable.ts
+function isIterable(fn) {
+  if (!fn) {
+    return false;
+  }
+  return typeof fn[Symbol.iterator] == "function";
+}
+
+// src/handlers/RequestHandler.ts
+var defaultContext = {
+  status,
+  set,
+  delay,
+  fetch
+};
+var RequestHandler = class {
+  constructor(options) {
+    this.shouldSkip = false;
+    this.ctx = options.ctx || defaultContext;
+    this.resolver = options.resolver;
+    const callFrame = getCallFrame(new Error());
+    this.info = __spreadProps(__spreadValues({}, options.info), {
+      callFrame
+    });
+  }
+  parse(_request, _resolutionContext) {
+    return null;
+  }
+  test(request, resolutionContext) {
+    return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+  }
+  getPublicRequest(request, _parsedResult) {
+    return request;
+  }
+  markAsSkipped(shouldSkip = true) {
+    this.shouldSkip = shouldSkip;
+  }
+  async run(request, resolutionContext) {
+    if (this.shouldSkip) {
+      return null;
+    }
+    const parsedResult = this.parse(request, resolutionContext);
+    const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+    if (!shouldIntercept) {
+      return null;
+    }
+    const publicRequest = this.getPublicRequest(request, parsedResult);
+    const executeResolver = this.wrapResolver(this.resolver);
+    const mockedResponse = await executeResolver(publicRequest, response, this.ctx);
+    return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+  }
+  wrapResolver(resolver) {
+    return async (req, res, ctx) => {
+      const result = this.resolverGenerator || await resolver(req, res, ctx);
+      if (isIterable(result)) {
+        const { value, done } = result[Symbol.iterator]().next();
+        const nextResponse = await value;
+        if (!nextResponse && done) {
+          return this.resolverGeneratorResult;
+        }
+        if (!this.resolverGenerator) {
+          this.resolverGenerator = result;
+        }
+        this.resolverGeneratorResult = nextResponse;
+        return nextResponse;
+      }
+      return result;
+    };
+  }
+  createExecutionResult(parsedResult, request, response2) {
+    return {
+      handler: this,
+      parsedResult: parsedResult || null,
+      request,
+      response: response2 || null
+    };
+  }
+};
+
 // src/handlers/RestHandler.ts
 var RESTMethods = /* @__PURE__ */ ((RESTMethods2) => {
   RESTMethods2["HEAD"] = "HEAD";
@@ -1032,6 +1036,15 @@ var restContext = __spreadProps(__spreadValues({}, defaultContext), {
   json,
   xml
 });
+var RestRequest = class extends MockedRequest {
+  constructor(request, params) {
+    super(request.url, __spreadProps(__spreadValues({}, request), {
+      body: request["_body"]
+    }));
+    this.params = params;
+    this.id = request.id;
+  }
+};
 var RestHandler = class extends RequestHandler {
   constructor(method, path, resolver) {
     super({
@@ -1065,9 +1078,7 @@ var RestHandler = class extends RequestHandler {
     return matchRequestUrl(request.url, this.info.path, resolutionContext == null ? void 0 : resolutionContext.baseUrl);
   }
   getPublicRequest(request, parsedResult) {
-    return __spreadProps(__spreadValues({}, request), {
-      params: parsedResult.params || {}
-    });
+    return new RestRequest(request, parsedResult.params || {});
   }
   predicate(request, parsedResult) {
     const matchesMethod = this.info.method instanceof RegExp ? this.info.method.test(request.method) : isStringEqual(this.info.method, request.method);
@@ -1130,6 +1141,14 @@ function isDocumentNode(value) {
   }
   return typeof value === "object" && "kind" in value && "definitions" in value;
 }
+var GraphQLRequest = class extends MockedRequest {
+  constructor(request, variables) {
+    super(request.url, __spreadProps(__spreadValues({}, request), {
+      body: request["_body"]
+    }));
+    this.variables = variables;
+  }
+};
 var GraphQLHandler = class extends RequestHandler {
   constructor(operationType, operationName, endpoint, resolver) {
     let resolvedOperationName = operationName;
@@ -1159,9 +1178,7 @@ var GraphQLHandler = class extends RequestHandler {
     return tryCatch(() => parseGraphQLRequest(request), (error2) => console.error(error2.message));
   }
   getPublicRequest(request, parsedResult) {
-    return __spreadProps(__spreadValues({}, request), {
-      variables: (parsedResult == null ? void 0 : parsedResult.variables) || {}
-    });
+    return new GraphQLRequest(request, (parsedResult == null ? void 0 : parsedResult.variables) || {});
   }
   predicate(request, parsedResult) {
     if (!parsedResult) {
@@ -1356,69 +1373,27 @@ async function handleRequest(request, handlers, options, emitter, handleRequestO
   return transformedResponse;
 }
 
-// src/setupWorker/start/utils/streamResponse.ts
-var import_outvariant3 = require("outvariant");
-async function streamResponse(operationChannel, messageChannel, mockedResponse) {
-  const response2 = new Response(mockedResponse.body, mockedResponse);
-  delete mockedResponse.body;
-  messageChannel.send({
-    type: "MOCK_RESPONSE_START",
-    payload: mockedResponse
-  });
-  (0, import_outvariant3.invariant)(response2.body, "Failed to stream mocked response with no body");
-  const reader = response2.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (!done) {
-      operationChannel.postMessage({
-        type: "MOCK_RESPONSE_CHUNK",
-        payload: value
-      });
-      continue;
-    }
-    operationChannel.postMessage({
-      type: "MOCK_RESPONSE_END"
-    });
-    operationChannel.close();
-    reader.releaseLock();
-    break;
-  }
-}
-
-// src/utils/internal/StrictBroadcastChannel.ts
-var ParentClass = typeof BroadcastChannel == "undefined" ? class UnsupportedEnvironment {
-  constructor() {
-    throw new Error("Cannot construct BroadcastChannel in a non-browser environment");
-  }
-} : BroadcastChannel;
-var StrictBroadcastChannel = class extends ParentClass {
-  postMessage(message) {
-    return super.postMessage(message);
-  }
-};
-
 // src/setupWorker/start/createRequestListener.ts
 var createRequestListener = (context, options) => {
   return async (event, message) => {
-    const messageChannel = createMessageChannel(event);
+    const messageChannel = new WorkerChannel(event.ports[0]);
+    const request = parseWorkerRequest(message.payload);
     try {
-      const request = parseWorkerRequest(message.payload);
-      const operationChannel = new StrictBroadcastChannel(`msw-response-stream-${request.id}`);
       await handleRequest(request, context.requestHandlers, options, context.emitter, {
         transformResponse,
         onPassthroughResponse() {
-          return messageChannel.send({
-            type: "MOCK_NOT_FOUND"
-          });
+          messageChannel.postMessage("NOT_FOUND");
         },
-        onMockedResponse(response2) {
-          if (response2.body == null) {
-            return messageChannel.send({
-              type: "MOCK_RESPONSE",
-              payload: response2
-            });
+        async onMockedResponse(response2) {
+          if (response2.body instanceof ReadableStream) {
+            throw new Error(devUtils.formatMessage('Failed to construct a mocked response with a "ReadableStream" body: mocked streams are not supported. Follow https://github.com/mswjs/msw/issues/1336 for more details.'));
           }
-          streamResponse(operationChannel, messageChannel, response2);
+          const responseInstance = new Response(response2.body, response2);
+          const responseBodyBuffer = await responseInstance.arrayBuffer();
+          const responseBody = response2.body == null ? null : responseBodyBuffer;
+          messageChannel.postMessage("MOCK_RESPONSE", __spreadProps(__spreadValues({}, response2), {
+            body: responseBody
+          }), [responseBodyBuffer]);
         },
         onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
           if (options.quiet) {
@@ -1429,25 +1404,29 @@ var createRequestListener = (context, options) => {
       });
     } catch (error2) {
       if (error2 instanceof NetworkError) {
-        return messageChannel.send({
-          type: "NETWORK_ERROR",
-          payload: {
-            name: error2.name,
-            message: error2.message
-          }
+        messageChannel.postMessage("NETWORK_ERROR", {
+          name: error2.name,
+          message: error2.message
         });
+        return;
       }
       if (error2 instanceof Error) {
-        messageChannel.send({
-          type: "INTERNAL_ERROR",
-          payload: {
-            status: 500,
-            body: JSON.stringify({
-              errorType: error2.constructor.name,
-              message: error2.message,
-              location: error2.stack
-            })
-          }
+        devUtils.error(`Uncaught exception in the request handler for "%s %s":
+
+%s
+
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses`, request.method, request.url, error2);
+        messageChannel.postMessage("MOCK_RESPONSE", {
+          status: 500,
+          statusText: "Request Handler Error",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            name: error2.name,
+            message: error2.message,
+            stack: error2.stack
+          })
         });
       }
     }
@@ -1467,8 +1446,8 @@ function transformResponse(response2) {
 async function requestIntegrityCheck(context, serviceWorker) {
   context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
   const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (actualChecksum !== "c9450df6e4dc5e45740c3b0b640727a2") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"c9450df6e4dc5e45740c3b0b640727a2"}).`);
+  if (actualChecksum !== "b3066ef78c2f9090b4ce87e874965995") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"b3066ef78c2f9090b4ce87e874965995"}).`);
   }
   return serviceWorker;
 }
@@ -1646,43 +1625,18 @@ function prepareStartHandler(handler, context) {
 }
 
 // src/setupWorker/start/createFallbackRequestListener.ts
-var import_interceptors = require("@mswjs/interceptors");
+var import_interceptors3 = require("@mswjs/interceptors");
 var import_fetch3 = require("@mswjs/interceptors/lib/interceptors/fetch");
 var import_XMLHttpRequest = require("@mswjs/interceptors/lib/interceptors/XMLHttpRequest");
-
-// src/utils/request/parseIsomorphicRequest.ts
-function parseIsomorphicRequest(request) {
-  const mockedRequest = {
-    id: request.id,
-    url: request.url,
-    method: request.method,
-    body: parseBody(request.body, request.headers),
-    credentials: request.credentials || "same-origin",
-    headers: request.headers,
-    cookies: {},
-    redirect: "manual",
-    referrer: "",
-    keepalive: false,
-    cache: "default",
-    mode: "cors",
-    referrerPolicy: "no-referrer",
-    integrity: "",
-    destination: "document",
-    bodyUsed: false,
-    passthrough
-  };
-  setRequestCookies(mockedRequest);
-  return mockedRequest;
-}
-
-// src/setupWorker/start/createFallbackRequestListener.ts
 function createFallbackRequestListener(context, options) {
-  const interceptor = new import_interceptors.BatchInterceptor({
+  const interceptor = new import_interceptors3.BatchInterceptor({
     name: "fallback",
     interceptors: [new import_fetch3.FetchInterceptor(), new import_XMLHttpRequest.XMLHttpRequestInterceptor()]
   });
   interceptor.on("request", async (request) => {
-    const mockedRequest = parseIsomorphicRequest(request);
+    const mockedRequest = new MockedRequest(request.url, __spreadProps(__spreadValues({}, request), {
+      body: await request.arrayBuffer()
+    }));
     const response2 = await handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
       transformResponse(response3) {
         return {
@@ -1767,7 +1721,7 @@ function setupWorker(...requestHandlers) {
           if (event.source !== context.worker) {
             return;
           }
-          const message = jsonParse(event.data);
+          const message = event.data;
           if (!message) {
             return;
           }
@@ -1800,7 +1754,7 @@ function setupWorker(...requestHandlers) {
         return new Promise((resolve, reject) => {
           const handleIncomingMessage = (event) => {
             try {
-              const message = JSON.parse(event.data);
+              const message = event.data;
               if (message.type === eventType) {
                 resolve(message);
               }
@@ -1911,6 +1865,7 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GraphQLHandler,
+  MockedRequest,
   RESTMethods,
   RequestHandler,
   RestHandler,
@@ -1924,7 +1879,6 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
   graphqlContext,
   handleRequest,
   matchRequestUrl,
-  parseIsomorphicRequest,
   response,
   rest,
   restContext,