wrangler 2.6.2 → 2.7.0

package/src/__tests__/pages.test.ts

@@ -1,37 +1,34 @@
+/* eslint-disable no-shadow */
+import { Blob } from "node:buffer";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { chdir } from "node:process";
+import { MockedRequest, rest } from "msw";
+import { FormData } from "undici";
 import { ROUTES_SPEC_VERSION } from "../pages/constants";
 import { isRoutesJSONSpec } from "../pages/functions/routes-validation";
 import { version } from "./../../package.json";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import {
-	createFetchResult,
-	setMockRawResponse,
-	setMockResponse,
-	unsetAllMocks,
-} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw } from "./helpers/msw";
+import { FileReaderSync } from "./helpers/msw/read-file-sync";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type { Deployment, Project, UploadPayloadFile } from "../pages/types";
-import type { FormData, RequestInit } from "undici";
-
-// Asserting within mock responses get swallowed, so run them out-of-band
-const outOfBandTests: (() => void)[] = [];
-function assertLater(fn: () => void) {
-	outOfBandTests.push(fn);
-}
+import type { RestRequest } from "msw";
 
 function mockGetToken(jwt: string) {
-	return setMockResponse(
-		"/accounts/:accountId/pages/projects/foo/upload-token",
-		async ([_url, accountId]) => {
-			assertLater(() => {
-				expect(accountId).toEqual("some-account-id");
-			});
-
-			return { jwt };
-		}
+	msw.use(
+		rest.get(
+			"*/accounts/:accountId/pages/projects/foo/upload-token",
+			(req, res, ctx) => {
+				expect(req.params.accountId).toEqual("some-account-id");
+
+				return res(
+					ctx.status(200),
+					ctx.json({ success: true, errors: [], messages: [], result: { jwt } })
+				);
+			}
+		)
 	);
 }
 
@@ -41,12 +38,6 @@ describe("pages", () => {
 	function endEventLoop() {
 		return new Promise((resolve) => setImmediate(resolve));
 	}
-	beforeEach(() => {
-		outOfBandTests.length = 0;
-	});
-	afterEach(() => {
-		outOfBandTests.forEach((fn) => fn());
-	});
 
 	beforeEach(() => {
 		// @ts-expect-error we're using a very simple setTimeout mock here
@@ -54,6 +45,13 @@ describe("pages", () => {
 			setImmediate(fn);
 		});
 	});
+	afterEach(async () => {
+		// Force a tick to ensure that all promises resolve
+		await endEventLoop();
+		// Reset MSW after tick to ensure that all requests have been handled
+		msw.resetHandlers();
+		msw.restoreHandlers();
+	});
 
 	it("should should display a list of available subcommands, for pages with no subcommand", async () => {
 		await runWrangler("pages");
@@ -124,28 +122,33 @@ describe("pages", () => {
 		mockAccountId();
 		mockApiToken();
 
-		afterEach(() => {
-			unsetAllMocks();
-		});
-
 		function mockListRequest(projects: unknown[]) {
 			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/pages/projects",
-				([_url, accountId], init, query) => {
-					requests.count++;
-					const pageSize = Number(query.get("per_page"));
-					const page = Number(query.get("page"));
-					const expectedPageSize = 10;
-					const expectedPage = requests.count;
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
+			msw.use(
+				rest.get(
+					"*/accounts/:accountId/pages/projects",
+					async (req, res, ctx) => {
+						requests.count++;
+						const pageSize = Number(req.url.searchParams.get("per_page"));
+						const page = Number(req.url.searchParams.get("page"));
+						const expectedPageSize = 10;
+						const expectedPage = requests.count;
+						expect(req.params.accountId).toEqual("some-account-id");
 						expect(pageSize).toEqual(expectedPageSize);
 						expect(page).toEqual(expectedPage);
-						expect(init).toEqual({});
-					});
-					return projects.slice((page - 1) * pageSize, page * pageSize);
-				}
+						expect(await req.text()).toEqual("");
+
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: projects.slice((page - 1) * pageSize, page * pageSize),
+							})
+						);
+					}
+				)
 			);
 			return requests;
 		}
@@ -210,29 +213,34 @@ describe("pages", () => {
 		mockAccountId();
 		mockApiToken();
 
-		afterEach(() => {
-			unsetAllMocks();
-		});
-
 		it("should create a project with a production branch", async () => {
-			setMockResponse(
-				"/accounts/:accountId/pages/projects",
-				([_url, accountId], init) => {
-					const body = JSON.parse(init.body as string);
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
+			msw.use(
+				rest.post(
+					"*/accounts/:accountId/pages/projects",
+					async (req, res, ctx) => {
+						const body = await req.json();
+
+						expect(req.params.accountId).toEqual("some-account-id");
 						expect(body).toEqual({
 							name: "a-new-project",
 							production_branch: "main",
 						});
-					});
-					return {
-						name: "a-new-project",
-						subdomain: "a-new-project.pages.dev",
-						production_branch: "main",
-					};
-				}
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									name: "a-new-project",
+									subdomain: "a-new-project.pages.dev",
+									production_branch: "main",
+								},
+							})
+						);
+					}
+				)
 			);
 			await runWrangler(
 				"pages project create a-new-project --production-branch=main"
@@ -248,21 +256,28 @@ describe("pages", () => {
 		mockAccountId();
 		mockApiToken();
 
-		afterEach(() => {
-			unsetAllMocks();
-		});
 		function mockListRequest(deployments: unknown[]) {
 			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/:project/deployments",
-				([_url, accountId, project]) => {
-					requests.count++;
-					assertLater(() => {
-						expect(project).toEqual("images");
-						expect(accountId).toEqual("some-account-id");
-					});
-					return deployments;
-				}
+			msw.use(
+				rest.get(
+					"*/accounts/:accountId/pages/projects/:project/deployments",
+					(req, res, ctx) => {
+						requests.count++;
+
+						expect(req.params.project).toEqual("images");
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: deployments,
+							})
+						);
+					}
+				)
 			);
 			return requests;
 		}
@@ -302,13 +317,13 @@ describe("pages", () => {
 		mockApiToken();
 		runInTempDir();
 
+		//TODO Abstract MSW handlers that repeat to this level - JACOB
 		beforeEach(() => {
 			actualProcessEnvCI = process.env.CI;
 			process.env.CI = "true";
 		});
 
 		afterEach(() => {
-			unsetAllMocks();
 			process.env.CI = actualProcessEnvCI;
 		});
 
@@ -343,33 +358,34 @@ describe("pages", () => {
 
 		it("should upload a directory of files", async () => {
 			writeFileSync("logo.png", "foobar");
-
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["2082190357cfd3617ccfe04f340c6247"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = await req.json();
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["2082190357cfd3617ccfe04f340c6247"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toMatchInlineSnapshot(
+						`"Bearer <<funfetti-auth-jwt>>"`
+					);
+					expect(await req.json()).toMatchObject([
 						{
 							key: "2082190357cfd3617ccfe04f340c6247",
 							value: Buffer.from("foobar").toString("base64"),
@@ -379,39 +395,55 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
-						const manifest = JSON.parse(body.get("manifest") as string);
-						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/logo.png": "2082190357cfd3617ccfe04f340c6247",
-				                          }
-			                      `);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
+					return res.once(
+						ctx.status(200),
+						ctx.json({ success: true, errors: [], messages: [], result: null })
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						expect(await (req as RestRequestWithFormData).formData())
+							.toMatchInlineSnapshot(`
+				FormData {
+				  Symbol(state): Array [
+				    Object {
+				      "name": "manifest",
+				      "value": "{\\"/logo.png\\":\\"2082190357cfd3617ccfe04f340c6247\\"}",
+				    },
+				  ],
 				}
+			`);
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { deployment_configs: { production: {}, preview: {} } },
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish . --project-name=foo");
@@ -428,84 +460,35 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
-						});
-					});
-					return body.hashes;
-				}
-			);
-
 			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockRawResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-
-				if (requests.length < 2) {
-					return createFetchResult(null, false, [
-						{
-							code: 800000,
-							message: "Something exploded, please retry",
-						},
-					]);
-				} else {
-					return createFetchResult(null, true);
-				}
-			});
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
-						const manifest = JSON.parse(body.get("manifest") as string);
-						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
-				                          }
-			                      `);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
-			);
-
-			await runWrangler("pages publish . --project-name=foo");
+			const requests: RestRequest[] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = await req.json();
 
-			// Assert two identical requests
-			expect(requests.length).toBe(2);
-			for (const init of requests) {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
 					});
 
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(await req.json()).toMatchObject([
 						{
 							key: "1a98fb08af91aca4a7df1764a2c4ddb0",
 							value: Buffer.from("foobar").toString("base64"),
@@ -515,8 +498,80 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			}
+
+					if (requests.length < 2) {
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: false,
+								errors: [
+									{
+										code: 800000,
+										message: "Something exploded, please retry",
+									},
+								],
+								messages: [],
+								result: null,
+							})
+						);
+					} else {
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: null,
+							})
+						);
+					}
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						expect(await (req as RestRequestWithFormData).formData())
+							.toMatchInlineSnapshot(`
+				FormData {
+				  Symbol(state): Array [
+				    Object {
+				      "name": "manifest",
+				      "value": "{\\"/logo.txt\\":\\"1a98fb08af91aca4a7df1764a2c4ddb0\\"}",
+				    },
+				  ],
+				}
+			`);
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { url: "https://abcxyz.foo.pages.dev/" },
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { deployment_configs: { production: {}, preview: {} } },
+							})
+						);
+					}
+				)
+			);
+
+			await runWrangler("pages publish . --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "✨ Success! Uploaded 1 files (TIMINGS)
@@ -527,104 +582,125 @@ describe("pages", () => {
 
 		it("should refetch a JWT if it expires while uploading", async () => {
 			writeFileSync("logo.txt", "foobar");
+			mockGetToken("<<funfetti-auth-jwt>>");
 
-			const cancelMockGetToken = mockGetToken("<<funfetti-auth-jwt>>");
+			const requests: RestRequest[] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as { hashes: string[] };
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
-						});
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
 					});
-					return body.hashes;
-				}
-			);
 
