wrangler 2.0.27 → 2.1.0

package/src/__tests__/tail.test.ts

@@ -3,7 +3,9 @@ import { Headers, Request } from "undici";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockGetZoneFromHostRequest } from "./helpers/mock-get-zone-from-host";
 import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockCollectKnownRoutesRequest } from "./helpers/mock-known-routes";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type {
@@ -12,6 +14,7 @@ import type {
 	ScheduledEvent,
 	AlarmEvent,
 } from "../tail";
+import type { RequestInit } from "undici";
 import type WebSocket from "ws";
 
 describe("tail", () => {
@@ -42,26 +45,58 @@ describe("tail", () => {
 
 		it("creates and then delete tails", async () => {
 			const api = mockWebsocketAPIs();
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			api.ws.close();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+		it("should connect to the worker assigned to a given route", async () => {
+			const api = mockWebsocketAPIs();
+			expect(api.requests.creation.length).toStrictEqual(0);
+
+			mockGetZoneFromHostRequest("example.com", "test-zone");
+			mockCollectKnownRoutesRequest([
+				{
+					pattern: "example.com/*",
+					script: "test-worker",
+				},
+			]);
+			await runWrangler("tail example.com/*");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
 			expect(api.requests.deletion.count).toStrictEqual(1);
 		});
 
+		it("should error if a given route is not assigned to the user's zone", async () => {
+			mockGetZoneFromHostRequest("example.com", "test-zone");
+			mockCollectKnownRoutesRequest([]);
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
+		it("should error if a given route is not within the user's zone", async () => {
+			mockGetZoneFromHostRequest("example.com");
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
+
 		it("creates and then delete tails: legacy envs", async () => {
 			const api = mockWebsocketAPIs("some-env", true);
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker --env some-env --legacy-env true");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -70,12 +105,12 @@ describe("tail", () => {
 
 		it("creates and then delete tails: service envs", async () => {
 			const api = mockWebsocketAPIs("some-env");
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker --env some-env --legacy-env false");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -109,65 +144,57 @@ describe("tail", () => {
 			await expect(tooLow).rejects.toThrow();
 
 			await runWrangler("tail test-worker --sampling-rate 0.25");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ sampling_rate: 0.25 },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"sampling_rate":0.25}]}`
+			);
 		});
 
 		it("sends single status filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --status error");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ outcome: ["exception", "exceededCpu", "exceededMemory", "unknown"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"outcome":["exception","exceededCpu","exceededMemory","unknown"]}]}`
+			);
 		});
 
 		it("sends multiple status filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --status error --status canceled");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{
-					outcome: [
-						"exception",
-						"exceededCpu",
-						"exceededMemory",
-						"unknown",
-						"canceled",
-					],
-				},
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"outcome":["exception","exceededCpu","exceededMemory","unknown","canceled"]}]}`
+			);
 		});
 
 		it("sends single HTTP method filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --method POST");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ method: ["POST"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"method":["POST"]}]}`
+			);
 		});
 
 		it("sends multiple HTTP method filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --method POST --method GET");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ method: ["POST", "GET"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"method":["POST","GET"]}]}`
+			);
 		});
 
 		it("sends header filters without a query", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ header: { key: "X-CUSTOM-HEADER" } },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"header":{"key":"X-CUSTOM-HEADER"}}]}`
+			);
 		});
 
 		it("sends header filters with a query", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"header":{"key":"X-CUSTOM-HEADER","query":"some-value"}}]}`
+			);
 		});
 
 		it("sends single IP filters", async () => {
@@ -175,9 +202,9 @@ describe("tail", () => {
 			const fakeIp = "192.0.2.1";
 
 			await runWrangler(`tail test-worker --ip ${fakeIp}`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ client_ip: [fakeIp] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"client_ip":["${fakeIp}"]}]}`
