msw 0.42.3 → 0.44.0

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,
@@ -122,7 +122,7 @@ var cookieUtils = __toESM(require("cookie"));
 var cookie = (name, value, options) => {
   return (res) => {
     const serializedCookie = cookieUtils.serialize(name, value, options);
-    res.headers.set("Set-Cookie", serializedCookie);
+    res.headers.append("Set-Cookie", serializedCookie);
     if (typeof document !== "undefined") {
       document.cookie = serializedCookie;
     }
@@ -424,17 +424,18 @@ async function enableMocking(context, options) {
   });
 }
 
-// src/utils/createBroadcastChannel.ts
-var createBroadcastChannel = (event) => {
+// src/setupWorker/start/utils/createMessageChannel.ts
+function createMessageChannel(event) {
   const port = event.ports[0];
   return {
     send(message) {
-      if (port) {
-        port.postMessage(message);
+      if (!port) {
+        return;
       }
+      port.postMessage(message);
     }
   };
-};
+}
 
 // src/utils/NetworkError.ts
 var NetworkError = class extends Error {
@@ -445,166 +446,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"));
@@ -628,28 +478,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) {
@@ -728,39 +561,74 @@ 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(input, init = {}) {
+    var __super = (...args) => {
+      super(...args);
+    };
+    if (input instanceof import_interceptors.IsomorphicRequest) {
+      __super(input);
+    } else {
+      __super(input, 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
@@ -939,14 +807,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)
   });
@@ -1013,6 +882,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";
@@ -1031,6 +1045,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({
@@ -1064,9 +1087,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);
@@ -1129,6 +1150,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;
@@ -1158,9 +1187,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) {
@@ -1355,24 +1382,69 @@ async function handleRequest(request, handlers, options, emitter, handleRequestO
   return transformedResponse;
 }
 
-// src/utils/worker/createRequestListener.ts
+// 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 channel = createBroadcastChannel(event);
+    const messageChannel = createMessageChannel(event);
     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 channel.send({
+          return messageChannel.send({
             type: "MOCK_NOT_FOUND"
           });
         },
         onMockedResponse(response2) {
-          channel.send({
-            type: "MOCK_SUCCESS",
-            payload: response2
-          });
+          if (response2.body == null) {
+            return messageChannel.send({
+              type: "MOCK_RESPONSE",
+              payload: response2
+            });
+          }
+          streamResponse(operationChannel, messageChannel, response2);
         },
         onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
           if (options.quiet) {
@@ -1383,7 +1455,7 @@ var createRequestListener = (context, options) => {
       });
     } catch (error2) {
       if (error2 instanceof NetworkError) {
-        return channel.send({
+        return messageChannel.send({
           type: "NETWORK_ERROR",
           payload: {
             name: error2.name,
@@ -1392,7 +1464,7 @@ var createRequestListener = (context, options) => {
         });
       }
       if (error2 instanceof Error) {
-        channel.send({
+        messageChannel.send({
           type: "INTERNAL_ERROR",
           payload: {
             status: 500,
@@ -1421,8 +1493,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 !== "02f4ad4a2797f85668baf196e553d929") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"02f4ad4a2797f85668baf196e553d929"}).`);
+  if (actualChecksum !== "df0d85222361310ecbe1792c606e08f2") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"df0d85222361310ecbe1792c606e08f2"}).`);
   }
   return serviceWorker;
 }
@@ -1445,7 +1517,7 @@ function deferNetworkRequestsUntil(predicatePromise) {
   };
 }
 
-// src/utils/worker/createResponseListener.ts
+// src/setupWorker/start/createResponseListener.ts
 function createResponseListener(context) {
   return (_, message) => {
     var _a;
@@ -1599,44 +1671,17 @@ function prepareStartHandler(handler, context) {
   };
 }
 
-// src/utils/worker/createFallbackRequestListener.ts
-var import_interceptors = require("@mswjs/interceptors");
+// src/setupWorker/start/createFallbackRequestListener.ts
+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/utils/worker/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);
     const response2 = await handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
       transformResponse(response3) {
         return {
@@ -1721,7 +1766,7 @@ function setupWorker(...requestHandlers) {
           if (event.source !== context.worker) {
             return;
           }
-          const message = jsonParse(event.data);
+          const message = event.data;
           if (!message) {
             return;
           }
@@ -1754,7 +1799,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);
               }
@@ -1865,6 +1910,7 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GraphQLHandler,
+  MockedRequest,
   RESTMethods,
   RequestHandler,
   RestHandler,
@@ -1878,7 +1924,6 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
   graphqlContext,
   handleRequest,
   matchRequestUrl,
-  parseIsomorphicRequest,
   response,
   rest,
   restContext,