-			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockRawResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-
-				// Fail just the first request
-				if (requests.length < 2) {
-					cancelMockGetToken();
-					mockGetToken("<<funfetti-auth-jwt2>>");
-					return createFetchResult(null, false, [
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
+					expect(await req.json()).toMatchObject([
 						{
-							code: 8000013,
-							message: "Authorization failed",
+							key: "1a98fb08af91aca4a7df1764a2c4ddb0",
+							value: Buffer.from("foobar").toString("base64"),
+							metadata: {
+								contentType: "text/plain",
+							},
+							base64: true,
 						},
 					]);
-				} else {
-					return createFetchResult(null, true);
-				}
-			});
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
-						const manifest = JSON.parse(body.get("manifest") as string);
-						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
-				                          }
-			                      `);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
+					// Fail just the first request
+					if (requests.length < 2) {
+						mockGetToken("<<funfetti-auth-jwt2>>");
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: false,
+								errors: [
+									{
+										code: 8000013,
+										message: "Authorization failed",
+									},
+								],
+								messages: [],
+								result: null,
+							})
+						);
+					} else {
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: null,
+							})
+						);
+					}
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						expect(await (req as RestRequestWithFormData).formData())
+							.toMatchInlineSnapshot(`
+				FormData {
+				  Symbol(state): Array [
+				    Object {
+				      "name": "manifest",
+				      "value": "{\\"/logo.txt\\":\\"1a98fb08af91aca4a7df1764a2c4ddb0\\"}",
+				    },
+				  ],
 				}