+			);
 		});
 
 		it("sends multiple IP filters", async () => {
@@ -185,9 +212,9 @@ describe("tail", () => {
 			const fakeIp = "192.0.2.1";
 
 			await runWrangler(`tail test-worker --ip ${fakeIp} --ip self`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ client_ip: [fakeIp, "self"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"client_ip":["${fakeIp}","self"]}]}`
+			);
 		});
 
 		it("sends search filters", async () => {
@@ -195,9 +222,9 @@ describe("tail", () => {
 			const search = "filterMe";
 
 			await runWrangler(`tail test-worker --search ${search}`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ query: search },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"query":"${search}"}]}`
+			);
 		});
 
 		it("sends everything but the kitchen sink", async () => {
@@ -218,30 +245,10 @@ describe("tail", () => {
 				`--search ${query} ` +
 				`--debug`;
 
-			const expectedWebsocketMessage = {
-				filters: [
-					{ sampling_rate },
-					{
-						outcome: [
-							"ok",
-							"exception",
-							"exceededCpu",
-							"exceededMemory",
-							"unknown",
-						],
-					},
-					{ method },
-					{ header: { key: "X-HELLO", query: "world" } },
-					{ client_ip },
-					{ query },
-				],
-				debug: true,
-			};
+			const expectedWebsocketMessage = `{"filters":[{"sampling_rate":0.69},{"outcome":["ok","exception","exceededCpu","exceededMemory","unknown"]},{"method":["GET","POST","PUT"]},{"header":{"key":"X-HELLO","query":"world"}},{"client_ip":["192.0.2.1","self"]},{"query":"onlyTheseMessagesPlease"}]}`;
 
 			await runWrangler(`tail test-worker ${cliFilters}`);
-			await expect(api.nextMessageJson()).resolves.toEqual(
-				expectedWebsocketMessage
-			);
+			expect(api.requests.creation[0].body).toEqual(expectedWebsocketMessage);
 		});
 	});
 