-			);
+			`);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { url: "https://abcxyz.foo.pages.dev/" },
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { deployment_configs: { production: {}, preview: {} } },
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish . --project-name=foo");
 
-			// Assert two requests
-			expect(requests.length).toBe(2);
-
-			expect(requests[0].headers).toMatchObject({
-				Authorization: "Bearer <<funfetti-auth-jwt>>",
-			});
-
-			expect(requests[1].headers).toMatchObject({
-				Authorization: "Bearer <<funfetti-auth-jwt2>>",
-			});
+			expect(requests[0].headers.get("Authorization")).toBe(
+				"Bearer <<funfetti-auth-jwt>>"
+			);
 
-			for (const init of requests) {
-				const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-				expect(body).toMatchObject([
-					{
-						key: "1a98fb08af91aca4a7df1764a2c4ddb0",
-						value: Buffer.from("foobar").toString("base64"),
-						metadata: {
-							contentType: "text/plain",
-						},
-						base64: true,
-					},
-				]);
-			}
+			expect(requests[1].headers.get("Authorization")).toBe(
+				"Bearer <<funfetti-auth-jwt2>>"
+			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "✨ Success! Uploaded 1 files (TIMINGS)
@@ -641,80 +717,110 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: expect.arrayContaining([
-								"d96fef225537c9f5e44a3cb27fd0b492",
-								"2082190357cfd3617ccfe04f340c6247",
-								"6be321bef99e758250dac034474ddbb8",
-								"1a98fb08af91aca4a7df1764a2c4ddb0",
-							]),
-						});
-					});
-					return body.hashes;
-				}
-			);
-
 			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-			});
+			const requests: RestRequest[] = [];
+			const bodies: UploadPayloadFile[][] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
-						const manifest = JSON.parse(body.get("manifest") as string);
-						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
-				                            "/logo.js": "6be321bef99e758250dac034474ddbb8",
-				                            "/logo.png": "2082190357cfd3617ccfe04f340c6247",
-				                            "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
-				                          }
-			                      `);
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: expect.arrayContaining([
+							"d96fef225537c9f5e44a3cb27fd0b492",
+							"2082190357cfd3617ccfe04f340c6247",
+							"6be321bef99e758250dac034474ddbb8",
+							"1a98fb08af91aca4a7df1764a2c4ddb0",
+						]),
 					});
 
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					bodies.push((await req.json()) as UploadPayloadFile[]);
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						const body = await (req as RestRequestWithFormData).formData();
+						const manifest = JSON.parse(body.get("manifest") as string);
+
+						expect(manifest).toMatchInlineSnapshot(`
+						                      Object {
+						                        "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
+						                        "/logo.js": "6be321bef99e758250dac034474ddbb8",
+						                        "/logo.png": "2082190357cfd3617ccfe04f340c6247",
+						                        "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
+						                      }
+						                `);
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish . --project-name=foo");
 
 			// We have 3 buckets, so expect 3 uploads
 			expect(requests.length).toBe(3);
-			const bodies: UploadPayloadFile[][] = [];
-			for (const init of requests) {
-				expect(init.headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
-				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
-			}
+
 			// One bucket should end up with 2 files
 			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
@@ -764,82 +870,105 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as {
+			// Accumulate multiple requests then assert afterwards
+			const requests: RestRequest[] = [];
+			const bodies: UploadPayloadFile[][] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
 						hashes: string[];
 					};
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: expect.arrayContaining([
-								"d96fef225537c9f5e44a3cb27fd0b492",
-								"2082190357cfd3617ccfe04f340c6247",
-								"6be321bef99e758250dac034474ddbb8",
-								"1a98fb08af91aca4a7df1764a2c4ddb0",
-							]),
-						});
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: expect.arrayContaining([
+							"d96fef225537c9f5e44a3cb27fd0b492",
+							"2082190357cfd3617ccfe04f340c6247",
+							"6be321bef99e758250dac034474ddbb8",
+							"1a98fb08af91aca4a7df1764a2c4ddb0",
+						]),
 					});
-					return body.hashes;
-				}
-			);
 
-			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-			});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					bodies.push((await req.json()) as UploadPayloadFile[]);
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/imgs/logo.png": "2082190357cfd3617ccfe04f340c6247",
-				                            "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
-				                            "/logo.js": "6be321bef99e758250dac034474ddbb8",
-				                            "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
-				                          }
-			                      `);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						                      Object {
+						                        "/imgs/logo.png": "2082190357cfd3617ccfe04f340c6247",
+						                        "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
+						                        "/logo.js": "6be321bef99e758250dac034474ddbb8",
+						                        "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
+						                      }
+						                `);
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { url: "https://abcxyz.foo.pages.dev/" },
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler(`pages publish public --project-name=foo`);
 
 			// We have 3 buckets, so expect 3 uploads
 			expect(requests.length).toBe(3);
-			const bodies: UploadPayloadFile[][] = [];
-			for (const init of requests) {
-				expect(init.headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
-				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
-			}
 			// One bucket should end up with 2 files
 			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
@@ -889,83 +1018,106 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as {
+			// Accumulate multiple requests then assert afterwards
+			const requests: RestRequest[] = [];
+			const bodies: UploadPayloadFile[][] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
 						hashes: string[];
 					};
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: expect.arrayContaining([
-								"d96fef225537c9f5e44a3cb27fd0b492",
-								"2082190357cfd3617ccfe04f340c6247",
-								"6be321bef99e758250dac034474ddbb8",
-								"1a98fb08af91aca4a7df1764a2c4ddb0",
-							]),
-						});
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: expect.arrayContaining([
+							"d96fef225537c9f5e44a3cb27fd0b492",
+							"2082190357cfd3617ccfe04f340c6247",
+							"6be321bef99e758250dac034474ddbb8",
+							"1a98fb08af91aca4a7df1764a2c4ddb0",
+						]),
 					});
-					return body.hashes;
-				}
-			);
 
-			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-			});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					bodies.push((await req.json()) as UploadPayloadFile[]);
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/imgs/logo.png": "2082190357cfd3617ccfe04f340c6247",
-				                            "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
-				                            "/logo.js": "6be321bef99e758250dac034474ddbb8",
-				                            "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
-				                          }
-			                      `);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						                      Object {
+						                        "/imgs/logo.png": "2082190357cfd3617ccfe04f340c6247",
+						                        "/logo.html": "d96fef225537c9f5e44a3cb27fd0b492",
+						                        "/logo.js": "6be321bef99e758250dac034474ddbb8",
+						                        "/logo.txt": "1a98fb08af91aca4a7df1764a2c4ddb0",
+						                      }
+						                `);
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { url: "https://abcxyz.foo.pages.dev/" },
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			chdir("public");
 			await runWrangler(`pages publish . --project-name=foo`);
-
 			// We have 3 buckets, so expect 3 uploads
 			expect(requests.length).toBe(3);