@@ -555,7 +562,7 @@ function deserializeToJson(message: WebSocket.RawData): string {
  */
 type MockAPI = {
 	requests: {
-		creation: RequestCounter;
+		creation: RequestInit[];
 		deletion: RequestCounter;
 	};
 	ws: MockWebSocket;
@@ -581,15 +588,15 @@ function mockCreateTailRequest(
 	websocketURL: string,
 	env?: string,
 	legacyEnv = false
-): RequestCounter {
-	const requests = { count: 0 };
+): RequestInit[] {
+	const requests: RequestInit[] = [];
 	const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
 	const environment = env && !legacyEnv ? "/environments/:envName" : "";
 	setMockResponse(
 		`/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails`,
 		"POST",
-		([_url, accountId, scriptName, envName]) => {
-			requests.count++;
+		([_url, accountId, scriptName, envName], req) => {
+			requests.push(req);
 			expect(accountId).toEqual("some-account-id");
 			expect(scriptName).toEqual(
 				legacyEnv && env ? `test-worker-${env}` : "test-worker"
@@ -676,7 +683,7 @@ function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
 	const api: MockAPI = {
 		requests: {
 			deletion: { count: 0 },
-			creation: { count: 0 },
+			creation: [],
 		},
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		ws: null!, // will be set in the `beforeEach()` below.

package/src/__tests__/test-old-node-version.js

@@ -1,4 +1,4 @@
-// this test has to be run with a version of node.js older than 16.7 to pass
+// this test has to be run with a version of node.js older than 16.13 to pass
 
 const { spawn } = require("child_process");
 const path = require("path");
@@ -11,7 +11,7 @@ const wranglerProcess = spawn(
 	{ stdio: "pipe" }
 );
 
-const messageToMatch = "Wrangler requires at least node.js v16.7.0";
+const messageToMatch = "Wrangler requires at least node.js v16.13.0";
 
 wranglerProcess.once("exit", (code) => {
 	try {
@@ -25,7 +25,7 @@ wranglerProcess.once("exit", (code) => {
 	} catch (err) {
 		console.error("Error:", err);
 		throw new Error(
-			"This test has to be run with a version of node.js under 16.7 to pass"
+			"This test has to be run with a version of node.js under 16.13 to pass"
 		);
 	}
 });

package/src/__tests__/worker-namespace.test.ts

@@ -4,7 +4,7 @@ import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
-describe("worker-namespace", () => {
+describe("dispatch-namespace", () => {
 	runInTempDir();
 	const std = mockConsoleMethods();
 	mockAccountId();
@@ -14,8 +14,8 @@ describe("worker-namespace", () => {
 		unsetAllMocks();
 	});
 
-	it("should should display a list of available subcommands, for worker-namespace with no subcommand", async () => {
-		await runWrangler("worker-namespace");
+	it("should should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
+		await runWrangler("dispatch-namespace");
 
 		// wait a tick for the help menu to be printed
 		await new Promise((resolve) => setImmediate(resolve));
@@ -24,16 +24,16 @@ describe("worker-namespace", () => {
 		Object {
 		  "debug": "",
 		  "err": "",
-		  "out": "wrangler worker-namespace
+		  "out": "wrangler dispatch-namespace
 
-		📦 Interact with a worker namespace
+		📦 Interact with a dispatch namespace
 
 		Commands:
-		  wrangler worker-namespace list                          List all Worker namespaces
-		  wrangler worker-namespace get <name>                    Get information about a Worker namespace
-		  wrangler worker-namespace create <name>                 Create a Worker namespace
-		  wrangler worker-namespace delete <name>                 Delete a Worker namespace
-		  wrangler worker-namespace rename <old-name> <new-name>  Rename a Worker namespace
+		  wrangler dispatch-namespace list                          List all dispatch namespaces
+		  wrangler dispatch-namespace get <name>                    Get information about a dispatch namespace
+		  wrangler dispatch-namespace create <name>                 Create a dispatch namespace
+		  wrangler dispatch-namespace delete <name>                 Delete a dispatch namespace
+		  wrangler dispatch-namespace rename <old-name> <new-name>  Rename a dispatch namespace
 
 		Flags:
 		  -c, --config   Path to .toml configuration file  [string]
@@ -73,19 +73,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for create", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -97,11 +97,11 @@ describe("worker-namespace", () => {
 		it("should attempt to create the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockCreateRequest(namespaceName);
-			await runWrangler(`worker-namespace create ${namespaceName}`);
+			await runWrangler(`dispatch-namespace create ${namespaceName}`);
 			expect(requests.count).toEqual(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Created Worker namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
 			);
 		});
 	});
@@ -125,19 +125,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for delete", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -149,11 +149,11 @@ describe("worker-namespace", () => {
 		it("should try to delete the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockDeleteRequest(namespaceName);
-			await runWrangler(`worker-namespace delete ${namespaceName}`);
+			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Deleted Worker namespace \\"my-namespace\\""`
+				`"Deleted dispatch namespace \\"my-namespace\\""`
 			);
 		});
 	});
@@ -183,19 +183,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for get", async () => {
 			await expect(
-				runWrangler("worker-namespace get")
+				runWrangler("dispatch-namespace get")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "
-			        wrangler worker-namespace get <name>
+			        wrangler dispatch-namespace get <name>
 
-			        Get information about a Worker namespace
+			        Get information about a dispatch namespace
 
 			        Positionals:
-			          name  Name of the Worker namespace  [string] [required]
+			          name  Name of the dispatch namespace  [string] [required]
 
 			        Flags:
 			          -c, --config   Path to .toml configuration file  [string]
@@ -207,7 +207,7 @@ describe("worker-namespace", () => {
 		it("should attempt to get info for the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockInfoRequest(namespaceName);
-			await runWrangler(`worker-namespace get ${namespaceName}`);
+			await runWrangler(`dispatch-namespace get ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -248,7 +248,7 @@ describe("worker-namespace", () => {
 
 		it("should list all namespaces", async () => {
 			const requests = mockListRequest();
-			await runWrangler("worker-namespace list");
+			await runWrangler("dispatch-namespace list");
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(`
 			"[
@@ -291,20 +291,20 @@ describe("worker-namespace", () => {
 
 		it("should display help for rename", async () => {
 			await expect(
-				runWrangler("worker-namespace rename")
+				runWrangler("dispatch-namespace rename")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 2"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace rename <old-name> <new-name>
+			wrangler dispatch-namespace rename <old-name> <new-name>
 
-			Rename a Worker namespace
+			Rename a dispatch namespace
 
 			Positionals:
-			  old-name  Name of the Worker namespace  [string] [required]
-			  new-name  New name of the Worker namespace  [string] [required]
+			  old-name  Name of the dispatch namespace  [string] [required]
+			  new-name  New name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -317,10 +317,12 @@ describe("worker-namespace", () => {
 			const namespaceName = "my-namespace";
 			const newName = "new-namespace";
 			const requests = mockRenameRequest(namespaceName);
-			await runWrangler(`worker-namespace rename ${namespaceName} ${newName}`);
+			await runWrangler(
+				`dispatch-namespace rename ${namespaceName} ${newName}`
+			);
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(
-				`"Renamed Worker namespace \\"my-namespace\\" to \\"new-namespace\\""`
+				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
 			);
 		});
 	});

package/src/api/dev.ts

@@ -1,10 +1,12 @@
-import { startDev } from "../dev";
+import { fetch } from "undici";
+import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { RequestInit, Response } from "undici";
 
 interface DevOptions {
+	config?: string;
 	env?: string;
 	ip?: string;
 	port?: number;
@@ -20,7 +22,7 @@ interface DevOptions {
 	experimentalEnableLocalPersistence?: boolean;
 	liveReload?: boolean;
 	watch?: boolean;
-	vars: {
+	vars?: {
 		[key: string]: unknown;
 	};
 	kv?: {
@@ -48,46 +50,109 @@ interface DevOptions {
 	_?: (string | number)[]; //yargs wants this
 	$0?: string; //yargs wants this
 }
+
+interface DevApiOptions {
+	testMode?: boolean;
+	disableExperimentalWarning?: boolean;
+}
+
+interface UnstableDev {
+	stop: () => Promise<void>;
+	fetch: (init?: RequestInit) => Promise<Response | undefined>;
+	waitUntilExit: () => Promise<void>;
+}
 /**
  *  unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
  *  @param {string} script
  *  @param {DevOptions} options
+ *  @param {DevApiOptions} apiOptions
+ * @returns {Promise<UnstableDev>}
  */
 export async function unstable_dev(
 	script: string,
-	options: DevOptions,
-	disableExperimentalWarning?: boolean
+	options?: DevOptions,
+	apiOptions?: DevApiOptions
 ) {
+	const { testMode = true, disableExperimentalWarning = false } =
+		apiOptions || {};
 	if (!disableExperimentalWarning) {
 		logger.warn(
 			`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
 		);
 	}
-
-	return new Promise<{
-		stop: () => void;
-		fetch: (init?: RequestInit) => Promise<Response | undefined>;
-		waitUntilExit: () => Promise<void>;
-	}>((resolve) => {
-		//lmao
-		return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
-			const devServer = startDev({
-				script: script,
-				inspect: false,
-				logLevel: "none",
-				showInteractiveDevSession: false,
-				_: [],
-				$0: "",
-				...options,
-				local: true,
-				onReady: () => ready(devServer),
+	let readyPort: number;
+	let readyAddress: string;
+	//due to Pages adoption of unstable_dev, we can't *just* disable rebuilds and watching. instead, we'll have two versions of startDev, which will converge.
+	if (testMode) {
+		//in testMode, we can run multiple wranglers in parallel, but rebuilds might not work out of the box
+		return new Promise<UnstableDev>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startApiDev>>>((ready) => {
+				// once the devServer is ready for requests, we resolve the inner promise
+				// (where we've named the resolve function "ready")
+				const devServer = startApiDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					port: options?.port ?? 0,
+					...options,
+					local: true,
+					onReady: (address, port) => {
+						readyPort = port;
+						readyAddress = address;
+						ready(devServer);
+					},
+				});
+			}).then((devServer) => {
+				// now that the inner promise has resolved, we can resolve the outer promise
+				// with an object that lets you fetch and stop the dev server
+				resolve({
+					stop: devServer.stop,
+					fetch: async (init?: RequestInit) => {
+						const urlToFetch = `http://${readyAddress}:${readyPort}/`;
+						return await fetch(urlToFetch, init);
+					},
+					//no-op, does nothing in tests
+					waitUntilExit: async () => {
+						return;
+					},
+				});
 			});
-		}).then((devServer) => {
-			resolve({
-				stop: devServer.stop,
-				fetch: devServer.fetch,
-				waitUntilExit: devServer.devReactElement.waitUntilExit,
+		});
+	} else {
+		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
+
+		return new Promise<UnstableDev>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
+				const devServer = startDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: (address, port) => {
+						readyPort = port;
+						readyAddress = address;
+						ready(devServer);
+					},
+				});
+			}).then((devServer) => {
+				resolve({
+					stop: devServer.stop,
+					fetch: async (init?: RequestInit) => {
+						const urlToFetch = `http://${readyAddress}:${readyPort}/`;
+						return await fetch(urlToFetch, init);
+					},
+					waitUntilExit: devServer.devReactElement.waitUntilExit,
+				});
 			});
 		});
-	});
+	}
 }