-			const bodies: UploadPayloadFile[][] = [];
-			for (const init of requests) {
-				expect(init.headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
-				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
-			}
 			// One bucket should end up with 2 files
 			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
@@ -1013,29 +1165,35 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["7b764dacfd211bebd8077828a7ddefd7"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["7b764dacfd211bebd8077828a7ddefd7"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					const body = (await req.json()) as UploadPayloadFile[];
 					expect(body).toMatchObject([
 						{
 							key: "7b764dacfd211bebd8077828a7ddefd7",
@@ -1046,25 +1204,50 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async () => ({
-					url: "https://abcxyz.foo.pages.dev/",
-				})
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: { url: "https://abcxyz.foo.pages.dev/" },
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish . --project-name=foo");
@@ -1103,30 +1286,35 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1136,46 +1324,51 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: true,
+						})
+					);
+				}),
+				rest.post(`*/pages/assets/upsert-hashes`, async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
 
-			setMockResponse(
-				`/pages/assets/upsert-hashes`,
-				"POST",
-				async (_, init) => {
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
+					expect(await req.json()).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
 
-					return Promise.resolve(true);
-				}
-			);
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: true,
+						})
+					);
+				}),
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(async () => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
 
 						// for Functions projects, we auto-generate a `_worker.js`,
 						// `functions-filepath-routing-config.json`, and `_routes.json`
 						// file, based on the contents of `/functions`
-						const generatedWorkerJS = body.get("_worker.js") as Blob;
-						const generatedRoutesJSON = await (
-							body.get("_routes.json") as Blob
-						).text();
-						const generatedFilepathRoutingConfig = await (
-							body.get("functions-filepath-routing-config.json") as Blob
-						).text();
+						const generatedWorkerJS = body.get("_worker.js") as string;
+						const generatedRoutesJSON = body.get("_routes.json") as string;
+						const generatedFilepathRoutingConfig = body.get(
+							"functions-filepath-routing-config.json"
+						) as string;
 
 						// make sure this is all we uploaded
 						expect([...body.keys()]).toEqual([
@@ -1186,10 +1379,10 @@ describe("pages", () => {
 						]);
 
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
-				                          }
-			                      `);
+						                        Object {
+						                          "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
+						                        }
+						                  `);
 
 						// the contents of the generated `_worker.js` file is pretty massive, so I don't
 						// think snapshot testing makes much sense here. Plus, calling
@@ -1198,7 +1391,7 @@ describe("pages", () => {
 						// file contents is too big). So for now, let's test that _worker.js was indeed
 						// generated and that the file size is greater than zero
 						expect(generatedWorkerJS).not.toBeNull();
-						expect(generatedWorkerJS.size).toBeGreaterThan(0);
+						expect(generatedWorkerJS.length).toBeGreaterThan(0);
 
 						const maybeRoutesJSONSpec = JSON.parse(generatedRoutesJSON);
 						expect(isRoutesJSONSpec(maybeRoutesJSONSpec)).toBe(true);
@@ -1227,23 +1420,38 @@ describe("pages", () => {
 							],
 							baseURL: "/",
 						});
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish public --project-name=foo");
@@ -1278,30 +1486,35 @@ describe("pages", () => {
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1311,56 +1524,75 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(async () => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: true,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
-						const customWorkerJS = await (
-							body.get("_worker.js") as Blob
-						).text();
+						const customWorkerJS = body.get("_worker.js");
 
 						// make sure this is all we uploaded
-						expect([...body.keys()]).toEqual(["manifest", "_worker.js"]);
+						expect([...body.keys()].sort()).toEqual(
+							["manifest", "_worker.js"].sort()
+						);
 
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
-				                          }
-			                      `);
+							                          Object {
+							                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
+							                          }
+						                      `);
 
 						expect(customWorkerJS).toMatchInlineSnapshot(`
-				"
-								export default {
-									async fetch(request, env) {
-										const url = new URL(request.url);
-										return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
-								};
 							"
-			`);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+											export default {
+												async fetch(request, env) {
+													const url = new URL(request.url);
+													return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
+											};
+										"
+						`);
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish public --project-name=foo");
@@ -1414,31 +1646,35 @@ describe("pages", () => {
 			);
 
 			mockGetToken("<<funfetti-auth-jwt>>");
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					return body.hashes;
-				}
-			);
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
-					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1448,60 +1684,67 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
 
-			setMockResponse(
-				`/pages/assets/upsert-hashes`,
-				"POST",
-				async (_, init) => {
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(`*/pages/assets/upsert-hashes`, async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
 
-					return Promise.resolve(true);
-				}
-			);
+					expect(await req.json()).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
+					});
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(async () => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: true,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
-						const generatedWorkerJS = body.get("_worker.js") as Blob;
-						const customRoutesJSON = await (
-							body.get("_routes.json") as Blob
-						).text();
-						const generatedFilepathRoutingConfig = await (
-							body.get("functions-filepath-routing-config.json") as Blob
-						).text();
+						const generatedWorkerJS = body.get("_worker.js") as string;
+						const customRoutesJSON = body.get("_routes.json") as string;
+						const generatedFilepathRoutingConfig = body.get(
+							"functions-filepath-routing-config.json"
+						) as string;
 
 						// make sure this is all we uploaded
-						expect([...body.keys()]).toEqual([
-							"manifest",
-							"functions-filepath-routing-config.json",
-							"_worker.js",
-							"_routes.json",
-						]);
+						expect([...body.keys()].sort()).toEqual(
+							[
+								"manifest",
+								"functions-filepath-routing-config.json",
+								"_worker.js",
+								"_routes.json",
+							].sort()
+						);
 
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
-				                          }
-			                      `);
+						                      Object {
+						                        "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
+						                      }
+						                `);
 
 						// file content of generated `_worker.js` is too massive to snapshot test
 						expect(generatedWorkerJS).not.toBeNull();
-						expect(generatedWorkerJS.size).toBeGreaterThan(0);
+						expect(generatedWorkerJS.length).toBeGreaterThan(0);
 
 						const customRoutes = JSON.parse(customRoutesJSON);
 						expect(customRoutes).toMatchObject({
@@ -1518,7 +1761,6 @@ describe("pages", () => {
 						// The actual shape doesn't matter that much since this
 						// is only used for display in Dash, but it's still useful for
 						// tracking unexpected changes to this config.
-						console.log(generatedFilepathRoutingConfig);
 						expect(parsedFilepathRoutingConfig).toStrictEqual({
 							routes: [
 								{
@@ -1536,23 +1778,38 @@ describe("pages", () => {
 							],
 							baseURL: "/",
 						});
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish public --project-name=foo");
@@ -1604,31 +1861,35 @@ describe("pages", () => {
 			);
 
 			mockGetToken("<<funfetti-auth-jwt>>");
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					return body.hashes;
-				}
-			);
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
-					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1638,18 +1899,35 @@ describe("pages", () => {
 							base64: true,
 						},
 					]);
-				});
-			});
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await expect(runWrangler("pages publish public --project-name=foo"))
@@ -1697,30 +1975,35 @@ and that at least one include rule is provided.
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1730,41 +2013,44 @@ and that at least one include rule is provided.
 							base64: true,
 						},
 					]);
-				});
-			});
 
-			setMockResponse(
-				`/pages/assets/upsert-hashes`,
-				"POST",
-				async (_, init) => {
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+				rest.post(`*/pages/assets/upsert-hashes`, async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
 
-					return Promise.resolve(true);
-				}
-			);
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: true,
+						})
+					);
+				}),
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						const body = await (req as RestRequestWithFormData).formData();
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(async () => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
 						const manifest = JSON.parse(body.get("manifest") as string);
-						const customWorkerJS = await (
-							body.get("_worker.js") as Blob
-						).text();
-						const customRoutesJSON = await (
-							body.get("_routes.json") as Blob
-						).text();
+						const customWorkerJS = body.get("_worker.js") as string;
+						const customRoutesJSON = body.get("_routes.json") as string;
 
 						// make sure this is all we uploaded
 						expect([...body.keys()]).toEqual([
@@ -1772,47 +2058,61 @@ and that at least one include rule is provided.
 							"_worker.js",
 							"_routes.json",
 						]);
-
+						expect(req.params.accountId).toEqual("some-account-id");
 						expect(manifest).toMatchInlineSnapshot(`
-				Object {
-				  "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
-				}
-			`);
+							Object {
+							  "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
+							}
+						`);
 
 						expect(customWorkerJS).toMatchInlineSnapshot(`
-				"
-								export default {
-									async fetch(request, env) {
-										const url = new URL(request.url);
-										return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
-								};
 							"
-			`);
-
-						const customRoutes = JSON.parse(customRoutesJSON);
-						expect(customRoutes).toMatchObject({
+											export default {
+												async fetch(request, env) {
+													const url = new URL(request.url);
+													return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
+											};
+										"
+						`);
+
+						expect(JSON.parse(customRoutesJSON)).toMatchObject({
 							version: ROUTES_SPEC_VERSION,
 							description: "Custom _routes.json file",
 							include: ["/api/*"],
 							exclude: [],
 						});
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish public --project-name=foo");
@@ -1864,30 +2164,35 @@ and that at least one include rule is provided.
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1897,18 +2202,35 @@ and that at least one include rule is provided.
 							base64: true,
 						},
 					]);
-				});
-			});
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await expect(runWrangler("pages publish public --project-name=foo"))
@@ -1954,30 +2276,35 @@ and that at least one include rule is provided.
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["13a03eaf24ae98378acd36ea00f77f2f"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
 							key: "13a03eaf24ae98378acd36ea00f77f2f",
 							value: Buffer.from("This is a readme").toString("base64"),
@@ -1987,56 +2314,76 @@ and that at least one include rule is provided.
 							base64: true,
 						},
 					]);
-				});
-			});
 
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo/deployments",
-				async ([_url, accountId], init) => {
-					assertLater(async () => {
-						expect(accountId).toEqual("some-account-id");
-						expect(init.method).toEqual("POST");
-						const body = init.body as FormData;
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}),
+
+				rest.post(
+					"*/accounts/:accountId/pages/projects/foo/deployments",
+					async (req, res, ctx) => {
+						const body = await (req as RestRequestWithFormData).formData();
 						const manifest = JSON.parse(body.get("manifest") as string);
-						const customWorkerJS = await (
-							body.get("_worker.js") as Blob
-						).text();
+						const customWorkerJS = body.get("_worker.js");
 
+						expect(req.params.accountId).toEqual("some-account-id");
 						// make sure this is all we uploaded
-						expect([...body.keys()]).toEqual(["manifest", "_worker.js"]);
-
+						expect([...body.keys()].sort()).toEqual(
+							["manifest", "_worker.js"].sort()
+						);
 						expect(manifest).toMatchInlineSnapshot(`
-				                          Object {
-				                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
-				                          }
-			                      `);
-
+							                          Object {
+							                            "/README.md": "13a03eaf24ae98378acd36ea00f77f2f",
+							                          }
+						                      `);
 						expect(customWorkerJS).toMatchInlineSnapshot(`
-				"
-								export default {
-									async fetch(request, env) {
-										const url = new URL(request.url);
-										return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
-								};
 							"
-			`);
-					});
-
-					return {
-						url: "https://abcxyz.foo.pages.dev/",
-					};
-				}
-			);
-
-			setMockResponse(
-				"/accounts/:accountId/pages/projects/foo",
-				"GET",
-				async ([_url, accountId]) => {
-					assertLater(() => {
-						expect(accountId).toEqual("some-account-id");
-					});
-					return { deployment_configs: { production: {}, preview: {} } };
-				}
+											export default {
+												async fetch(request, env) {
+													const url = new URL(request.url);
+													return url.pathname.startsWith('/api/') ? new Response('Ok') : env.ASSETS.fetch(request);
+											};
+										"
+						`);
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									url: "https://abcxyz.foo.pages.dev/",
+								},
+							})
+						);
+					}
+				),
+				rest.get(
+					"*/accounts/:accountId/pages/projects/foo",
+					async (req, res, ctx) => {
+						expect(req.params.accountId).toEqual("some-account-id");
+
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: {
+									deployment_configs: { production: {}, preview: {} },
+								},
+							})
+						);
+					}
+				)
 			);
 
 			await runWrangler("pages publish public --project-name=foo");
@@ -2065,48 +2412,62 @@ and that at least one include rule is provided.
 		});
 
 		afterEach(() => {
-			unsetAllMocks();
 			process.env = ENV_COPY;
 		});
 
 		it("should upload a directory of files with a provided JWT", async () => {
 			writeFileSync("logo.png", "foobar");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["2082190357cfd3617ccfe04f340c6247"],
-						});
-					});
-					return body.hashes;
-				}
-			);
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["2082190357cfd3617ccfe04f340c6247"],
 					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					expect(await req.json()).toMatchObject([
 						{
+							base64: true,
 							key: "2082190357cfd3617ccfe04f340c6247",
-							value: Buffer.from("foobar").toString("base64"),
 							metadata: {
 								contentType: "image/png",
 							},
-							base64: true,
+							value: "Zm9vYmFy",
 						},
 					]);
-				});
-			});
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				})
+			);
 
 			await runWrangler("pages project upload .");
 
@@ -2135,100 +2496,103 @@ and that at least one include rule is provided.
 			mkdirSync("functions");
 			writeFileSync("functions/foo.js", "func");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: [
-								"2082190357cfd3617ccfe04f340c6247",
-								"95dedb64e6d4940fc2e0f11f711cc2f4",
-								"09a79777abda8ccc8bdd51dd3ff8e9e9",
-							],
-						});
+			// Accumulate multiple requests then assert afterwards
+			const requests: RestRequest[] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as {
+						hashes: string[];
+					};
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: [
+							"2082190357cfd3617ccfe04f340c6247",
+							"95dedb64e6d4940fc2e0f11f711cc2f4",
+							"09a79777abda8ccc8bdd51dd3ff8e9e9",
+						],
 					});
-					return body.hashes;
-				}
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", (req, res, ctx) => {
+					requests.push(req);
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				})
 			);
 
-			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockRawResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
+			await runWrangler("pages project upload .");
 
-				return createFetchResult(null, true);
-			});
+			expect(requests.length).toBe(3);
 
-			assertLater(() => {
-				expect(requests.length).toBe(3);
+			const resolvedRequests = await Promise.all(
+				requests.map(async (req) => await req.json<UploadPayloadFile>())
+			);
 
-				const sortedRequests = requests.sort((a, b) => {
-					return (JSON.parse(a.body as string)[0].key as string).localeCompare(
-						JSON.parse(b.body as string)[0].key as string
-					);
-				});
+			const sortedRequests = resolvedRequests.sort((a, b) => {
+				const aKey = a.key as string;
+				const bKey = b.key as string;
 
-				expect(sortedRequests[0].headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
-
-				let body = JSON.parse(
-					sortedRequests[0].body as string
-				) as UploadPayloadFile[];
-				expect(body).toMatchObject([
-					{
-						key: "09a79777abda8ccc8bdd51dd3ff8e9e9",
-						value: Buffer.from("func").toString("base64"),
-						metadata: {
-							contentType: "application/javascript",
-						},
-						base64: true,
-					},
-				]);
+				return aKey?.localeCompare(bKey);
+			});
 
-				expect(sortedRequests[1].headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
+			for (const req of requests) {
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+			}
 
-				body = JSON.parse(
-					sortedRequests[1].body as string
-				) as UploadPayloadFile[];
-				expect(body).toMatchObject([
-					{
-						key: "2082190357cfd3617ccfe04f340c6247",
-						value: Buffer.from("foobar").toString("base64"),
-						metadata: {
-							contentType: "image/png",
-						},
-						base64: true,
+			expect(sortedRequests[0]).toMatchObject([
+				{
+					base64: true,
+					key: "95dedb64e6d4940fc2e0f11f711cc2f4",
+					metadata: {
+						contentType: "application/octet-stream",
 					},
-				]);
-
-				expect(sortedRequests[2].headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
+					value: "aGVhZGVyc2ZpbGU=",
+				},
+			]);
 
-				body = JSON.parse(
-					sortedRequests[2].body as string
-				) as UploadPayloadFile[];
-				expect(body).toMatchObject([
-					{
-						key: "95dedb64e6d4940fc2e0f11f711cc2f4",
-						value: Buffer.from("headersfile").toString("base64"),
-						metadata: {
-							contentType: "application/octet-stream",
-						},
-						base64: true,
+			expect(sortedRequests[1]).toMatchObject([
+				{
+					base64: true,
+					key: "2082190357cfd3617ccfe04f340c6247",
+					metadata: {
+						contentType: "image/png",
 					},
-				]);
-			});
+					value: "Zm9vYmFy",
+				},
+			]);
 
-			await runWrangler("pages project upload .");
+			expect(sortedRequests[2]).toMatchObject([
+				{
+					base64: true,
+					key: "09a79777abda8ccc8bdd51dd3ff8e9e9",
+					metadata: {
+						contentType: "application/javascript",
+					},
+					value: "ZnVuYw==",
+				},
+			]);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "✨ Success! Uploaded 3 files (TIMINGS)
@@ -2240,62 +2604,81 @@ and that at least one include rule is provided.
 		it("should retry uploads", async () => {
 			writeFileSync("logo.txt", "foobar");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
-						});
-					});
-					return body.hashes;
-				}
-			);
-
 			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockRawResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
+			const requests: RestRequest[] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as { hashes: string[] };
 
-				if (requests.length < 2) {
-					return createFetchResult(null, false, [
-						{
-							code: 800000,
-							message: "Something exploded, please retry",
-						},
-					]);
-				} else {
-					return createFetchResult(null, true);
-				}
-			});
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
+					});
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
+
+					if (requests.length < 2) {
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: false,
+								errors: [
+									{
+										code: 800000,
+										message: "Something exploded, please retry",
+									},
+								],
+								messages: [],
+								result: null,
+							})
+						);
+					} else {
+						return res(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: null,
+							})
+						);
+					}
+				})
+			);
 
 			await runWrangler("pages project upload .");
 
 			// Assert two identical requests
 			expect(requests.length).toBe(2);
 			for (const init of requests) {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
-					});
+				expect(init.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
 
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
-					expect(body).toMatchObject([
-						{
-							key: "1a98fb08af91aca4a7df1764a2c4ddb0",
-							value: Buffer.from("foobar").toString("base64"),
-							metadata: {
-								contentType: "text/plain",
-							},
-							base64: true,
+				const body = (await init.json()) as UploadPayloadFile[];
+				expect(body).toMatchObject([
+					{
+						key: "1a98fb08af91aca4a7df1764a2c4ddb0",
+						value: Buffer.from("foobar").toString("base64"),
+						metadata: {
+							contentType: "text/plain",
 						},
-					]);
-				});
+						base64: true,
+					},
+				]);
 			}
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -2313,33 +2696,52 @@ and that at least one include rule is provided.
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
-						expect(body).toMatchObject({
-							hashes: expect.arrayContaining([
-								"d96fef225537c9f5e44a3cb27fd0b492",
-								"2082190357cfd3617ccfe04f340c6247",
-								"6be321bef99e758250dac034474ddbb8",
-								"1a98fb08af91aca4a7df1764a2c4ddb0",
-							]),
-						});
+			// Accumulate multiple requests then assert afterwards
+			const requests: RestRequest[] = [];
+			msw.use(
+				rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+					const body = (await req.json()) as { hashes: string[] };
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: expect.arrayContaining([
+							"d96fef225537c9f5e44a3cb27fd0b492",
+							"2082190357cfd3617ccfe04f340c6247",
+							"6be321bef99e758250dac034474ddbb8",
+							"1a98fb08af91aca4a7df1764a2c4ddb0",
+						]),
 					});
-					return body.hashes;
-				}
-			);
 
-			// Accumulate multiple requests then assert afterwards
-			const requests: RequestInit[] = [];
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				requests.push(init);
-			});
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					requests.push(req);
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				})
+			);
 
 			await runWrangler("pages project upload .");
 
@@ -2347,10 +2749,7 @@ and that at least one include rule is provided.
 			expect(requests.length).toBe(3);
 			const bodies: UploadPayloadFile[][] = [];
 			for (const init of requests) {
-				expect(init.headers).toMatchObject({
-					Authorization: "Bearer <<funfetti-auth-jwt>>",
-				});
-				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
+				bodies.push((await init.json()) as UploadPayloadFile[]);
 			}
 			// One bucket should end up with 2 files
 			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
@@ -2399,29 +2798,36 @@ and that at least one include rule is provided.
 
 			mockGetToken("<<funfetti-auth-jwt>>");
 
-			setMockResponse(
-				"/pages/assets/check-missing",
-				"POST",
-				async (_, init) => {
-					const body = JSON.parse(init.body as string) as { hashes: string[] };
-					assertLater(() => {
-						expect(init.headers).toMatchObject({
-							Authorization: "Bearer <<funfetti-auth-jwt>>",
-						});
+			msw.use(
+				rest.post(
+					"*/pages/assets/check-missing",
+
+					async (req, res, ctx) => {
+						const body = (await req.json()) as { hashes: string[] };
+
+						expect(req.headers.get("Authorization")).toBe(
+							"Bearer <<funfetti-auth-jwt>>"
+						);
 						expect(body).toMatchObject({
 							hashes: ["7b764dacfd211bebd8077828a7ddefd7"],
 						});
-					});
-					return body.hashes;
-				}
-			);
 
-			setMockResponse("/pages/assets/upload", "POST", async (_, init) => {
-				assertLater(() => {
-					expect(init.headers).toMatchObject({
-						Authorization: "Bearer <<funfetti-auth-jwt>>",
-					});
-					const body = JSON.parse(init.body as string) as UploadPayloadFile[];
+						return res.once(
+							ctx.status(200),
+							ctx.json({
+								success: true,
+								errors: [],
+								messages: [],
+								result: body.hashes,
+							})
+						);
+					}
+				),
+				rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					const body = (await req.json()) as UploadPayloadFile[];
 					expect(body).toMatchObject([
 						{
 							key: "7b764dacfd211bebd8077828a7ddefd7",
@@ -2432,8 +2838,18 @@ and that at least one include rule is provided.
 							base64: true,
 						},
 					]);
-				});
-			});
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				})
+			);
 
 			await runWrangler("pages project upload .");
 
@@ -2441,3 +2857,43 @@ and that at least one include rule is provided.
 		});
 	});
 });
+
+function mockFormDataToString(this: FormData) {
+	const entries = [];
+	for (const [key, value] of this.entries()) {
+		if (value instanceof Blob) {
+			const reader = new FileReaderSync();
+			reader.readAsText(value);
+			const result = reader.result;
+			entries.push([key, result]);
+		} else {
+			entries.push([key, value]);
+		}
+	}
+	return JSON.stringify({
+		__formdata: entries,
+	});
+}
+
+async function mockFormDataFromString(this: MockedRequest): Promise<FormData> {
+	const { __formdata } = await this.json();
+	expect(__formdata).toBeInstanceOf(Array);
+
+	const form = new FormData();
+	for (const [key, value] of __formdata) {
+		form.set(key, value);
+	}
+	return form;
+}
+
+// The following two functions workaround the fact that MSW does not yet support FormData in requests.
+// We use the fact that MSW relies upon `node-fetch` internally, which will call `toString()` on the FormData object,
+// rather than passing it through or serializing it as a proper FormData object.
+// The hack is to serialize FormData to a JSON string by overriding `FormData.toString()`.
+// And then to deserialize back to a FormData object by monkey-patching a `formData()` helper onto `MockedRequest`.
+FormData.prototype.toString = mockFormDataToString;
+export interface RestRequestWithFormData extends MockedRequest, RestRequest {
+	formData(): Promise<FormData>;
+}
+(MockedRequest.prototype as RestRequestWithFormData).formData =
+	mockFormDataFromString;