diff --git a/.changeset/serious-toys-repeat.md b/.changeset/serious-toys-repeat.md
deleted file mode 100644
index bcb2b71609a8..000000000000
--- a/.changeset/serious-toys-repeat.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-"wrangler": minor
----
-
-Reintroduces some internal refactorings of wrangler dev servers (including `wrangler dev`, `wrangler dev --remote`, and `unstable_dev()`).
-
-These changes were released in 3.13.0 and reverted in 3.13.1 -- we believe the changes are now more stable and ready for release again.
-
-There are no changes required for developers to opt-in. Improvements include:
-
-- fewer 'address in use' errors upon reloads
-- upon config/source file changes, requests are buffered to guarantee the response is from the new version of the Worker
diff --git a/fixtures/dev-env/.gitignore b/fixtures/dev-env/.gitignore
deleted file mode 100644
index 1521c8b7652b..000000000000
--- a/fixtures/dev-env/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-dist
diff --git a/fixtures/dev-env/package.json b/fixtures/dev-env/package.json
deleted file mode 100644
index 11103f0de5a0..000000000000
--- a/fixtures/dev-env/package.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "dev-env",
-	"version": "1.0.1",
-	"private": true,
-	"description": "",
-	"license": "ISC",
-	"author": "",
-	"main": "src/index.js",
-	"scripts": {
-		"test": "npx vitest run",
-		"test:ci": "npx vitest run",
-		"test:watch": "npx vitest",
-		"type:tests": "tsc -p ./tests/tsconfig.json"
-	},
-	"devDependencies": {
-		"@types/ws": "^8.5.7",
-		"@cloudflare/workers-tsconfig": "workspace:^",
-		"get-port": "^7.0.0",
-		"miniflare": "3.20231025.1",
-		"undici": "^5.23.0",
-		"wrangler": "workspace:*",
-		"ws": "^8.14.2"
-	},
-	"dependencies": {}
-}
diff --git a/fixtures/dev-env/tests/index.test.ts b/fixtures/dev-env/tests/index.test.ts
deleted file mode 100644
index a30da78cbade..000000000000
--- a/fixtures/dev-env/tests/index.test.ts
+++ /dev/null
@@ -1,556 +0,0 @@
-import assert from "node:assert";
-import getPort from "get-port";
-import {
-	Miniflare,
-	type Response as MiniflareResponse,
-	type MiniflareOptions,
-	Log,
-} from "miniflare";
-import * as undici from "undici";
-import { WebSocket } from "ws";
-import { beforeEach, afterEach, describe, test, expect, vi } from "vitest";
-import { unstable_DevEnv as DevEnv } from "wrangler";
-import type { ProxyData } from "wrangler/src/api";
-import type { StartDevWorkerOptions } from "wrangler/src/api/startDevWorker/types";
-import type { EsbuildBundle } from "wrangler/src/dev/use-esbuild";
-
-const fakeBundle = {} as EsbuildBundle;
-
-let devEnv: DevEnv;
-let mf: Miniflare | undefined;
-let res: MiniflareResponse | undici.Response;
-let ws: WebSocket | undefined;
-let fireAndForgetPromises: Promise<any>[] = [];
-
-type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-
-beforeEach(() => {
-	devEnv = new DevEnv();
-	mf = undefined;
-	res = undefined as any;
-	ws = undefined;
-});
-afterEach(async () => {
-	await Promise.allSettled(fireAndForgetPromises);
-	await devEnv?.teardown();
-	await mf?.dispose();
-	await ws?.close();
-
-	vi.resetAllMocks();
-});
-
-async function fakeStartUserWorker(options: {
-	script: string;
-	name?: string;
-	mfOpts?: Partial<MiniflareOptions>;
-	config?: OptionalKeys<StartDevWorkerOptions, "name" | "script">;
-}) {
-	const config: StartDevWorkerOptions = {
-		...options.config,
-		name: options.name ?? "test-worker",
-		script: { contents: options.script },
-	};
-	const mfOpts: MiniflareOptions = Object.assign(
-		{
-			port: undefined,
-			inspectorPort: 0,
-			modules: true,
-			compatibilityDate: "2023-08-01",
-			name: config.name,
-			script: options.script,
-			log: Object.assign(new Log(), { error() {} }), // TODO: remove when this bug is fixed https://jira.cfdata.org/browse/DEVX-983
-		},
-		options.mfOpts
-	);
-
-	assert("script" in mfOpts);
-
-	fakeConfigUpdate(config);
-	fakeReloadStart(config);
-
-	const worker = devEnv.startWorker(config);
-	const { proxyWorker } = await devEnv.proxy.ready.promise;
-	const proxyWorkerUrl = await proxyWorker.ready;
-	const inspectorProxyWorkerUrl = await proxyWorker.unsafeGetDirectURL(
-		"InspectorProxyWorker"
-	);
-
-	mf = new Miniflare(mfOpts);
-
-	const userWorkerUrl = await mf.ready;
-	const userWorkerInspectorUrl = await mf.getInspectorURL();
-	fakeReloadComplete(config, mfOpts, userWorkerUrl, userWorkerInspectorUrl);
-
-	return {
-		worker,
-		mf,
-		mfOpts,
-		config,
-		userWorkerUrl,
-		userWorkerInspectorUrl,
-		proxyWorkerUrl,
-		inspectorProxyWorkerUrl,
-	};
-}
-
-async function fakeUserWorkerChanges({
-	script,
-	mfOpts,
-	config,
-}: {
-	script?: string;
-	mfOpts: MiniflareOptions;
-	config: StartDevWorkerOptions;
-}) {
-	assert(mf);
-	assert("script" in mfOpts);
-
-	config = {
-		...config,
-		script: {
-			...config.script,
-			...(script ? { contents: script } : undefined),
-		},
-	};
-	mfOpts = {
-		...mfOpts,
-		script: script ?? mfOpts.script,
-	};
-
-	fakeReloadStart(config);
-
-	await mf.setOptions(mfOpts);
-
-	const userWorkerUrl = await mf.ready;
-	const userWorkerInspectorUrl = await mf.getInspectorURL();
-	fakeReloadComplete(
-		config,
-		mfOpts,
-		userWorkerUrl,
-		userWorkerInspectorUrl,
-		1000
-	);
-
-	return { mfOpts, config, mf, userWorkerUrl, userWorkerInspectorUrl };
-}
-
-function fireAndForgetFakeUserWorkerChanges(
-	...args: Parameters<typeof fakeUserWorkerChanges>
-) {
-	// fire and forget the reload -- this let's us test request buffering
-	const promise = fakeUserWorkerChanges(...args);
-	fireAndForgetPromises.push(promise);
-}
-
-function fakeConfigUpdate(config: StartDevWorkerOptions) {
-	devEnv.proxy.onConfigUpdate({
-		type: "configUpdate",
-		config,
-	});
-
-	return config; // convenience to allow calling and defining new config inline but also store the new object
-}
-function fakeReloadStart(config: StartDevWorkerOptions) {
-	devEnv.proxy.onReloadStart({
-		type: "reloadStart",
-		config,
-		bundle: fakeBundle,
-	});
-
-	return config;
-}
-function fakeReloadComplete(
-	config: StartDevWorkerOptions,
-	mfOpts: MiniflareOptions,
-	userWorkerUrl: URL,
-	userWorkerInspectorUrl: URL,
-	delay = 100
-) {
-	const proxyData: ProxyData = {
-		userWorkerUrl: {
-			protocol: userWorkerUrl.protocol,
-			hostname: userWorkerUrl.hostname,
-			port: userWorkerUrl.port,
-		},
-		userWorkerInspectorUrl: {
-			protocol: userWorkerInspectorUrl.protocol,
-			hostname: userWorkerInspectorUrl.hostname,
-			port: userWorkerInspectorUrl.port,
-			pathname: `/core:user:${config.name}`,
-		},
-		userWorkerInnerUrlOverrides: {
-			protocol: config?.dev?.urlOverrides?.secure ? "https:" : "http:",
-			hostname: config?.dev?.urlOverrides?.hostname,
-		},
-		headers: {},
-		liveReload: config.dev?.liveReload,
-	};
-
-	setTimeout(() => {
-		devEnv.proxy.onReloadComplete({
-			type: "reloadComplete",
-			config,
-			bundle: fakeBundle,
-			proxyData,
-		});
-	}, delay);
-
-	return { config, mfOpts }; // convenience to allow calling and defining new config/mfOpts inline but also store the new objects
-}
-
-describe("startDevWorker: ProxyController", () => {
-	test("ProxyWorker buffers requests while runtime reloads", async () => {
-		const run = await fakeStartUserWorker({
-			script: `
-				export default {
-					fetch() {
-						return new Response("body:1");
-					}
-				}
-			`,
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:1");
-
-		fireAndForgetFakeUserWorkerChanges({
-			mfOpts: run.mfOpts,
-			config: run.config,
-			script: run.mfOpts.script.replace("1", "2"),
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:2");
-	});
-
-	test("InspectorProxyWorker discovery endpoints + devtools websocket connection", async () => {
-		const run = await fakeStartUserWorker({
-			script: `
-				export default {
-					fetch() {
-						console.log('Inside mock user worker');
-
-						return new Response("body:1");
-					}
-				}
-			`,
-		});
-
-		await devEnv.proxy.ready;
-		res = await undici.fetch(`http://${run.inspectorProxyWorkerUrl.host}/json`);
-
-		await expect(res.json()).resolves.toBeInstanceOf(Array);
-
-		ws = new WebSocket(
-			`ws://${run.inspectorProxyWorkerUrl.host}/core:user:${run.config.name}`
-		);
-		const openPromise = new Promise((resolve) => {
-			ws?.addEventListener("open", resolve);
-		});
-		const consoleAPICalledPromise = new Promise((resolve) => {
-			ws?.addEventListener("message", (event) => {
-				assert(typeof event.data === "string");
-				if (event.data.includes("Runtime.consoleAPICalled")) {
-					resolve(JSON.parse(event.data));
-				}
-			});
-		});
-		const executionContextCreatedPromise = new Promise((resolve) => {
-			ws?.addEventListener("message", (event) => {
-				assert(typeof event.data === "string");
-				if (event.data.includes("Runtime.executionContextCreated")) {
-					resolve(JSON.parse(event.data));
-				}
-			});
-		});
-
-		await openPromise;
-		await run.worker.fetch("http://localhost");
-
-		await expect(consoleAPICalledPromise).resolves.toMatchObject({
-			method: "Runtime.consoleAPICalled",
-			params: {
-				args: expect.arrayContaining([
-					{ type: "string", value: "Inside mock user worker" },
-				]),
-			},
-		});
-		await expect(executionContextCreatedPromise).resolves.toMatchObject({
-			method: "Runtime.executionContextCreated",
-			params: {
-				context: { id: expect.any(Number) },
-			},
-		});
-	});
-
-	test("User worker exception", async () => {
-		const consoleErrorSpy = vi.spyOn(console, "error");
-
-		const run = await fakeStartUserWorker({
-			script: `
-					export default {
-						fetch() {
-							throw new Error('Boom!');
-
-							return new Response("body:1");
-						}
-					}
-				`,
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("Error: Boom!");
-
-		await new Promise((r) => setTimeout(r, 100)); // allow some time for the error to be logged (TODO: replace with retry/waitUntil helper)
-		expect(consoleErrorSpy).toBeCalledWith(
-			expect.stringContaining("Error: Boom!")
-		);
-
-		// test changes causing a new error cause the new error to propogate
-		fireAndForgetFakeUserWorkerChanges({
-			script: `
-					export default {
-						fetch() {
-							throw new Error('Boom 2!');
-
-							return new Response("body:2");
-						}
-					}
-				`,
-			mfOpts: run.mfOpts,
-			config: run.config,
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("Error: Boom 2!");
-
-		await new Promise((r) => setTimeout(r, 100)); // allow some time for the error to be logged (TODO: replace with retry/waitUntil helper)
-		expect(consoleErrorSpy).toBeCalledWith(
-			expect.stringContaining("Error: Boom 2!")
-		);
-
-		// test eyeball requests receive the pretty error page
-		fireAndForgetFakeUserWorkerChanges({
-			script: `
-					export default {
-						fetch() {
-							const e = new Error('Boom 3!');
-
-							// this is how errors are serialised after they are caught by wrangler/miniflare3 middlewares
-							const error = { name: e.name, message: e.message, stack: e.stack };
-							return Response.json(error, {
-								status: 500,
-								headers: { "MF-Experimental-Error-Stack": "true" },
-							});
-						}
-					}
-				`,
-			mfOpts: run.mfOpts,
-			config: run.config,
-		});
-
-		const proxyWorkerUrl = await devEnv.proxy.proxyWorker?.ready;
-		assert(proxyWorkerUrl);
-		res = await undici.fetch(proxyWorkerUrl, {
-			headers: { Accept: "text/html" },
-		});
-		await expect(res.text()).resolves.toEqual(
-			expect.stringContaining(`<h2 class="error-message"> Boom 3! </h2>`) // pretty error page html snippet
-		);
-
-		// test further changes that fix the code
-		fireAndForgetFakeUserWorkerChanges({
-			script: `
-					export default {
-						fetch() {
-							return new Response("body:3");
-						}
-					}
-				`,
-			mfOpts: run.mfOpts,
-			config: run.config,
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:3");
-
-		consoleErrorSpy.mockReset();
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:3");
-
-		await new Promise((r) => setTimeout(r, 100)); // allow some time for the error to be logged (TODO: replace with retry/waitUntil helper)
-		expect(consoleErrorSpy).not.toHaveBeenCalled();
-	});
-
-	test("config.dev.{server,inspector} changes, restart the server instance", async () => {
-		const run = await fakeStartUserWorker({
-			script: `
-				export default {
-					fetch() {
-						return new Response("body:1");
-					}
-				}
-			`,
-			config: {
-				dev: {
-					server: { port: await getPort() },
-					inspector: { port: await getPort() },
-				},
-			},
-		});
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:1");
-
-		const oldPort = run.config.dev?.server?.port;
-		res = await undici.fetch(`http://127.0.0.1:${oldPort}`);
-		await expect(res.text()).resolves.toBe("body:1");
-
-		const config2 = fakeConfigUpdate({
-			...run.config,
-			dev: {
-				server: { port: await getPort() },
-				inspector: { port: await getPort() },
-			},
-		});
-		fakeReloadStart(config2);
-		fakeReloadComplete(
-			config2,
-			run.mfOpts,
-			run.userWorkerUrl,
-			run.userWorkerInspectorUrl
-		);
-
-		const newPort = config2.dev?.server?.port;
-
-		res = await run.worker.fetch("http://dummy");
-		await expect(res.text()).resolves.toBe("body:1");
-
-		res = await undici.fetch(`http://127.0.0.1:${newPort}`);
-		await expect(res.text()).resolves.toBe("body:1");
-
-		await expect(
-			undici.fetch(`http://127.0.0.1:${oldPort}`).then((r) => r.text())
-		).rejects.toMatchInlineSnapshot("[TypeError: fetch failed]");
-	});
-
-	test("liveReload", async () => {
-		let resText: string;
-		const scriptRegex = /<script>([\s\S]*)<\/script>/gm;
-
-		const run = await fakeStartUserWorker({
-			script: `
-				export default {
-					fetch() {
-						return new Response("body:1", {
-							headers: { 'Content-Type': 'text/html' }
-						});
-					}
-				}
-			`,
-			config: {
-				dev: { liveReload: true },
-			},
-		});
-
-		// test liveReload: true inserts live-reload <script> tag when the response Content-Type is html
-		res = await run.worker.fetch("http://dummy");
-		resText = await res.text();
-		expect(resText).toEqual(expect.stringContaining("body:1"));
-		expect(resText).toEqual(expect.stringMatching(scriptRegex));
-		expect(resText.replace(scriptRegex, "").trim()).toEqual("body:1"); // test, without the <script> tag, the response is as authored
-
-		fireAndForgetFakeUserWorkerChanges({
-			mfOpts: run.mfOpts,
-			script: `
-				export default {
-					fetch() {
-						return new Response("body:2");
-					}
-				}
-			`,
-			config: {
-				...run.config,
-				dev: { liveReload: true },
-			},
-		});
-
-		// test liveReload does nothing when the response Content-Type is not html
-		res = await run.worker.fetch("http://dummy");
-		resText = await res.text();
-		expect(resText).toMatchInlineSnapshot('"body:2"');
-		expect(resText).toBe("body:2");
-		expect(resText).not.toEqual(expect.stringMatching(scriptRegex));
-
-		fireAndForgetFakeUserWorkerChanges({
-			mfOpts: run.mfOpts,
-			script: `
-				export default {
-					fetch() {
-						return new Response("body:3", {
-							headers: { 'Content-Type': 'text/html' }
-						});
-					}
-				}
-			`,
-			config: {
-				...run.config,
-				dev: { liveReload: false },
-			},
-		});
-
-		// test liveReload: false does nothing even when the response Content-Type is html
-		res = await run.worker.fetch("http://dummy");
-		resText = await res.text();
-		expect(resText).toMatchInlineSnapshot('"body:3"');
-		expect(resText).toBe("body:3");
-		expect(resText).not.toEqual(expect.stringMatching(scriptRegex));
-	});
-
-	test("urlOverrides take effect in the UserWorker", async () => {
-		const run = await fakeStartUserWorker({
-			script: `
-				export default {
-					fetch(request) {
-						return new Response("URL: " + request.url);
-					}
-				}
-			`,
-			config: {
-				dev: {
-					urlOverrides: {
-						hostname: "www.google.com",
-					},
-				},
-			},
-		});
-
-		res = await run.worker.fetch("http://dummy/test/path/1");
-		await expect(res.text()).resolves.toBe(
-			`URL: http://www.google.com/test/path/1`
-		);
-
-		const config2 = fakeConfigUpdate({
-			...run.config,
-			dev: {
-				...run.config.dev,
-				urlOverrides: {
-					secure: true,
-					hostname: "mybank.co.uk",
-				},
-			},
-		});
-		fakeReloadComplete(
-			config2,
-			run.mfOpts,
-			run.userWorkerUrl,
-			run.userWorkerInspectorUrl,
-			1000
-		);
-
-		res = await run.worker.fetch("http://dummy/test/path/2");
-		await expect(res.text()).resolves.toBe(
-			"URL: https://mybank.co.uk/test/path/2"
-		);
-	});
-});
diff --git a/fixtures/dev-env/tests/tsconfig.json b/fixtures/dev-env/tests/tsconfig.json
deleted file mode 100644
index c35cdd8fea52..000000000000
--- a/fixtures/dev-env/tests/tsconfig.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-	"extends": "@cloudflare/workers-tsconfig/tsconfig.json",
-	"compilerOptions": {
-		"types": ["node"],
-		"jsx": "react"
-	},
-	"include": [
-		"**/*.ts",
-		"../../../node-types.d.ts",
-		"../../../packages/wrangler/src/*.d.ts"
-	]
-}
diff --git a/packages/edge-preview-authenticated-proxy/tests/index.test.ts b/packages/edge-preview-authenticated-proxy/tests/index.test.ts
index 8148ae470854..a2894af5b173 100644
--- a/packages/edge-preview-authenticated-proxy/tests/index.test.ts
+++ b/packages/edge-preview-authenticated-proxy/tests/index.test.ts
@@ -74,6 +74,7 @@ compatibility_date = "2023-01-01"
 		remote = await unstable_dev(path.join(tmpDir, "remote.js"), {
 			config: path.join(tmpDir, "wrangler.toml"),
 			experimental: { disableExperimentalWarning: true },
+			port: 6756,
 		});
 	});
 
@@ -91,7 +92,7 @@ compatibility_date = "2023-01-01"
 	it("should obtain token from exchange_url", async () => {
 		const resp = await worker.fetch(
 			`https://preview.devprod.cloudflare.dev/exchange?exchange_url=${encodeURIComponent(
-				`http://127.0.0.1:${remote.port}/exchange`
+				"http://127.0.0.1:6756/exchange"
 			)}`,
 			{
 				method: "POST",
@@ -116,9 +117,9 @@ compatibility_date = "2023-01-01"
 			`https://random-data.preview.devprod.cloudflare.dev/.update-preview-token?token=${encodeURIComponent(
 				token
 			)}&prewarm=${encodeURIComponent(
-				`http://127.0.0.1:${remote.port}/prewarm`
+				"http://127.0.0.1:6756/prewarm"
 			)}&remote=${encodeURIComponent(
-				`http://127.0.0.1:${remote.port}`
+				"http://127.0.0.1:6756"
 			)}&suffix=${encodeURIComponent("/hello?world")}`,
 			{
 				method: "GET",
@@ -150,17 +151,17 @@ compatibility_date = "2023-01-01"
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignoring this test type error for sake of turborepo PR
 		const json = (await resp.json()) as any;
 
-		expect(json).toMatchObject({
-			url: `http://127.0.0.1:${remote.port}/`,
-			headers: expect.arrayContaining([["cf-workers-preview-token", token]]),
-		});
+		expect(
+			json.headers.find(([h]: [string]) => h === "cf-workers-preview-token")[1]
+		).toBe(token);
+		expect(json.url).toMatchInlineSnapshot('"http://127.0.0.1:6756/"');
 	});
 	it("should be redirected with cookie", async () => {
 		const resp = await worker.fetch(
 			`https://random-data.preview.devprod.cloudflare.dev/.update-preview-token?token=TEST_TOKEN&prewarm=${encodeURIComponent(
-				`http://127.0.0.1:${remote.port}/prewarm`
+				"http://127.0.0.1:6756/prewarm"
 			)}&remote=${encodeURIComponent(
-				`http://127.0.0.1:${remote.port}`
+				"http://127.0.0.1:6756"
 			)}&suffix=${encodeURIComponent("/hello?world")}`,
 			{
 				method: "GET",
@@ -192,12 +193,10 @@ compatibility_date = "2023-01-01"
 		);
 
 		const json = (await resp.json()) as { headers: string[][]; url: string };
-		expect(json).toMatchObject({
-			url: `http://127.0.0.1:${remote.port}/`,
-			headers: expect.arrayContaining([
-				["cf-workers-preview-token", "TEST_TOKEN"],
-			]),
+		expect(Object.fromEntries([...json.headers])).toMatchObject({
+			"cf-workers-preview-token": "TEST_TOKEN",
 		});
+		expect(json.url).toMatchInlineSnapshot('"http://127.0.0.1:6756/"');
 	});
 	it("should not follow redirects", async () => {
 		const resp = await worker.fetch(
diff --git a/packages/wrangler/.eslintrc.js b/packages/wrangler/.eslintrc.js
index 8738c6659f9d..c7d6b30416ec 100644
--- a/packages/wrangler/.eslintrc.js
+++ b/packages/wrangler/.eslintrc.js
@@ -10,7 +10,6 @@ module.exports = {
 	],
 	overrides: [
 		{
-			// TODO: add linting for `startDevWorker` workers in `templates/startDevWorker`
 			files: "src/**/*.ts",
 			excludedFiles: "*.test.ts",
 			parserOptions: {
diff --git a/packages/wrangler/e2e/tsconfig.json b/packages/wrangler/e2e/tsconfig.json
index fbb2e7c543ff..b54836daa450 100644
--- a/packages/wrangler/e2e/tsconfig.json
+++ b/packages/wrangler/e2e/tsconfig.json
@@ -3,6 +3,6 @@
 	"compilerOptions": {
 		"types": ["node"]
 	},
-	"include": ["**/*.ts", "../src/*.d.ts"],
+	"include": ["**/*.ts"],
 	"exclude": []
 }
diff --git a/packages/wrangler/package.json b/packages/wrangler/package.json
index 22fdd8ee25f6..558e8413bfcd 100644
--- a/packages/wrangler/package.json
+++ b/packages/wrangler/package.json
@@ -64,7 +64,7 @@
 		"test:ci": "pnpm run test --coverage",
 		"test:debug": "pnpm run test --silent=false --verbose=true",
 		"test:e2e": "vitest --test-timeout 240000 --single-thread --dir ./e2e --retry 2 run",
-		"test:watch": "pnpm run test --testTimeout=50000 --watch",
+		"test:watch": "pnpm run test --runInBand --testTimeout=50000 --watch",
 		"type:tests": "tsc -p ./src/__tests__/tsconfig.json && tsc -p ./e2e/tsconfig.json"
 	},
 	"jest": {
diff --git a/packages/wrangler/scripts/bundle.ts b/packages/wrangler/scripts/bundle.ts
index 11741c747079..62ebc01c98d9 100644
--- a/packages/wrangler/scripts/bundle.ts
+++ b/packages/wrangler/scripts/bundle.ts
@@ -1,17 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import * as esbuild from "esbuild";
+import { build, context } from "esbuild";
 import { EXTERNAL_DEPENDENCIES } from "./deps";
-import type { BuildOptions, Plugin, BuildContext } from "esbuild";
+import type { BuildOptions } from "esbuild";
 
 // the expectation is that this is being run from the project root
 type BuildFlags = {
 	watch?: boolean;
 };
 
-const WATCH = process.argv.includes("--watch");
-const TEMPLATES_DIR = path.join(__dirname, "../templates");
-
 async function buildMain(flags: BuildFlags = {}) {
 	const outdir = path.resolve("./wrangler-dist");
 	const wranglerPackageDir = path.resolve(".");
@@ -55,14 +52,13 @@ async function buildMain(flags: BuildFlags = {}) {
 				? { ALGOLIA_PUBLIC_KEY: `"${process.env.ALGOLIA_PUBLIC_KEY}"` }
 				: {}),
 		},
-		plugins: [embedWorkersPlugin],
 	};
 
 	if (flags.watch) {
-		const ctx = await esbuild.context(options);
+		const ctx = await context(options);
 		await ctx.watch();
 	} else {
-		await esbuild.build(options);
+		await build(options);
 	}
 
 	// Copy `yoga-layout` `.wasm` file
@@ -78,63 +74,14 @@ async function buildMain(flags: BuildFlags = {}) {
 	await fs.copyFile(wasmSrc, wasmDst);
 }
 
-const workersContexts = new Map<string, BuildContext>();
-const embedWorkersPlugin: Plugin = {
-	name: "embed-workers",
-	setup(build) {
-		const namespace = "embed-worker";
-		build.onResolve({ filter: /^worker:/ }, async (args) => {
-			const name = args.path.substring("worker:".length);
-			// Use `build.resolve()` API so Workers can be written as `m?[jt]s` files
-			const result = await build.resolve("./" + name, {
-				kind: "import-statement",
-				resolveDir: TEMPLATES_DIR,
-			});
-			if (result.errors.length > 0) return { errors: result.errors };
-			return { path: result.path, namespace };
-		});
-		build.onLoad({ filter: /.*/, namespace }, async (args) => {
-			const ctx =
-				workersContexts.get(args.path) ??
-				(await esbuild.context({
-					platform: "node", // Marks `node:*` imports as external
-					format: "esm",
-					target: "esnext",
-					bundle: true,
-					sourcemap: true,
-					sourcesContent: false,
-					metafile: true,
-					entryPoints: [args.path],
-					outdir: build.initialOptions.outdir,
-				}));
-			const result = await ctx.rebuild();
-			workersContexts.set(args.path, ctx);
-			const watchFiles = Object.keys(result?.metafile?.inputs ?? {});
-			const scriptPath = Object.keys(result?.metafile?.outputs ?? {}).find(
-				(filepath) => filepath.endsWith(".js")
-			);
-
-			const contents = `
-				import path from "node:path";
-				const scriptPath = path.resolve(__dirname, "..", "${scriptPath}");
-				export default scriptPath;
-            `;
-
-			return { contents, loader: "js", watchFiles };
-		});
-	},
-};
-
 async function run() {
 	// main cli
 	await buildMain();
 
 	// After built once completely, rerun them both in watch mode
-	if (WATCH) {
+	if (process.argv.includes("--watch")) {
 		console.log("Built. Watching for changes...");
 		await buildMain({ watch: true });
-	} else {
-		for (const ctx of workersContexts.values()) await ctx.dispose();
 	}
 }
 
diff --git a/packages/wrangler/src/__tests__/api-devregistry.test.ts b/packages/wrangler/src/__tests__/api-devregistry.test.ts
index 955d1022d781..746d2f8a3795 100644
--- a/packages/wrangler/src/__tests__/api-devregistry.test.ts
+++ b/packages/wrangler/src/__tests__/api-devregistry.test.ts
@@ -13,8 +13,6 @@ describe("multi-worker testing", () => {
 	let childWorker: any;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	let parentWorker: any;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	const workers: any[] = [];
 
 	beforeAll(async () => {
 		childWorker = await unstable_dev(
@@ -26,8 +24,6 @@ describe("multi-worker testing", () => {
 				},
 			}
 		);
-		workers.push(childWorker);
-
 		parentWorker = await unstable_dev(
 			"src/__tests__/helpers/worker-scripts/parent-worker.js",
 			{
@@ -37,13 +33,11 @@ describe("multi-worker testing", () => {
 				},
 			}
 		);
-		workers.push(parentWorker);
 	});
 
 	afterAll(async () => {
-		for (const worker of workers) {
-			await worker.stop();
-		}
+		await childWorker.stop();
+		await parentWorker.stop();
 	});
 
 	it("parentWorker and childWorker should be added devRegistry", async () => {
@@ -87,15 +81,13 @@ describe("multi-worker testing", () => {
 		(["debug", "info", "log", "warn", "error"] as const).forEach((method) =>
 			jest.spyOn(console, method).mockImplementation((...args: unknown[]) => {
 				logs += `\n${args}`;
-				process.stdout.write(`\n${args}`);
 				// Regexp ignores colour codes
-				if (/\[wrangler.*:inf].+GET.+\/.+200.+OK/.test(String(args)))
-					requestResolve();
+				if (/\[mf:inf].+GET.+\/.+200.+OK/.test(String(args))) requestResolve();
 			})
 		);
 
 		async function startWorker() {
-			const worker = await unstable_dev(
+			return await unstable_dev(
 				"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 				{
 					// We need the wrangler.toml config to specify a Worker name
@@ -108,27 +100,29 @@ describe("multi-worker testing", () => {
 					},
 				}
 			);
-
-			workers.push(worker);
-
-			return worker;
 		}
 
-		let worker = await startWorker();
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let worker: any;
+		try {
+			worker = await startWorker();
 
-		// Stop the worker and start it again
-		await worker.stop();
-		await new Promise((r) => setTimeout(r, 2000));
+			// Stop the worker and start it again
+			await worker.stop();
+			await new Promise((r) => setTimeout(r, 2000));
 
-		worker = await startWorker();
+			worker = await startWorker();
 
-		const resp = await worker.fetch();
-		expect(resp).not.toBe(undefined);
+			const resp = await worker.fetch();
+			expect(resp).not.toBe(undefined);
 
-		await requestPromise;
+			expect(logs).not.toMatch(
+				/Failed to register worker in local service registry/
+			);
 
-		expect(logs).not.toMatch(
-			/Failed to register worker in local service registry/
-		);
+			await requestPromise;
+		} finally {
+			await worker?.stop();
+		}
 	}, 10000);
 });
diff --git a/packages/wrangler/src/__tests__/dev.test.tsx b/packages/wrangler/src/__tests__/dev.test.tsx
index 45e4e0dc3740..d38b9f20777f 100644
--- a/packages/wrangler/src/__tests__/dev.test.tsx
+++ b/packages/wrangler/src/__tests__/dev.test.tsx
@@ -878,7 +878,6 @@ describe("wrangler dev", () => {
 
 	describe("inspector port", () => {
 		it("should use 9229 as the default port", async () => {
-			(getPort as jest.Mock).mockImplementation((options) => options.port);
 			writeWranglerToml({
 				main: "index.js",
 			});
@@ -897,7 +896,6 @@ describe("wrangler dev", () => {
 		});
 
 		it("should read --inspector-port", async () => {
-			(getPort as jest.Mock).mockImplementation((options) => options.port);
 			writeWranglerToml({
 				main: "index.js",
 			});
diff --git a/packages/wrangler/src/__tests__/jest.setup.ts b/packages/wrangler/src/__tests__/jest.setup.ts
index f6168d6200e1..e3d63a2cd372 100644
--- a/packages/wrangler/src/__tests__/jest.setup.ts
+++ b/packages/wrangler/src/__tests__/jest.setup.ts
@@ -24,10 +24,9 @@ process.env.LC_ALL = "en";
 
 // Mock out getPort since we don't actually care about what ports are open in unit tests.
 jest.mock("get-port", () => {
-	const { default: getPort } = jest.requireActual("get-port");
 	return {
 		__esModule: true,
-		default: jest.fn(getPort),
+		default: jest.fn().mockImplementation(async (options) => options.port),
 	};
 });
 
@@ -102,12 +101,6 @@ fetchMock.dontMock();
 beforeAll(() => {
 	msw.listen({
 		onUnhandledRequest: (request) => {
-			const { hostname } = request.url;
-			const localHostnames = ["localhost", "127.0.0.1"]; // TODO: add other local hostnames if you need them
-			if (localHostnames.includes(hostname)) {
-				return request.passthrough();
-			}
-
 			throw new Error(
 				`No mock found for ${request.method} ${request.url.href}
 				`
@@ -235,34 +228,3 @@ afterEach(() => {
 	// It is important that we clear mocks between tests to avoid leakage.
 	jest.clearAllMocks();
 });
-
-// make jest understand virtual `worker:` imports
-jest.mock(
-	"worker:startDevWorker/ProxyWorker",
-	() => {
-		const path = jest.requireActual("path");
-		const { getBasePath } = jest.requireActual("../paths");
-
-		return {
-			__esModule: true,
-			default: path.resolve(getBasePath(), `wrangler-dist/ProxyWorker.js`),
-		};
-	},
-	{ virtual: true }
-);
-jest.mock(
-	"worker:startDevWorker/InspectorProxyWorker",
-	() => {
-		const path = jest.requireActual("path");
-		const { getBasePath } = jest.requireActual("../paths");
-
-		return {
-			__esModule: true,
-			default: path.resolve(
-				getBasePath(),
-				`wrangler-dist/InspectorProxyWorker.js`
-			),
-		};
-	},
-	{ virtual: true }
-);
diff --git a/packages/wrangler/src/api/dev.ts b/packages/wrangler/src/api/dev.ts
index 2d55dc595a84..d4bfaee12767 100644
--- a/packages/wrangler/src/api/dev.ts
+++ b/packages/wrangler/src/api/dev.ts
@@ -7,7 +7,6 @@ import type { Rule } from "../config/environment";
 import type { CfModule } from "../deployment-bundle/worker";
 import type { StartDevOptions } from "../dev";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli/types";
-import type { ProxyData } from "./startDevWorker";
 import type { Json } from "miniflare";
 import type { RequestInit, Response, RequestInfo } from "undici";
 
@@ -76,7 +75,6 @@ export interface UnstableDevOptions {
 export interface UnstableDevWorker {
 	port: number;
 	address: string;
-	proxyData: ProxyData;
 	stop: () => Promise<void>;
 	fetch: (input?: RequestInfo, init?: RequestInit) => Promise<Response>;
 	waitUntilExit: () => Promise<void>;
@@ -130,11 +128,7 @@ export async function unstable_dev(
 		);
 	}
 
-	type ReadyInformation = {
-		address: string;
-		port: number;
-		proxyData: ProxyData;
-	};
+	type ReadyInformation = { address: string; port: number };
 	let readyResolve: (info: ReadyInformation) => void;
 	const readyPromise = new Promise<ReadyInformation>((resolve) => {
 		readyResolve = resolve;
@@ -158,8 +152,8 @@ export async function unstable_dev(
 		forceLocal,
 		liveReload,
 		showInteractiveDevSession,
-		onReady: (address, port, proxyData) => {
-			readyResolve({ address, port, proxyData });
+		onReady: (address, port) => {
+			readyResolve({ address, port });
 		},
 		config: options?.config,
 		env: options?.env,
@@ -169,7 +163,7 @@ export async function unstable_dev(
 		compatibilityDate: options?.compatibilityDate,
 		compatibilityFlags: options?.compatibilityFlags,
 		ip: options?.ip,
-		inspectorPort: options?.inspectorPort ?? 0,
+		inspectorPort: options?.inspectorPort,
 		v: undefined,
 		localProtocol: options?.localProtocol,
 		assets: options?.assets,
@@ -209,11 +203,10 @@ export async function unstable_dev(
 		// in testMode, we can run multiple wranglers in parallel, but rebuilds might not work out of the box
 		// once the devServer is ready for requests, we resolve the ready promise
 		const devServer = await startApiDev(devOptions);
-		const { port, address, proxyData } = await readyPromise;
+		const { port, address } = await readyPromise;
 		return {
 			port,
 			address,
-			proxyData,
 			stop: devServer.stop,
 			fetch: async (input?: RequestInfo, init?: RequestInit) => {
 				return await fetch(
@@ -234,11 +227,10 @@ export async function unstable_dev(
 	} else {
 		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
 		const devServer = await startDev(devOptions);
-		const { port, address, proxyData } = await readyPromise;
+		const { port, address } = await readyPromise;
 		return {
 			port,
 			address,
-			proxyData,
 			stop: devServer.stop,
 			fetch: async (input?: RequestInfo, init?: RequestInit) => {
 				return await fetch(
diff --git a/packages/wrangler/src/api/index.ts b/packages/wrangler/src/api/index.ts
index dac524fe319e..2cf99840526a 100644
--- a/packages/wrangler/src/api/index.ts
+++ b/packages/wrangler/src/api/index.ts
@@ -9,4 +9,3 @@ export {
 	getMTlsCertificateByName,
 	deleteMTlsCertificate,
 } from "./mtls-certificate";
-export * from "./startDevWorker";
diff --git a/packages/wrangler/src/api/startDevWorker/BaseController.ts b/packages/wrangler/src/api/startDevWorker/BaseController.ts
deleted file mode 100644
index 7bd9b689831c..000000000000
--- a/packages/wrangler/src/api/startDevWorker/BaseController.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { EventEmitter } from "node:events";
-import type {
-	BundleCompleteEvent,
-	BundleStartEvent,
-	ErrorEvent,
-	PreviewTokenExpiredEvent,
-	ReloadCompleteEvent,
-	ReloadStartEvent,
-} from "./events";
-
-export abstract class Controller extends EventEmitter {}
-
-export abstract class RuntimeController extends Controller {
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	abstract onBundleStart(_: BundleStartEvent): void;
-	abstract onBundleComplete(_: BundleCompleteEvent): void;
-	abstract onPreviewTokenExpired(_: PreviewTokenExpiredEvent): void;
-	abstract teardown(): Promise<void>;
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	abstract emitReloadStartEvent(data: ReloadStartEvent): void;
-	abstract emitReloadCompletetEvent(data: ReloadCompleteEvent): void;
-
-	// *********************
-	//   Event Subscribers
-	// *********************
-
-	on(event: "reloadStart", listener: (_: ReloadStartEvent) => void): this;
-	on(event: "reloadComplete", listener: (_: ReloadCompleteEvent) => void): this;
-	// @ts-expect-error Missing overload implementation (only need the signature types, base implementation is fine)
-	on(event: "error", listener: (_: ErrorEvent) => void): this;
-	// @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
-	once: typeof this.on;
-}
diff --git a/packages/wrangler/src/api/startDevWorker/BundlerController.ts b/packages/wrangler/src/api/startDevWorker/BundlerController.ts
deleted file mode 100644
index d78cc135bce8..000000000000
--- a/packages/wrangler/src/api/startDevWorker/BundlerController.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Controller } from "./BaseController";
-import { notImplemented } from "./NotImplementedError";
-import type {
-	BundleCompleteEvent,
-	BundleStartEvent,
-	ConfigUpdateEvent,
-	ErrorEvent,
-} from "./events";
-
-export class BundlerController extends Controller {
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	onConfigUpdate(_: ConfigUpdateEvent) {
-		notImplemented(this.onConfigUpdate.name, this.constructor.name);
-	}
-
-	async teardown() {
-		notImplemented(this.teardown.name, this.constructor.name);
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	emitBundleStartEvent(data: BundleStartEvent) {
-		this.emit("bundleStart", data);
-	}
-	emitBundleCompletetEvent(data: BundleCompleteEvent) {
-		this.emit("bundleComplete", data);
-	}
-
-	// *********************
-	//   Event Subscribers
-	// *********************
-
-	on(event: "bundleStart", listener: (_: BundleStartEvent) => void): this;
-	on(event: "bundleComplete", listener: (_: BundleCompleteEvent) => void): this;
-	// @ts-expect-error Missing overload implementation (only need the signature types, base implementation is fine)
-	on(event: "error", listener: (_: ErrorEvent) => void): this;
-	// @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
-	once: typeof this.on;
-}
diff --git a/packages/wrangler/src/api/startDevWorker/ConfigController.ts b/packages/wrangler/src/api/startDevWorker/ConfigController.ts
deleted file mode 100644
index 74aa66456f28..000000000000
--- a/packages/wrangler/src/api/startDevWorker/ConfigController.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { EventEmitter } from "node:events";
-// import { readFileSync } from "../../parse";
-import { notImplemented } from "./NotImplementedError";
-import type { ConfigUpdateEvent, ErrorEvent } from "./events";
-import type { StartDevWorkerOptions } from "./types";
-
-export class ConfigController extends EventEmitter {
-	config?: StartDevWorkerOptions;
-
-	setOptions(_: StartDevWorkerOptions) {
-		notImplemented(this.setOptions.name, this.constructor.name);
-	}
-	updateOptions(_: Partial<StartDevWorkerOptions>) {
-		notImplemented(this.updateOptions.name, this.constructor.name);
-	}
-
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	async teardown() {
-		notImplemented(this.teardown.name, this.constructor.name);
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	emitConfigUpdateEvent(data: ConfigUpdateEvent) {
-		this.emit("configUpdate", data);
-	}
-
-	// *********************
-	//   Event Subscribers
-	// *********************
-
-	on(event: "configUpdate", listener: (_: ConfigUpdateEvent) => void): this;
-	// @ts-expect-error Missing overload implementation (only need the signature types, base implementation is fine)
-	on(event: "error", listener: (_: ErrorEvent) => void): this;
-	// @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
-	once: typeof this.on;
-}
diff --git a/packages/wrangler/src/api/startDevWorker/DevEnv.ts b/packages/wrangler/src/api/startDevWorker/DevEnv.ts
deleted file mode 100644
index b110a720790f..000000000000
--- a/packages/wrangler/src/api/startDevWorker/DevEnv.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import assert from "node:assert";
-import { EventEmitter } from "node:events";
-import { logger } from "../../logger";
-import { BundlerController } from "./BundlerController";
-import { ConfigController } from "./ConfigController";
-import { LocalRuntimeController } from "./LocalRuntimeController";
-import { ProxyController } from "./ProxyController";
-import { RemoteRuntimeController } from "./RemoteRuntimeController";
-import type { RuntimeController } from "./BaseController";
-import type { ErrorEvent } from "./events";
-import type { StartDevWorkerOptions, DevWorker } from "./types";
-
-/**
- * @internal
- */
-export class DevEnv extends EventEmitter {
-	config: ConfigController;
-	bundler: BundlerController;
-	runtimes: RuntimeController[];
-	proxy: ProxyController;
-
-	startWorker(options: StartDevWorkerOptions): DevWorker {
-		const worker = createWorkerObject(this);
-
-		this.config.setOptions(options);
-
-		return worker;
-	}
-
-	constructor({
-		config = new ConfigController(),
-		bundler = new BundlerController(),
-		runtimes = [
-			new LocalRuntimeController(),
-			new RemoteRuntimeController(),
-		] as RuntimeController[],
-		proxy = new ProxyController(),
-	} = {}) {
-		super();
-
-		this.config = config;
-		this.bundler = bundler;
-		this.runtimes = runtimes;
-		this.proxy = proxy;
-
-		[config, bundler, ...runtimes, proxy].forEach((controller) =>
-			controller.on("error", (event) => this.emitErrorEvent(event))
-		);
-
-		this.on("error", (event: ErrorEvent) => {
-			// TODO: when we're are comfortable with StartDevWorker/DevEnv stability,
-			//       we can remove this handler and let the user handle the unknowable errors
-			//       or let the process crash. For now, log them to stderr
-			//       so we can identify knowable vs unknowable error candidates
-
-			logger.error(`Error in ${event.source}: ${event.reason}\n`, event.cause);
-			logger.debug("=> Error contextual data:", event.data);
-		});
-
-		config.on("configUpdate", (event) => {
-			bundler.onConfigUpdate(event);
-			proxy.onConfigUpdate(event);
-		});
-
-		bundler.on("bundleStart", (event) => {
-			proxy.onBundleStart(event);
-			runtimes.forEach((runtime) => {
-				runtime.onBundleStart(event);
-			});
-		});
-		bundler.on("bundleComplete", (event) => {
-			runtimes.forEach((runtime) => {
-				runtime.onBundleComplete(event);
-			});
-		});
-
-		runtimes.forEach((runtime) => {
-			runtime.on("reloadStart", (event) => {
-				proxy.onReloadStart(event);
-			});
-			runtime.on("reloadComplete", (event) => {
-				proxy.onReloadComplete(event);
-			});
-		});
-
-		proxy.on("previewTokenExpired", (event) => {
-			runtimes.forEach((runtime) => {
-				runtime.onPreviewTokenExpired(event);
-			});
-		});
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	async teardown() {
-		this.emit("teardown");
-
-		await Promise.all([
-			this.config.teardown(),
-			this.bundler.teardown(),
-			this.runtimes.forEach((runtime) => runtime.teardown()),
-			this.proxy.teardown(),
-		]);
-	}
-
-	emitErrorEvent(ev: ErrorEvent) {
-		if (
-			ev.source === "ProxyController" &&
-			ev.reason === "Failed to start ProxyWorker or InspectorProxyWorker"
-		) {
-			assert(ev.data.config); // we must already have a `config` if we've already tried (and failed) to instantiate the ProxyWorker(s)
-
-			const { config } = ev.data;
-			const port = config.dev?.server?.port;
-			const inspectorPort = config.dev?.inspector?.port;
-			const randomPorts = [0, undefined];
-
-			// console.log({ port, inspectorPort, ev });
-			if (!randomPorts.includes(port) || !randomPorts.includes(inspectorPort)) {
-				// emit the event here while the ConfigController is unimplemented
-				// this will cause the ProxyController to try reinstantiating the ProxyWorker(s)
-				// TODO: change this to `this.config.updateOptions({ dev: { server: { port: 0 }, inspector: { port: 0 } } });` when the ConfigController is implemented
-				this.config.emitConfigUpdateEvent({
-					type: "configUpdate",
-					config: {
-						...config,
-						dev: {
-							...config.dev,
-							server: { ...config.dev?.server, port: 0 }, // override port
-							inspector: { ...config.dev?.inspector, port: 0 }, // override port
-						},
-					},
-				});
-			}
-		} else if (
-			ev.source === "ProxyController" &&
-			(ev.reason.startsWith("Failed to send message to") ||
-				ev.reason.startsWith("Could not connect to InspectorProxyWorker"))
-		) {
-			logger.debug(`Error in ${ev.source}: ${ev.reason}\n`, ev.cause);
-			logger.debug("=> Error contextual data:", ev.data);
-		}
-		// if other knowable + recoverable errors occur, handle them here
-		else {
-			// otherwise, re-emit the unknowable errors to the top-level
-			this.emit("error", ev);
-		}
-	}
-}
-
-export function createWorkerObject(devEnv: DevEnv): DevWorker {
-	return {
-		get ready() {
-			return devEnv.proxy.ready.promise.then(() => undefined);
-		},
-		get config() {
-			return devEnv.config.config;
-		},
-		setOptions(options) {
-			return devEnv.config.setOptions(options);
-		},
-		updateOptions(options) {
-			return devEnv.config.updateOptions(options);
-		},
-		async fetch(...args) {
-			const { proxyWorker } = await devEnv.proxy.ready.promise;
-			await devEnv.proxy.runtimeMessageMutex.drained();
-
-			return proxyWorker.dispatchFetch(...args);
-		},
-		async queue(..._args) {
-			// const { worker } = await devEnv.proxy.ready;
-			// return worker.queue(...args);
-		},
-		async scheduled(..._args) {
-			// const { worker } = await devEnv.proxy.ready;
-			// return worker.scheduled(...args);
-		},
-		async dispose() {
-			await devEnv.teardown();
-		},
-	};
-}
diff --git a/packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts b/packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts
deleted file mode 100644
index 699070b14569..000000000000
--- a/packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-// import { readFileSync } from "../../parse";
-import { RuntimeController } from "./BaseController";
-import { notImplemented } from "./NotImplementedError";
-import type {
-	BundleCompleteEvent,
-	BundleStartEvent,
-	PreviewTokenExpiredEvent,
-	ReloadCompleteEvent,
-	ReloadStartEvent,
-} from "./events";
-
-export class LocalRuntimeController extends RuntimeController {
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	onBundleStart(_: BundleStartEvent) {
-		notImplemented(this.onBundleStart.name, this.constructor.name);
-	}
-	onBundleComplete(_: BundleCompleteEvent) {
-		notImplemented(this.onBundleComplete.name, this.constructor.name);
-	}
-	onPreviewTokenExpired(_: PreviewTokenExpiredEvent): void {
-		// ignore in local runtime
-	}
-
-	async teardown() {
-		notImplemented(this.teardown.name, this.constructor.name);
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	emitReloadStartEvent(data: ReloadStartEvent) {
-		this.emit("reloadComplete", data);
-	}
-	emitReloadCompletetEvent(data: ReloadCompleteEvent) {
-		this.emit("reloadComplete", data);
-	}
-}
diff --git a/packages/wrangler/src/api/startDevWorker/NotImplementedError.ts b/packages/wrangler/src/api/startDevWorker/NotImplementedError.ts
deleted file mode 100644
index 7bfc32be7fbe..000000000000
--- a/packages/wrangler/src/api/startDevWorker/NotImplementedError.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { logger } from "../../logger";
-
-export class NotImplementedError extends Error {
-	constructor(func: string, namespace?: string) {
-		if (namespace) func = `${namespace}#${func}`;
-		super(`Not Implemented Error: ${func}`);
-	}
-}
-
-export function notImplemented(func: string, namespace?: string) {
-	if (namespace) func = `${namespace}#${func}`;
-	logger.debug(`Not Implemented Error: ${func}`);
-
-	return new NotImplementedError(func, namespace);
-}
diff --git a/packages/wrangler/src/api/startDevWorker/ProxyController.ts b/packages/wrangler/src/api/startDevWorker/ProxyController.ts
deleted file mode 100644
index d07625b4cf25..000000000000
--- a/packages/wrangler/src/api/startDevWorker/ProxyController.ts
+++ /dev/null
@@ -1,526 +0,0 @@
-import assert from "node:assert";
-import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-import path from "node:path";
-import { LogLevel, Miniflare, Mutex, Response, WebSocket } from "miniflare";
-import inspectorProxyWorkerPath from "worker:startDevWorker/InspectorProxyWorker";
-import proxyWorkerPath from "worker:startDevWorker/ProxyWorker";
-import {
-	logConsoleMessage,
-	maybeHandleNetworkLoadResource,
-} from "../../dev/inspect";
-import { WranglerLog, castLogLevel } from "../../dev/miniflare";
-import { handleRuntimeStdio } from "../../dev/miniflare";
-import { getHttpsOptions } from "../../https-options";
-import { logger } from "../../logger";
-import { getSourceMappedStack } from "../../sourcemap";
-import { castErrorCause } from "./events";
-import { assertNever, createDeferred, type DeferredPromise } from "./utils";
-import type { EsbuildBundle } from "../../dev/use-esbuild";
-import type {
-	BundleStartEvent,
-	ConfigUpdateEvent,
-	ErrorEvent,
-	InspectorProxyWorkerIncomingWebSocketMessage,
-	InspectorProxyWorkerOutgoingRequestBody,
-	InspectorProxyWorkerOutgoingWebsocketMessage,
-	PreviewTokenExpiredEvent,
-	ProxyData,
-	ProxyWorkerIncomingRequestBody,
-	ProxyWorkerOutgoingRequestBody,
-	ReadyEvent,
-	ReloadCompleteEvent,
-	ReloadStartEvent,
-	SerializedError,
-} from "./events";
-import type { StartDevWorkerOptions } from "./types";
-import type { MiniflareOptions } from "miniflare";
-
-export class ProxyController extends EventEmitter {
-	public ready = createDeferred<ReadyEvent>();
-
-	public proxyWorker?: Miniflare;
-	proxyWorkerOptions?: MiniflareOptions;
-	inspectorProxyWorkerWebSocket?: DeferredPromise<WebSocket>;
-
-	protected latestConfig?: StartDevWorkerOptions;
-	protected latestBundle?: EsbuildBundle;
-	secret = randomUUID();
-
-	protected createProxyWorker() {
-		if (this._torndown) return;
-		assert(this.latestConfig !== undefined);
-
-		const cert =
-			this.latestConfig.dev?.server?.secure ||
-			this.latestConfig.dev?.inspector?.secure
-				? getHttpsOptions()
-				: undefined;
-
-		const proxyWorkerOptions: MiniflareOptions = {
-			host: this.latestConfig.dev?.server?.hostname,
-			port: this.latestConfig.dev?.server?.port,
-			https: this.latestConfig.dev?.server?.secure,
-			httpsCert: cert?.cert,
-			httpsKey: cert?.key,
-
-			workers: [
-				{
-					name: "ProxyWorker",
-					compatibilityFlags: ["nodejs_compat"],
-					modulesRoot: path.dirname(proxyWorkerPath),
-					modules: [{ type: "ESModule", path: proxyWorkerPath }],
-					durableObjects: {
-						DURABLE_OBJECT: {
-							className: "ProxyWorker",
-							unsafePreventEviction: true,
-						},
-					},
-					serviceBindings: {
-						PROXY_CONTROLLER: async (req): Promise<Response> => {
-							const message =
-								(await req.json()) as ProxyWorkerOutgoingRequestBody;
-
-							this.onProxyWorkerMessage(message);
-
-							return new Response(null, { status: 204 });
-						},
-					},
-					bindings: {
-						PROXY_CONTROLLER_AUTH_SECRET: this.secret,
-					},
-
-					// no need to use file-system, so don't
-					cache: false,
-					unsafeEphemeralDurableObjects: true,
-				},
-				{
-					name: "InspectorProxyWorker",
-					compatibilityFlags: ["nodejs_compat"],
-					modulesRoot: path.dirname(inspectorProxyWorkerPath),
-					modules: [{ type: "ESModule", path: inspectorProxyWorkerPath }],
-					durableObjects: {
-						DURABLE_OBJECT: {
-							className: "InspectorProxyWorker",
-							unsafePreventEviction: true,
-						},
-					},
-					serviceBindings: {
-						PROXY_CONTROLLER: async (req): Promise<Response> => {
-							const body =
-								(await req.json()) as InspectorProxyWorkerOutgoingRequestBody;
-
-							return this.onInspectorProxyWorkerRequest(body);
-						},
-					},
-					bindings: {
-						PROXY_CONTROLLER_AUTH_SECRET: this.secret,
-					},
-
-					unsafeDirectHost: this.latestConfig.dev?.inspector?.hostname,
-					unsafeDirectPort: this.latestConfig.dev?.inspector?.port ?? 0,
-
-					// no need to use file-system, so don't
-					cache: false,
-					unsafeEphemeralDurableObjects: true,
-				},
-			],
-
-			verbose: logger.loggerLevel === "debug",
-
-			// log requests into the ProxyWorker (for local + remote mode)
-			log: new ProxyControllerLogger(castLogLevel(logger.loggerLevel), {
-				prefix:
-					// if debugging, log requests with specic ProxyWorker prefix
-					logger.loggerLevel === "debug" ? "wrangler-ProxyWorker" : "wrangler",
-			}),
-			handleRuntimeStdio,
-		};
-
-		const proxyWorkerOptionsChanged = didMiniflareOptionsChange(
-			this.proxyWorkerOptions,
-			proxyWorkerOptions
-		);
-
-		const willInstantiateMiniflareInstance =
-			!this.proxyWorker || proxyWorkerOptionsChanged;
-		this.proxyWorker ??= new Miniflare(proxyWorkerOptions);
-		this.proxyWorkerOptions = proxyWorkerOptions;
-
-		if (proxyWorkerOptionsChanged) {
-			logger.debug("ProxyWorker miniflare options changed, reinstantiating...");
-
-			void this.proxyWorker.setOptions(proxyWorkerOptions);
-
-			// this creates a new .ready promise that will be resolved when both ProxyWorkers are ready
-			// it also respects any await-ers of the existing .ready promise
-			this.ready = createDeferred<ReadyEvent>(this.ready);
-		}
-
-		// store the non-null versions for callbacks
-		const { proxyWorker } = this;
-
-		if (willInstantiateMiniflareInstance) {
-			void Promise.all([
-				proxyWorker.ready,
-				this.reconnectInspectorProxyWorker(),
-			])
-				.then(() => {
-					this.emitReadyEvent(proxyWorker);
-				})
-				.catch((error) => {
-					this.emitErrorEvent(
-						"Failed to start ProxyWorker or InspectorProxyWorker",
-						error
-					);
-				});
-		}
-	}
-
-	async reconnectInspectorProxyWorker(): Promise<WebSocket | undefined> {
-		if (this._torndown) return;
-
-		const existingWebSocket = await this.inspectorProxyWorkerWebSocket?.promise;
-		if (existingWebSocket?.readyState === WebSocket.READY_STATE_OPEN) {
-			return existingWebSocket;
-		}
-
-		this.inspectorProxyWorkerWebSocket = createDeferred<WebSocket>();
-
-		let webSocket: WebSocket | null = null;
-
-		try {
-			assert(this.proxyWorker);
-			const inspectorProxyWorker = await this.proxyWorker.getWorker(
-				"InspectorProxyWorker"
-			);
-			({ webSocket } = await inspectorProxyWorker.fetch(
-				"http://dummy/cdn-cgi/InspectorProxyWorker/websocket",
-				{
-					headers: { Authorization: this.secret, Upgrade: "websocket" },
-				}
-			));
-		} catch (cause) {
-			if (this._torndown) return;
-
-			const error = castErrorCause(cause);
-
-			this.inspectorProxyWorkerWebSocket?.reject(error);
-			this.emitErrorEvent("Could not connect to InspectorProxyWorker", error);
-			return;
-		}
-
-		assert(
-			webSocket,
-			"Expected webSocket on response from inspectorProxyWorker"
-		);
-
-		webSocket.addEventListener("message", (event) => {
-			assert(typeof event.data === "string");
-
-			this.onInspectorProxyWorkerMessage(JSON.parse(event.data));
-		});
-		webSocket.addEventListener("close", () => {
-			// don't reconnect
-		});
-		webSocket.addEventListener("error", () => {
-			if (this._torndown) return;
-
-			void this.reconnectInspectorProxyWorker();
-		});
-
-		webSocket.accept();
-		this.inspectorProxyWorkerWebSocket?.resolve(webSocket);
-
-		return webSocket;
-	}
-
-	runtimeMessageMutex = new Mutex();
-	async sendMessageToProxyWorker(
-		message: ProxyWorkerIncomingRequestBody,
-		retries = 3
-	): Promise<void> {
-		if (this._torndown) return;
-
-		// Don't do any async work here. Enqueue the message with the mutex immediately.
-
-		try {
-			await this.runtimeMessageMutex.runWith(async () => {
-				assert(this.proxyWorker, "proxyWorker should already be instantiated");
-
-				const ready = await this.proxyWorker.ready.catch(() => undefined);
-				if (!ready) return;
-
-				return this.proxyWorker.dispatchFetch(
-					`http://dummy/cdn-cgi/ProxyWorker/${message.type}`,
-					{
-						headers: { Authorization: this.secret },
-						cf: { hostMetadata: message },
-					}
-				);
-			});
-		} catch (cause) {
-			if (this._torndown) return;
-
-			const error = castErrorCause(cause);
-
-			if (retries > 0) {
-				return this.sendMessageToProxyWorker(message, retries - 1);
-			}
-
-			this.emitErrorEvent(
-				`Failed to send message to ProxyWorker: ${JSON.stringify(message)}`,
-				error
-			);
-
-			throw error;
-		}
-	}
-	async sendMessageToInspectorProxyWorker(
-		message: InspectorProxyWorkerIncomingWebSocketMessage,
-		retries = 3
-	): Promise<void> {
-		if (this._torndown) return;
-
-		try {
-			// returns the existing websocket, if already connected
-			const websocket = await this.reconnectInspectorProxyWorker();
-			assert(websocket);
-
-			websocket.send(JSON.stringify(message));
-		} catch (cause) {
-			if (this._torndown) return;
-
-			const error = castErrorCause(cause);
-
-			if (retries > 0) {
-				return this.sendMessageToInspectorProxyWorker(message, retries - 1);
-			}
-
-			this.emitErrorEvent(
-				`Failed to send message to InspectorProxyWorker: ${JSON.stringify(
-					message
-				)}`,
-				error
-			);
-
-			throw error;
-		}
-	}
-
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	onConfigUpdate(data: ConfigUpdateEvent) {
-		this.latestConfig = data.config;
-		this.createProxyWorker();
-
-		void this.sendMessageToProxyWorker({ type: "pause" });
-	}
-	onBundleStart(data: BundleStartEvent) {
-		this.latestConfig = data.config;
-
-		void this.sendMessageToProxyWorker({ type: "pause" });
-	}
-	onReloadStart(data: ReloadStartEvent) {
-		this.latestConfig = data.config;
-
-		void this.sendMessageToProxyWorker({ type: "pause" });
-		void this.sendMessageToInspectorProxyWorker({ type: "reloadStart" });
-	}
-	onReloadComplete(data: ReloadCompleteEvent) {
-		this.latestConfig = data.config;
-		this.latestBundle = data.bundle;
-
-		void this.sendMessageToProxyWorker({
-			type: "play",
-			proxyData: data.proxyData,
-		});
-
-		void this.sendMessageToInspectorProxyWorker({
-			type: "reloadComplete",
-			proxyData: data.proxyData,
-		});
-	}
-	onProxyWorkerMessage(message: ProxyWorkerOutgoingRequestBody) {
-		switch (message.type) {
-			case "previewTokenExpired":
-				this.emitPreviewTokenExpiredEvent(message.proxyData);
-
-				break;
-			case "error":
-				this.emitErrorEvent("Error inside ProxyWorker", message.error);
-
-				break;
-			case "debug-log":
-				logger.debug("[ProxyWorker]", ...message.args);
-
-				break;
-			default:
-				assertNever(message);
-		}
-	}
-	onInspectorProxyWorkerMessage(
-		message: InspectorProxyWorkerOutgoingWebsocketMessage
-	) {
-		switch (message.method) {
-			case "Runtime.consoleAPICalled": {
-				if (this._torndown) return;
-
-				logConsoleMessage(message.params);
-
-				break;
-			}
-			case "Runtime.exceptionThrown": {
-				if (this._torndown) return;
-
-				const stack = getSourceMappedStack(message.params.exceptionDetails);
-				logger.error(message.params.exceptionDetails.text, stack);
-				break;
-			}
-			default: {
-				assertNever(message);
-			}
-		}
-	}
-	async onInspectorProxyWorkerRequest(
-		message: InspectorProxyWorkerOutgoingRequestBody
-	) {
-		switch (message.type) {
-			case "runtime-websocket-error":
-				// TODO: consider sending proxyData again to trigger the InspectorProxyWorker to reconnect to the runtime
-				logger.debug(
-					"[InspectorProxyWorker] 'runtime websocket' error",
-					message.error
-				);
-
-				break;
-			case "error":
-				this.emitErrorEvent("Error inside InspectorProxyWorker", message.error);
-
-				break;
-			case "debug-log":
-				if (this._torndown) break;
-
-				logger.debug("[InspectorProxyWorker]", ...message.args);
-
-				break;
-			case "load-network-resource": {
-				assert(this.latestConfig !== undefined);
-				assert(this.latestBundle !== undefined);
-
-				let maybeContents: string | undefined;
-				if (message.url.startsWith("wrangler-file:")) {
-					maybeContents = maybeHandleNetworkLoadResource(
-						message.url.replace("wrangler-file:", "file:"),
-						this.latestBundle,
-						this.latestBundle.sourceMapMetadata?.tmpDir
-					);
-				}
-
-				if (maybeContents === undefined) {
-					return new Response(null, { status: 404 });
-				}
-
-				return new Response(maybeContents);
-			}
-			default:
-				assertNever(message);
-				return new Response(null, { status: 404 });
-		}
-
-		return new Response(null, { status: 204 });
-	}
-
-	_torndown = false;
-	async teardown() {
-		logger.debug("ProxyController teardown");
-		this._torndown = true;
-
-		const { proxyWorker } = this;
-		this.proxyWorker = undefined;
-
-		await Promise.all([
-			proxyWorker?.dispose(),
-			this.inspectorProxyWorkerWebSocket?.promise
-				.then((ws) => ws.close())
-				.catch(() => {
-					/* ignore */
-				}),
-		]);
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	emitReadyEvent(proxyWorker: Miniflare) {
-		const data: ReadyEvent = {
-			type: "ready",
-			proxyWorker,
-		};
-
-		this.emit("ready", data);
-		this.ready.resolve(data);
-	}
-	emitPreviewTokenExpiredEvent(proxyData: ProxyData) {
-		this.emit("previewTokenExpired", {
-			type: "previewTokenExpired",
-			proxyData,
-		});
-	}
-	emitErrorEvent(reason: string, cause: Error | SerializedError) {
-		const event: ErrorEvent = {
-			type: "error",
-			source: "ProxyController",
-			cause,
-			reason,
-			data: {
-				config: this.latestConfig,
-				bundle: this.latestBundle,
-			},
-		};
-
-		this.emit("error", event);
-	}
-
-	// *********************
-	//   Event Subscribers
-	// *********************
-
-	on(event: "ready", listener: (_: ReadyEvent) => void): this;
-	on(
-		event: "previewTokenExpired",
-		listener: (_: PreviewTokenExpiredEvent) => void
-	): this;
-	// @ts-expect-error Missing overload implementation (only need the signature types, base implementation is fine)
-	on(event: "error", listener: (_: ErrorEvent) => void): this;
-	// @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
-	once: typeof this.on;
-}
-
-export class ProxyControllerLogger extends WranglerLog {
-	log(message: string) {
-		// filter out request logs being handled by the ProxyWorker
-		// the requests log remaining are handled by the UserWorker
-		// keep the ProxyWorker request logs if we're in debug mode
-		if (message.includes("/cdn-cgi/") && this.level < LogLevel.DEBUG) return;
-		super.log(message);
-	}
-}
-
-function deepEquality(a: unknown, b: unknown): boolean {
-	// could be more efficient, but this is fine for now
-	return JSON.stringify(a) === JSON.stringify(b);
-}
-
-function didMiniflareOptionsChange(
-	prev: MiniflareOptions | undefined,
-	next: MiniflareOptions
-) {
-	if (prev === undefined) return false; // first time, so 'no change'
-
-	// otherwise, if they're not deeply equal, they've changed
-	return !deepEquality(prev, next);
-}
diff --git a/packages/wrangler/src/api/startDevWorker/RemoteRuntimeController.ts b/packages/wrangler/src/api/startDevWorker/RemoteRuntimeController.ts
deleted file mode 100644
index 71f289b338c3..000000000000
--- a/packages/wrangler/src/api/startDevWorker/RemoteRuntimeController.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-// import { readFileSync } from "../../parse";
-import { RuntimeController } from "./BaseController";
-import { notImplemented } from "./NotImplementedError";
-import type {
-	BundleCompleteEvent,
-	BundleStartEvent,
-	PreviewTokenExpiredEvent,
-	ReloadCompleteEvent,
-	ReloadStartEvent,
-} from "./events";
-
-export class RemoteRuntimeController extends RuntimeController {
-	// ******************
-	//   Event Handlers
-	// ******************
-
-	onBundleStart(_: BundleStartEvent) {
-		notImplemented(this.onBundleStart.name, this.constructor.name);
-	}
-	onBundleComplete(_: BundleCompleteEvent) {
-		notImplemented(this.onBundleComplete.name, this.constructor.name);
-	}
-	onPreviewTokenExpired(_: PreviewTokenExpiredEvent): void {
-		notImplemented(this.onPreviewTokenExpired.name, this.constructor.name);
-	}
-
-	async teardown() {
-		notImplemented(this.teardown.name, this.constructor.name);
-	}
-
-	// *********************
-	//   Event Dispatchers
-	// *********************
-
-	emitReloadStartEvent(data: ReloadStartEvent) {
-		this.emit("reloadComplete", data);
-	}
-	emitReloadCompletetEvent(data: ReloadCompleteEvent) {
-		this.emit("reloadComplete", data);
-	}
-}
diff --git a/packages/wrangler/src/api/startDevWorker/bundle-allowed-paths.ts b/packages/wrangler/src/api/startDevWorker/bundle-allowed-paths.ts
deleted file mode 100644
index b459971997fd..000000000000
--- a/packages/wrangler/src/api/startDevWorker/bundle-allowed-paths.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * Browser DevTools will send `Network.loadNetworkResource` commands for source
- * maps and source files. We only want to allow files referenced by the bundle
- * to be requested (to prevent arbitrary file access). This module exports
- * functions for checking whether a specific file may be requested as a source
- * file, or source map (i.e. is safe to serve from the file system).
- */
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import type { EsbuildBundle } from "../../dev/use-esbuild";
-import type { RawSourceMap } from "source-map";
-
-export function isAllowedSourcePath(
-	bundle: EsbuildBundle,
-	filePath: string
-): boolean {
-	const allowed = getBundleReferencedPaths(bundle);
-	return allowed.sourcePaths.has(filePath);
-}
-export function isAllowedSourceMapPath(
-	bundle: EsbuildBundle,
-	filePath: string
-): boolean {
-	const allowed = getBundleReferencedPaths(bundle);
-	return allowed.sourceMapPaths.has(filePath);
-}
-
-interface BundleReferencedPaths {
-	sourcePaths: Set<string>;
-	sourceMapPaths: Set<string>;
-}
-const bundleReferencedPathsCache = new WeakMap<
-	EsbuildBundle,
-	BundleReferencedPaths
->();
-function getBundleReferencedPaths(
-	bundle: EsbuildBundle
-): BundleReferencedPaths {
-	let allowed = bundleReferencedPathsCache.get(bundle);
-	if (allowed !== undefined) return allowed;
-	allowed = { sourcePaths: new Set(), sourceMapPaths: new Set() };
-	bundleReferencedPathsCache.set(bundle, allowed);
-
-	for (const sourcePath of getBundleSourcePaths(bundle)) {
-		// We don't need to add `sourcePath` to `allowed` here, as DevTools sends
-		// `Debugger.getScriptSource` commands instead, which get the code from V8.
-
-		const sourceMappingURL = maybeGetSourceMappingURL(sourcePath);
-		if (sourceMappingURL === undefined) continue;
-		const sourceMappingPath = fileURLToPath(sourceMappingURL);
-		allowed.sourceMapPaths.add(sourceMappingPath);
-
-		const sourceMapData = fs.readFileSync(sourceMappingPath, "utf8");
-		const sourceMap: RawSourceMap = JSON.parse(sourceMapData);
-
-		const sourceRoot = sourceMap.sourceRoot ?? "";
-		for (const source of sourceMap.sources) {
-			const sourceURL = new URL(
-				path.posix.join(sourceRoot, source),
-				sourceMappingURL
-			);
-			allowed.sourcePaths.add(fileURLToPath(sourceURL));
-		}
-	}
-
-	return allowed;
-}
-
-function* getBundleSourcePaths(bundle: EsbuildBundle): Generator<string> {
-	yield bundle.path;
-	for (const module of bundle.modules) {
-		if (module.type !== "esm" && module.type !== "commonjs") continue;
-		if (module.filePath === undefined) continue;
-		yield module.filePath;
-	}
-}
-
-function maybeGetSourceMappingURL(sourcePath: string): URL | undefined {
-	const source = fs.readFileSync(sourcePath, "utf8");
-	const sourceMappingURLIndex = source.lastIndexOf("//# sourceMappingURL=");
-	if (sourceMappingURLIndex === -1) return;
-
-	const sourceMappingURLMatch = source
-		.substring(sourceMappingURLIndex)
-		.match(/^\/\/# sourceMappingURL=(.+)/);
-	assert(sourceMappingURLMatch !== null);
-	const sourceMappingURLSpecifier = sourceMappingURLMatch[1];
-
-	const sourceURL = pathToFileURL(sourcePath);
-	try {
-		const sourceMappingURL = new URL(sourceMappingURLSpecifier, sourceURL);
-		if (sourceMappingURL.protocol !== "file:") return;
-		return sourceMappingURL;
-	} catch {
-		// If we can't parse `sourceMappingURLSpecifier`, ignore it
-	}
-}
diff --git a/packages/wrangler/src/api/startDevWorker/devtools.ts b/packages/wrangler/src/api/startDevWorker/devtools.ts
deleted file mode 100644
index 8a3afb85a631..000000000000
--- a/packages/wrangler/src/api/startDevWorker/devtools.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import type Protocol from "devtools-protocol/types/protocol-mapping";
-
-type _Params<ParamsArray extends [unknown?]> = ParamsArray extends [infer P]
-	? P
-	: undefined;
-
-type _EventMethods = keyof Protocol.Events;
-export type DevToolsEvent<Method extends _EventMethods> = Method extends unknown
-	? {
-			method: Method;
-			params: _Params<Protocol.Events[Method]>;
-	  }
-	: never;
-
-export type DevToolsEvents = DevToolsEvent<_EventMethods>;
-
-type _CommandMethods = keyof Protocol.Commands;
-export type DevToolsCommandRequest<Method extends _CommandMethods> =
-	Method extends unknown
-		? _Params<Protocol.Commands[Method]["paramsType"]> extends undefined
-			? {
-					id: number;
-					method: Method;
-			  }
-			: {
-					id: number;
-					method: Method;
-					params: _Params<Protocol.Commands[Method]["paramsType"]>;
-			  }
-		: never;
-
-export type DevToolsCommandRequests = DevToolsCommandRequest<_CommandMethods>;
-
-export type DevToolsCommandResponse<Method extends _CommandMethods> =
-	Method extends unknown
-		? {
-				id: number;
-				result: Protocol.Commands[Method]["returnType"];
-		  }
-		: never;
-export type DevToolsCommandResponses = DevToolsCommandResponse<_CommandMethods>;
diff --git a/packages/wrangler/src/api/startDevWorker/events.ts b/packages/wrangler/src/api/startDevWorker/events.ts
deleted file mode 100644
index 1c9b6f6e1074..000000000000
--- a/packages/wrangler/src/api/startDevWorker/events.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import type { EsbuildBundle } from "../../dev/use-esbuild";
-import type { DevToolsEvent } from "./devtools";
-import type { StartDevWorkerOptions } from "./types";
-import type { Miniflare } from "miniflare";
-
-export type TeardownEvent = {
-	type: "teardown";
-};
-export type ErrorEvent =
-	| BaseErrorEvent<
-			| "ConfigController"
-			| "BundlerController"
-			| "LocalRuntimeController"
-			| "RemoteRuntimeController"
-			| "ProxyWorker"
-			| "InspectorProxyWorker"
-	  >
-	| BaseErrorEvent<
-			"ProxyController",
-			{ config?: StartDevWorkerOptions; bundle?: EsbuildBundle }
-	  >;
-export type BaseErrorEvent<Source = string, Data = undefined> = {
-	type: "error";
-	reason: string;
-	cause: Error | SerializedError;
-	source: Source;
-	data: Data;
-};
-
-export function castErrorCause(cause: unknown) {
-	if (cause instanceof Error) return cause;
-
-	const error = new Error();
-	error.cause = cause;
-
-	return error;
-}
-
-// ConfigController
-export type ConfigUpdateEvent = {
-	type: "configUpdate";
-
-	config: StartDevWorkerOptions;
-};
-
-// BundlerController
-export type BundleStartEvent = {
-	type: "bundleStart";
-
-	config: StartDevWorkerOptions;
-};
-export type BundleCompleteEvent = {
-	type: "bundleComplete";
-
-	config: StartDevWorkerOptions;
-	bundle: EsbuildBundle;
-};
-
-// RuntimeController
-export type ReloadStartEvent = {
-	type: "reloadStart";
-
-	config: StartDevWorkerOptions;
-	bundle: EsbuildBundle;
-};
-export type ReloadCompleteEvent = {
-	type: "reloadComplete";
-
-	config: StartDevWorkerOptions;
-	bundle: EsbuildBundle;
-	proxyData: ProxyData;
-};
-
-// ProxyController
-export type PreviewTokenExpiredEvent = {
-	type: "previewTokenExpired";
-
-	proxyData: ProxyData;
-	// ... other details of failed request/response
-};
-export type ReadyEvent = {
-	type: "ready";
-
-	proxyWorker: Miniflare;
-};
-
-// ProxyWorker
-export type ProxyWorkerIncomingRequestBody =
-	| { type: "play"; proxyData: ProxyData }
-	| { type: "pause" };
-export type ProxyWorkerOutgoingRequestBody =
-	| { type: "error"; error: SerializedError }
-	| { type: "previewTokenExpired"; proxyData: ProxyData }
-	| { type: "debug-log"; args: Parameters<typeof console.debug> };
-
-// InspectorProxyWorker
-export * from "./devtools";
-export type InspectorProxyWorkerIncomingWebSocketMessage =
-	| {
-			type: ReloadStartEvent["type"];
-	  }
-	| {
-			type: ReloadCompleteEvent["type"];
-			proxyData: ProxyData;
-	  };
-export type InspectorProxyWorkerOutgoingWebsocketMessage =
-	// Relayed Chrome DevTools Protocol Messages
-	| DevToolsEvent<"Runtime.consoleAPICalled">
-	| DevToolsEvent<"Runtime.exceptionThrown">;
-
-export type InspectorProxyWorkerOutgoingRequestBody =
-	| { type: "error"; error: SerializedError }
-	| { type: "runtime-websocket-error"; error: SerializedError }
-	| { type: "debug-log"; args: Parameters<typeof console.debug> }
-	// Intercepted Chrome DevTools Protocol Messages
-	| { type: "load-network-resource"; url: string }; // responds with `url`'s contents
-
-export type SerializedError = {
-	message: string;
-	name?: string;
-	stack?: string | undefined;
-	cause?: unknown;
-};
-export function serialiseError(e: unknown): SerializedError {
-	if (e instanceof Error) {
-		return {
-			message: e.message,
-			name: e.name,
-			stack: e.stack,
-			cause: e.cause && serialiseError(e.cause),
-		};
-	} else {
-		return { message: String(e) };
-	}
-}
-
-export type UrlOriginParts = Pick<URL, "protocol" | "hostname" | "port">;
-export type UrlOriginAndPathnameParts = Pick<
-	URL,
-	"protocol" | "hostname" | "port" | "pathname"
->;
-
-export type ProxyData = {
-	userWorkerUrl: UrlOriginParts;
-	userWorkerInspectorUrl: UrlOriginAndPathnameParts;
-	userWorkerInnerUrlOverrides: Partial<UrlOriginParts>;
-	headers: Record<string, string | undefined>;
-	liveReload?: boolean;
-	proxyLogsToController?: boolean;
-};
diff --git a/packages/wrangler/src/api/startDevWorker/index.ts b/packages/wrangler/src/api/startDevWorker/index.ts
deleted file mode 100644
index 582a4c3206d1..000000000000
--- a/packages/wrangler/src/api/startDevWorker/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { DevEnv } from "./DevEnv";
-import type { StartDevWorkerOptions, DevWorker } from "./types";
-
-export { DevEnv };
-export * from "./types";
-export * from "./events";
-
-export function startWorker(options: StartDevWorkerOptions): DevWorker {
-	const devEnv = new DevEnv();
-
-	return devEnv.startWorker(options);
-}
diff --git a/packages/wrangler/src/api/startDevWorker/types.ts b/packages/wrangler/src/api/startDevWorker/types.ts
deleted file mode 100644
index b476d38dab4d..000000000000
--- a/packages/wrangler/src/api/startDevWorker/types.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-import type { RawConfig } from "../../config/config";
-import type { CfAccount } from "../../dev/create-worker-preview";
-import type { Json, Request, Response, DispatchFetch } from "miniflare";
-import type * as undici from "undici";
-
-export interface DevWorker {
-	ready: Promise<void>;
-	config?: StartDevWorkerOptions;
-	setOptions(options: StartDevWorkerOptions): void;
-	updateOptions(options: Partial<StartDevWorkerOptions>): void;
-	fetch: DispatchFetch;
-	scheduled(cron?: string): Promise<void>;
-	queue(queueName: string, ...messages: unknown[]): Promise<void>;
-	dispose(): Promise<void>;
-}
-
-export interface StartDevWorkerOptions {
-	/** The name of the worker. */
-	name: string;
-	/**
-	 * The javascript or typescript entry-point of the worker.
-	 * This is the `main` property of a wrangler.toml.
-	 * You can specify a file path or provide the contents directly.
-	 */
-	script: File<string>;
-	/** The configuration of the worker. */
-	config?: File<string | RawConfig> & { env?: string };
-	/** The compatibility date for the workerd runtime. */
-	compatibilityDate?: string;
-	/** The compatibility flags for the workerd runtime. */
-	compatibilityFlags?: string[];
-
-	/** The bindings available to the worker. The specified bindind type will be exposed to the worker on the `env` object under the same key. */
-	bindings?: Record<string, Binding>; // Type level constraint for bindings not sharing names
-	/** The triggers which will cause the worker's exported default handlers to be called. */
-	triggers?: Trigger[];
-
-	/** Options applying to (legacy) Worker Sites. Please consider using Cloudflare Pages. */
-	site?: {
-		path: string;
-		include?: string[];
-		exclude?: string[];
-	};
-
-	/** Options applying to the worker's build step. Applies to deploy and dev. */
-	build?: {
-		/** Whether the worker and its dependencies are bundled. Defaults to true. */
-		bundle?: boolean;
-		/** Specifies types of modules matched by globs. */
-		moduleRules?: ModuleRule[];
-		/** Replace global identifiers with constant expressions, e.g. ['debug=true','version="1.0.0"'] or { debug: 'true', version: '"1.0.0"' }. Only takes effect if bundle: true. */
-		define: string[] | Record<string, string>;
-		/** Whether the bundled worker is minified. Only takes effect if bundle: true. */
-		minify: boolean;
-		/** Options controlling a custom build step. */
-		custom: {
-			/** Custom shell command to run before bundling. Runs even if bundle. */
-			command: string;
-			/** The cwd to run the command in. */
-			workingDirectory?: string;
-			/** Filepath(s) to watch for changes. Upon changes, the command will be rerun. */
-			watch?: string | string[];
-		};
-	};
-
-	/** Options applying to the worker's development preview environment. */
-	dev?: {
-		/** Options applying to the worker's inspector server. */
-		inspector?: { hostname?: string; port?: number; secure?: boolean };
-		/** Whether the worker runs on the edge or locally. */
-		remote?: boolean;
-		/** Cloudflare Account credentials. Can be provided upfront or as a function which will be called only when required. */
-		auth?: Hook<CfAccount>;
-		/** Whether local storage (KV, Durable Objects, R2, D1, etc) is persisted. You can also specify the directory to persist data to. */
-		persist?: boolean | { path: string };
-		/** Controls which logs are logged 🤙. */
-		logLevel?: LogLevel;
-		/** Whether the worker server restarts upon source/config file changes. */
-		watch?: boolean;
-		/** Whether a script tag is inserted on text/html responses which will reload the page upon file changes. Defaults to false. */
-		liveReload?: boolean;
-
-		/** The local address to reach your worker. Applies to remote: true (remote mode) and remote: false (local mode). */
-		server?: { hostname?: string; port?: number; secure?: boolean }; // hostname: --ip, port: --port, secure: --local-protocol
-		/** Controls what request.url looks like inside the worker. */
-		urlOverrides?: { hostname?: string; secure?: boolean }; // hostname: --host (remote)/--local-upstream (local), port: doesn't make sense in remote/=== server.port in local, secure: --upstream-protocol
-		/** A hook for outbound fetch calls from within the worker. */
-		outboundService?: ServiceFetch;
-		/** An undici MockAgent to declaratively mock fetch calls to particular resources. */
-		mockFetch?: undici.MockAgent;
-	};
-}
-
-export type Hook<T, Args extends unknown[] = unknown[]> =
-	| T
-	| Promise<T>
-	| ((...args: Args) => T | Promise<T>);
-
-export type LogLevel = "debug" | "info" | "log" | "warn" | "error" | "none";
-
-export type File<Contents = string> =
-	| { path: string } // `path` resolved relative to cwd
-	| { contents: Contents; path?: string }; // `contents` used instead, `path` can be specified if needed e.g. for module resolution
-export type BinaryFile = File<Uint8Array>; // Note: Node's `Buffer`s are instances of `Uint8Array`
-
-export interface Location {
-	hostname?: string;
-	port?: number;
-	secure?: boolean; // Usually `https`, but could be `wss` for inspector
-}
-
-export type PatternRoute = {
-	pattern: string;
-} & (
-	| { pattern: string; customDomain: true }
-	| { pattern: string; zoneId: string; customDomain?: true; zoneName?: never }
-	| { pattern: string; zoneName: string; customDomain?: true; zoneId?: never }
-);
-export type WorkersDevRoute = { workersDev: true };
-export type Route = PatternRoute | WorkersDevRoute;
-
-export interface ModuleRule {
-	type:
-		| "ESModule"
-		| "CommonJS"
-		| "NodeJSCompat"
-		| "CompiledWasm"
-		| "Text"
-		| "Data";
-	include?: string[];
-	fallthrough?: boolean;
-}
-
-export type Trigger =
-	| { type: "workers.dev" }
-	| { type: "route"; pattern: string; customDomain: true }
-	| {
-			type: "route";
-			pattern: string;
-			zoneId: string;
-			customDomain?: true;
-			zoneName?: never;
-	  }
-	| {
-			type: "route";
-			pattern: string;
-			zoneName: string;
-			customDomain?: true;
-			zoneId?: never;
-	  }
-	| { type: "schedule"; schedule: string }
-	| {
-			type: "queue-consumer";
-			name: string;
-			maxBatchSize?: number;
-			maxBatchTimeout?: number;
-			maxRetries?: string;
-			deadLetterQueue?: string;
-	  };
-
-export type Binding =
-	| { type: "kv"; id: string }
-	| { type: "r2"; bucket_name: string }
-	| {
-			type: "d1";
-			/** The binding name used to refer to the D1 database in the worker. */
-			binding: string;
-			/** The name of this D1 database. */
-			database_name: string;
-			/** The UUID of this D1 database (not required). */
-			database_id: string;
-			/** The UUID of this D1 database for Wrangler Dev (if specified). */
-			preview_database_id?: string;
-			/** The name of the migrations table for this D1 database (defaults to 'd1_migrations'). */
-			migrations_table?: string;
-			/** The path to the directory of migrations for this D1 database (defaults to './migrations'). */
-			migrations_dir?: string;
-			/** Internal use only. */
-			database_internal_env?: string;
-	  }
-	| {
-			type: "durable-object";
-			className: string;
-			service?: ServiceDesignator;
-	  }
-	| { type: "service"; service: ServiceDesignator | ServiceFetch }
-	| { type: "queue-producer"; name: string }
-	| { type: "constellation"; project_id: string }
-	| { type: "var"; value: string | Json | Uint8Array }
-	| { type: `unsafe-${string}`; [key: string]: unknown };
-
-export type ServiceFetch = (request: Request) => Promise<Response>;
-
-export interface ServiceDesignator {
-	name: string;
-	env?: string;
-}
diff --git a/packages/wrangler/src/api/startDevWorker/utils.ts b/packages/wrangler/src/api/startDevWorker/utils.ts
deleted file mode 100644
index 694f0405d310..000000000000
--- a/packages/wrangler/src/api/startDevWorker/utils.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import assert from "node:assert";
-
-export type MaybePromise<T> = T | Promise<T>;
-export type DeferredPromise<T> = {
-	promise: Promise<T>;
-	resolve: (_: MaybePromise<T>) => void;
-	reject: (_: Error) => void;
-};
-
-export function createDeferred<T>(
-	previousDeferred?: DeferredPromise<T>
-): DeferredPromise<T> {
-	let resolve, reject;
-	const newPromise = new Promise<T>((_resolve, _reject) => {
-		resolve = _resolve;
-		reject = _reject;
-	});
-	assert(resolve);
-	assert(reject);
-
-	// if passed a previousDeferred, ensure it is resolved with the newDeferred
-	// so that await-ers of previousDeferred are now await-ing newDeferred
-	previousDeferred?.resolve(newPromise);
-
-	return {
-		promise: newPromise,
-		resolve,
-		reject,
-	};
-}
-
-export function assertNever(_value: never) {}
-
-export function urlFromParts(
-	parts: Partial<URL>,
-	base = "http://localhost"
-): URL {
-	const url = new URL(base);
-
-	Object.assign(url, parts);
-
-	return url;
-}
diff --git a/packages/wrangler/src/cli.ts b/packages/wrangler/src/cli.ts
index 13b570855001..0c062f57ddd0 100644
--- a/packages/wrangler/src/cli.ts
+++ b/packages/wrangler/src/cli.ts
@@ -1,6 +1,6 @@
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { unstable_dev, unstable_pages, DevEnv as unstable_DevEnv } from "./api";
+import { unstable_dev, unstable_pages } from "./api";
 import { FatalError } from "./errors";
 import { main } from ".";
 
@@ -24,5 +24,5 @@ if (typeof jest === "undefined" && require.main === module) {
  * It makes it possible to import wrangler from 'wrangler',
  * and call wrangler.unstable_dev().
  */
-export { unstable_dev, unstable_pages, unstable_DevEnv };
+export { unstable_dev, unstable_pages };
 export type { UnstableDevWorker, UnstableDevOptions };
diff --git a/packages/wrangler/src/dev.tsx b/packages/wrangler/src/dev.tsx
index b64136ad4dca..868ea01858bc 100644
--- a/packages/wrangler/src/dev.tsx
+++ b/packages/wrangler/src/dev.tsx
@@ -26,7 +26,6 @@ import {
 	isLegacyEnv,
 	printWranglerBanner,
 } from "./index";
-import type { ProxyData } from "./api";
 import type { Config, Environment } from "./config";
 import type { Route, Rule } from "./config/environment";
 import type { CfWorkerInit, CfModule } from "./deployment-bundle/worker";
@@ -341,7 +340,7 @@ export type StartDevOptions = DevArguments &
 		forceLocal?: boolean;
 		disableDevRegistry?: boolean;
 		enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
-		onReady?: (ip: string, port: number, proxyData: ProxyData) => void;
+		onReady?: (ip: string, port: number) => void;
 		showInteractiveDevSession?: boolean;
 		updateCheck?: boolean;
 	};
diff --git a/packages/wrangler/src/dev/dev.tsx b/packages/wrangler/src/dev/dev.tsx
index 564cfcd0267e..dd725e636111 100644
--- a/packages/wrangler/src/dev/dev.tsx
+++ b/packages/wrangler/src/dev/dev.tsx
@@ -5,17 +5,10 @@ import { watch } from "chokidar";
 import clipboardy from "clipboardy";
 import commandExists from "command-exists";
 import { Box, Text, useApp, useInput, useStdin } from "ink";
-import React, {
-	useCallback,
-	useEffect,
-	useMemo,
-	useRef,
-	useState,
-} from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { useErrorHandler, withErrorBoundary } from "react-error-boundary";
 import onExit from "signal-exit";
 import { fetch } from "undici";
-import { DevEnv } from "../api";
 import { runCustomBuild } from "../deployment-bundle/run-custom-build";
 import {
 	getBoundRegisteredWorkers,
@@ -31,7 +24,6 @@ import { Local } from "./local";
 import { Remote } from "./remote";
 import { useEsbuild } from "./use-esbuild";
 import { validateDevProps } from "./validate-dev-props";
-import type { ProxyData, StartDevWorkerOptions } from "../api";
 import type { Config } from "../config";
 import type { Route } from "../config/environment";
 import type { Entry } from "../deployment-bundle/entry";
@@ -40,7 +32,6 @@ import type { WorkerRegistry } from "../dev-registry";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli/types";
 import type { EphemeralDirectory } from "../paths";
 import type { AssetPaths } from "../sites";
-import type { EsbuildBundle } from "./use-esbuild";
 
 /**
  * This hooks establishes a connection with the dev registry,
@@ -166,9 +157,7 @@ export type DevProps = {
 	host: string | undefined;
 	routes: Route[] | undefined;
 	inspect: boolean;
-	onReady:
-		| ((ip: string, port: number, proxyData: ProxyData) => void)
-		| undefined;
+	onReady: ((ip: string, port: number) => void) | undefined;
 	showInteractiveDevSession: boolean | undefined;
 	forceLocal: boolean | undefined;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
@@ -215,12 +204,12 @@ function InteractiveDevSession(props: DevProps) {
 
 	useTunnel(toggles.tunnel);
 
-	const onReady = (newIp: string, newPort: number, proxyData: ProxyData) => {
+	const onReady = (newIp: string, newPort: number) => {
 		if (newIp !== props.initialIp || newPort !== props.initialPort) {
 			ip = newIp;
 			port = newPort;
 			if (props.onReady) {
-				props.onReady(newIp, newPort, proxyData);
+				props.onReady(newIp, newPort);
 			}
 		}
 	};
@@ -258,60 +247,7 @@ type DevSessionProps = DevProps & {
 };
 
 function DevSession(props: DevSessionProps) {
-	const [devEnv] = useState(() => new DevEnv());
-	useEffect(() => {
-		return () => {
-			void devEnv.teardown();
-		};
-	}, [devEnv]);
-	const startDevWorkerOptions: StartDevWorkerOptions = useMemo(
-		() => ({
-			name: props.name ?? "worker",
-			script: { contents: "" },
-			dev: {
-				server: {
-					hostname: props.initialIp,
-					port: props.initialPort,
-					secure: props.localProtocol === "https",
-				},
-				inspector: {
-					port: props.inspectorPort,
-				},
-				urlOverrides: {
-					secure: props.localProtocol === "https",
-					hostname: props.localUpstream,
-				},
-				liveReload: props.liveReload,
-			},
-		}),
-		[
-			props.name,
-			props.initialIp,
-			props.initialPort,
-			props.localProtocol,
-			props.localUpstream,
-			props.inspectorPort,
-			props.liveReload,
-		]
-	);
-	const onBundleStart = useCallback(() => {
-		devEnv.proxy.onBundleStart({
-			type: "bundleStart",
-			config: startDevWorkerOptions,
-		});
-	}, [devEnv, startDevWorkerOptions]);
-	const onReloadStart = useCallback(
-		(bundle: EsbuildBundle) => {
-			devEnv.proxy.onReloadStart({
-				type: "reloadStart",
-				config: startDevWorkerOptions,
-				bundle,
-			});
-		},
-		[devEnv, startDevWorkerOptions]
-	);
-
-	useCustomBuild(props.entry, props.build, onBundleStart);
+	useCustomBuild(props.entry, props.build);
 
 	const directory = useTmpDir(props.projectRoot);
 
@@ -321,13 +257,6 @@ function DevSession(props: DevSessionProps) {
 		props.bindings.durable_objects,
 		props.local ? "local" : "remote"
 	);
-	useEffect(() => {
-		// temp: fake these events by calling the handler directly
-		devEnv.proxy.onConfigUpdate({
-			type: "configUpdate",
-			config: startDevWorkerOptions,
-		});
-	}, [devEnv, startDevWorkerOptions]);
 
 	const bundle = useEsbuild({
 		entry: props.entry,
@@ -357,11 +286,7 @@ function DevSession(props: DevSessionProps) {
 		testScheduled: props.testScheduled ?? false,
 		experimentalLocal: props.experimentalLocal,
 		projectRoot: props.projectRoot,
-		onBundleStart,
 	});
-	useEffect(() => {
-		if (bundle) onReloadStart(bundle);
-	}, [onReloadStart, bundle]);
 
 	// TODO(queues) support remote wrangler dev
 	if (
@@ -373,24 +298,7 @@ function DevSession(props: DevSessionProps) {
 		);
 	}
 
-	if (props.local && props.bindings.hyperdrive?.length) {
-		logger.warn(
-			"Hyperdrive does not currently support 'wrangler dev' in local mode at this stage of the beta. Use the '--remote' flag to test a Hyperdrive configuration before deploying."
-		);
-	}
-
-	const announceAndOnReady: typeof props.onReady = async (
-		finalIp,
-		finalPort,
-		proxyData
-	) => {
-		// at this point (in the layers of onReady callbacks), we have devEnv in scope
-		// so rewrite the onReady params to be the ip/port of the ProxyWorker instead of the UserWorker
-		const { proxyWorker } = await devEnv.proxy.ready.promise;
-		const url = await proxyWorker.ready;
-		finalIp = url.hostname;
-		finalPort = parseInt(url.port);
-
+	const announceAndOnReady: typeof props.onReady = (finalIp, finalPort) => {
 		if (process.send) {
 			process.send(
 				JSON.stringify({
@@ -401,17 +309,8 @@ function DevSession(props: DevSessionProps) {
 			);
 		}
 
-		if (bundle) {
-			devEnv.proxy.onReloadComplete({
-				type: "reloadComplete",
-				config: startDevWorkerOptions,
-				bundle,
-				proxyData,
-			});
-		}
-
 		if (props.onReady) {
-			props.onReady(finalIp, finalPort, proxyData);
+			props.onReady(finalIp, finalPort);
 		}
 	};
 
@@ -426,8 +325,8 @@ function DevSession(props: DevSessionProps) {
 			bindings={props.bindings}
 			workerDefinitions={workerDefinitions}
 			assetPaths={props.assetPaths}
-			initialPort={undefined} // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
-			initialIp={"127.0.0.1"} // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
+			initialPort={props.initialPort}
+			initialIp={props.initialIp}
 			rules={props.rules}
 			inspectorPort={props.inspectorPort}
 			runtimeInspectorPort={props.runtimeInspectorPort}
@@ -435,7 +334,7 @@ function DevSession(props: DevSessionProps) {
 			liveReload={props.liveReload}
 			crons={props.crons}
 			queueConsumers={props.queueConsumers}
-			localProtocol={"http"} // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
+			localProtocol={props.localProtocol}
 			localUpstream={props.localUpstream}
 			inspect={props.inspect}
 			onReady={announceAndOnReady}
@@ -493,11 +392,7 @@ function useTmpDir(projectRoot: string | undefined): string | undefined {
 	return directory;
 }
 
-function useCustomBuild(
-	expectedEntry: Entry,
-	build: Config["build"],
-	onBundleStart: () => void
-): void {
+function useCustomBuild(expectedEntry: Entry, build: Config["build"]): void {
 	useEffect(() => {
 		if (!build.command) return;
 		let watcher: ReturnType<typeof watch> | undefined;
@@ -510,7 +405,6 @@ function useCustomBuild(
 					path.relative(expectedEntry.directory, expectedEntry.file) || ".";
 				//TODO: we should buffer requests to the proxy until this completes
 				logger.log(`The file ${filePath} changed, restarting build...`);
-				onBundleStart();
 				runCustomBuild(expectedEntry.file, relativeFile, build).catch((err) => {
 					logger.error("Custom build failed:", err);
 				});
@@ -520,7 +414,7 @@ function useCustomBuild(
 		return () => {
 			void watcher?.close();
 		};
-	}, [build, expectedEntry, onBundleStart]);
+	}, [build, expectedEntry]);
 }
 
 function sleep(period: number) {
diff --git a/packages/wrangler/src/dev/inspect.ts b/packages/wrangler/src/dev/inspect.ts
index 605a12cf3042..5732b703c220 100644
--- a/packages/wrangler/src/dev/inspect.ts
+++ b/packages/wrangler/src/dev/inspect.ts
@@ -1,16 +1,617 @@
 import { readFileSync } from "fs";
+import assert from "node:assert";
+import crypto from "node:crypto";
+import { createServer } from "node:http";
 import os from "node:os";
-import { URL, fileURLToPath } from "node:url";
-import path from "path";
+import path from "node:path";
+import { URL, fileURLToPath, pathToFileURL } from "node:url";
 import open from "open";
-import {
-	isAllowedSourceMapPath,
-	isAllowedSourcePath,
-} from "../api/startDevWorker/bundle-allowed-paths";
+import { useEffect, useRef, useState } from "react";
+import WebSocket, { WebSocketServer } from "ws";
+import { version } from "../../package.json";
 import { logger } from "../logger";
-import type { EsbuildBundle } from "../dev/use-esbuild";
+import { getSourceMappedStack } from "../sourcemap";
+import { getAccessToken } from "../user/access";
+import { waitForPortToBeAvailable } from "./proxy";
+import type { SourceMapMetadata } from "../deployment-bundle/bundle";
 import type Protocol from "devtools-protocol";
+import type { IncomingMessage, Server, ServerResponse } from "node:http";
 import type { RawSourceMap } from "source-map";
+import type { MessageEvent } from "ws";
+
+/**
+ * `useInspector` is a hook for debugging Workers applications
+ *  when using `wrangler dev`.
+ *
+ * When we start a session with `wrangler dev`, the Workers platform
+ * also exposes a debugging websocket that implements the DevTools
+ * Protocol. While we could just start up DevTools and connect to this
+ * URL, that URL changes every time we make a change to the
+ * worker, or when the session expires. Instead, we start up a proxy
+ * server locally that acts as a bridge between the remote DevTools
+ * server and the local DevTools instance. So whenever the URL changes,
+ * we can can silently connect to it and keep the local DevTools instance
+ * up to date. Further, we also intercept these messages and selectively
+ * log them directly to the terminal (namely, calls to `console.<x>`,
+ * and exceptions)
+ */
+
+// TODO:
+// - clear devtools whenever we save changes to the worker
+// - clear devtools when we switch between local/remote modes
+// - handle more methods from console
+
+interface InspectorProps {
+	/**
+	 * The port that the local proxy server should listen on.
+	 */
+	port: number;
+	/**
+	 * The websocket URL exposed by Workers that the inspector should connect to.
+	 */
+	inspectorUrl: string | undefined;
+	/**
+	 * Whether console statements and exceptions should be logged to the terminal.
+	 * (We don't log them in local mode because they're already getting
+	 * logged to the terminal by nature of them actually running in node locally.)
+	 */
+	logToTerminal: boolean;
+	/**
+	 * Sourcemap path, so that stacktraces can be interpretted
+	 */
+	sourceMapPath: string | undefined;
+
+	sourceMapMetadata: SourceMapMetadata | undefined;
+
+	host?: string;
+
+	name?: string;
+}
+
+type LocalWebSocket = WebSocket & { isDevTools?: boolean };
+
+export default function useInspector(props: InspectorProps) {
+	/** A unique ID for this session. */
+	const inspectorIdRef = useRef(crypto.randomUUID());
+
+	/** The websocket from the devtools instance. */
+	const [localWebSocket, setLocalWebSocket] = useState<LocalWebSocket>();
+	/**  The websocket from the edge */
+	const [remoteWebSocket, setRemoteWebSocket] = useState<WebSocket>();
+
+	/**
+	 * Source maps included in `Debugger.scriptParsed` events sent by the current
+	 * `remoteWebSocket`. Each source map is given a unique ID which must be
+	 * included when fetching the source map to prevent arbitrary file access.
+	 * We assume each `Debugger.scriptParsed` event will trigger a single fetch
+	 * for the corresponding source map, so remove source maps after they've been
+	 * fetched once.
+	 */
+	const sourceMaps = useRef<Map<string /* id */, string /* filePath */>>();
+	sourceMaps.current ??= new Map();
+	/**
+	 * For source maps without `sourcesContent`, DevTools will request the
+	 * contents of source files too. Again, we'd like to prevent arbitrary file
+	 * access here, so only allow fetching sources if we've seen the path
+	 * when responding with a source map. We again assume each source will be
+	 * fetched once, so remove allowed sources after fetch.
+	 */
+	const allowedSourcePaths = useRef<Set<string /* filePath */>>();
+	allowedSourcePaths.current ??= new Set();
+
+	/**
+	 *  The local proxy server that acts as the bridge between
+	 *  the remote websocket and the local DevTools instance.
+	 */
+	const serverRef = useRef<Server>();
+	if (serverRef.current === undefined) {
+		serverRef.current = createServer(
+			(req: IncomingMessage, res: ServerResponse) => {
+				switch (req.url) {
+					// We implement a couple of well known end points
+					// that are queried for metadata by chrome://inspect
+					case "/json/version":
+						res.setHeader("Content-Type", "application/json");
+						res.end(
+							JSON.stringify({
+								Browser: `wrangler/v${version}`,
+								// TODO: (someday): The DevTools protocol should match that of Edge Worker.
+								// This could be exposed by the preview API.
+								"Protocol-Version": "1.3",
+							})
+						);
+						return;
+					case "/json":
+					case "/json/list":
+						{
+							res.setHeader("Content-Type", "application/json");
+							const localHost = `127.0.0.1:${props.port}/ws`;
+							const devtoolsFrontendUrl = `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${localHost}`;
+							const devtoolsFrontendUrlCompat = `devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=${localHost}`;
+							res.end(
+								JSON.stringify([
+									{
+										id: inspectorIdRef.current,
+										type: "node",
+										description: "workers",
+										webSocketDebuggerUrl: `ws://${localHost}`,
+										devtoolsFrontendUrl,
+										devtoolsFrontendUrlCompat,
+										// Below are fields that are visible in the DevTools UI.
+										title: "Cloudflare Worker",
+										faviconUrl: "https://workers.cloudflare.com/favicon.ico",
+										url:
+											"https://" +
+											(remoteWebSocket
+												? new URL(remoteWebSocket.url).host
+												: "workers.dev"),
+									},
+								])
+							);
+						}
+						return;
+					default:
+						break;
+				}
+			}
+		);
+	}
+	const server = serverRef.current;
+
+	/**
+	 * The websocket server that runs on top of the proxy server.
+	 */
+	const wsServerRef = useRef<WebSocketServer>();
+	if (wsServerRef.current === undefined) {
+		wsServerRef.current = new WebSocketServer({
+			server,
+			clientTracking: true,
+		});
+	}
+	const wsServer = wsServerRef.current;
+
+	wsServer.on("connection", (ws, req) => {
+		if (wsServer.clients.size > 1) {
+			/** We only want to have one active Devtools instance at a time. */
+			logger.error(
+				"Tried to open a new devtools window when a previous one was already open."
+			);
+			ws.close(1013, "Too many clients; only one can be connected at a time");
+		} else {
+			// Since Wrangler proxies the inspector, reloading Chrome DevTools won't trigger debugger initialisation events (because it's connecting to an extant session).
+			// This sends a `Debugger.disable` message to the remote when a new WebSocket connection is initialised,
+			// with the assumption that the new connection will shortly send a `Debugger.enable` event and trigger re-initialisation.
+			// The key initialisation messages that are needed are the `Debugger.scriptParsed events`.
+			remoteWebSocket?.send(
+				JSON.stringify({
+					// This number is arbitrary, and is chosen to be high so as not to conflict with messages that DevTools might actually send.
+					// For completeness, these options don't work: 0, -1, or Number.MAX_SAFE_INTEGER
+					id: 100_000_000,
+					method: "Debugger.disable",
+				})
+			);
+
+			// Our patched DevTools are hosted on a `https://` URL. These cannot
+			// access `file://` URLs, meaning local source maps cannot be fetched.
+			// To get around this, we can rewrite `Debugger.scriptParsed` events to
+			// include a special `worker:` scheme for source maps, and respond to
+			// `Network.loadNetworkResource` commands for these. Unfortunately, this
+			// breaks IDE's built-in debuggers (e.g. VSCode and WebStorm), so we only
+			// want to enable this transformation when we detect hosted DevTools has
+			// connected. We do this by looking at the WebSocket handshake headers:
+			//
+			// # DevTools
+			//
+			// Upgrade: websocket
+			// Host: localhost:9229
+			// (from Chrome)  User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36
+			// (from Firefox) User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/116.0
+			// Origin: https://devtools.devprod.cloudflare.dev
+			// ...
+			//
+			// # VSCode
+			//
+			// Upgrade: websocket
+			// Host: localhost
+			// ...
+			//
+			// # WebStorm
+			//
+			// Upgrade: websocket
+			// Host: localhost:9229
+			// Origin: http://localhost:9229
+			// ...
+			//
+			// From this, we could just use the presence of a `User-Agent` header to
+			// determine if DevTools connected, but VSCode/WebStorm could very well
+			// add this in future versions. We could also look for an `Origin` header
+			// matching the hosted DevTools URL, but this would prevent preview/local
+			// versions working. Instead, we look for a browser-like `User-Agent`.
+			const localWs: LocalWebSocket = ws;
+			localWs.isDevTools = /mozilla/i.test(req.headers["user-agent"] ?? "");
+
+			// As promised, save the created websocket in a state hook
+			setLocalWebSocket(localWs);
+
+			ws.addEventListener("close", () => {
+				// And cleanup when devtools closes
+				setLocalWebSocket(undefined);
+			});
+		}
+	});
+
+	/**
+	 * We start and stop the server in an effect to take advantage
+	 * of the component lifecycle. Convenient.
+	 */
+	useEffect(() => {
+		const abortController = new AbortController();
+		async function startInspectorProxy() {
+			await waitForPortToBeAvailable(props.port, {
+				retryPeriod: 200,
+				timeout: 2000,
+				abortSignal: abortController.signal,
+			});
+			server.listen(props.port, "127.0.0.1");
+		}
+		startInspectorProxy().catch((err) => {
+			if ((err as { code: string }).code !== "ABORT_ERR") {
+				logger.error("Failed to start inspector:", err);
+			}
+		});
+		return () => {
+			server.close();
+			// Also disconnect any open websockets/devtools connections
+			wsServer.clients.forEach((ws) => ws.close());
+			wsServer.close();
+			abortController.abort();
+		};
+	}, [props.port, server, wsServer]);
+
+	/**
+	 * When connecting to the remote websocket, if we don't start either
+	 * the devtools instance or make an actual request to the worker in time,
+	 * then the connecting process can error out. When this happens, we
+	 * want to simply retry the connection. We use a state hook to trigger retries
+	 * of the effect that connects to the remote websocket.
+	 */
+	const [
+		retryRemoteWebSocketConnectionSigil,
+		setRetryRemoteWebSocketConnectionSigil,
+	] = useState<number>(0);
+	function retryRemoteWebSocketConnection() {
+		setRetryRemoteWebSocketConnectionSigil((x) => x + 1);
+	}
+
+	/** A simple incrementing id to attach to messages we send to devtools */
+	const messageCounterRef = useRef(1);
+
+	const cfAccessRef = useRef<string>();
+
+	useEffect(() => {
+		const run = async () => {
+			if (props.host && !cfAccessRef.current) {
+				const token = await getAccessToken(props.host);
+				cfAccessRef.current = token;
+			}
+		};
+		if (props.host) void run();
+	}, [props.host]);
+
+	// This effect tracks the connection to the remote websocket
+	// (stored in, no surprises here, `remoteWebSocket`)
+	useEffect(() => {
+		if (!props.inspectorUrl) {
+			return;
+		}
+
+		// The actual websocket instance
+		const ws = new WebSocket(props.inspectorUrl, {
+			headers: {
+				cookie: `CF_Authorization=${cfAccessRef.current}`,
+			},
+		});
+		setRemoteWebSocket(ws);
+
+		/**
+		 * A handle to the interval we run to keep the websocket alive
+		 */
+		let keepAliveInterval: NodeJS.Timer;
+
+		/**
+		 * Test if the websocket is closed
+		 */
+		function isClosed() {
+			return (
+				ws.readyState === WebSocket.CLOSED ||
+				ws.readyState === WebSocket.CLOSING
+			);
+		}
+
+		/**
+		 * Send a message to the remote websocket
+		 */
+		function send(event: Record<string, unknown>): void {
+			if (!isClosed()) {
+				ws.send(JSON.stringify(event));
+			}
+		}
+
+		/**
+		 * Closes the inspector.
+		 */
+		function close(): void {
+			if (!isClosed()) {
+				send({
+					method: "Runtime.discardConsoleEntries",
+					id: messageCounterRef.current++,
+				});
+				try {
+					ws.close();
+				} catch (err) {
+					// Closing before the websocket is ready will throw an error.
+				}
+			}
+		}
+
+		/**
+		 * Since we have a handle on the remote websocket, we can tap
+		 * into its events, and log any pertinent ones directly to
+		 * the terminal (which means you have insight into your worker
+		 * without having to open the devtools).
+		 */
+		if (props.logToTerminal) {
+			ws.addEventListener("message", async (event: MessageEvent) => {
+				if (typeof event.data === "string") {
+					const evt = JSON.parse(event.data);
+					if (evt.method === "Runtime.exceptionThrown") {
+						const params = evt.params as Protocol.Runtime.ExceptionThrownEvent;
+						const stack = getSourceMappedStack(params.exceptionDetails);
+						logger.error(params.exceptionDetails.text, stack);
+					}
+					if (evt.method === "Runtime.consoleAPICalled") {
+						logConsoleMessage(
+							evt.params as Protocol.Runtime.ConsoleAPICalledEvent
+						);
+					}
+				} else {
+					// We should never get here, but who know is 2022...
+					logger.error("Unrecognised devtools event:", event);
+				}
+			});
+		}
+
+		ws.addEventListener("open", () => {
+			send({ method: "Runtime.enable", id: messageCounterRef.current++ });
+			// TODO: This doesn't actually work. Must fix.
+			send({ method: "Network.enable", id: messageCounterRef.current++ });
+
+			keepAliveInterval = setInterval(() => {
+				send({
+					method: "Runtime.getIsolateId",
+					id: messageCounterRef.current++,
+				});
+			}, 10_000);
+		});
+
+		ws.on("unexpected-response", () => {
+			logger.log("Waiting for connection...");
+			/**
+			 * This usually means the worker is not "ready" yet
+			 * so we'll just retry the connection process
+			 */
+			retryRemoteWebSocketConnection();
+		});
+
+		ws.addEventListener("close", () => {
+			clearInterval(keepAliveInterval);
+		});
+
+		return () => {
+			// clean up! Let's first stop the heartbeat interval
+			clearInterval(keepAliveInterval);
+			// Then we'll send a message to the devtools instance to
+			// tell it to clear the console.
+			wsServer.clients.forEach((client) => {
+				// We could've used `localSocket` here, but
+				// then we would have had to add it to the effect
+				// change detection array, which would have made a
+				// bunch of other stuff complicated. So we'll just
+				// cycle through all of the server's connected clients
+				// (in practice, there should only be one or zero) and send
+				// the Log.clear message.
+				client.send(
+					JSON.stringify({
+						// TODO: This doesn't actually work. Must fix.
+						method: "Log.clear",
+						// we can disable the next eslint warning since
+						// we're referencing a ref that stays alive
+						// eslint-disable-next-line react-hooks/exhaustive-deps
+						id: messageCounterRef.current++,
+						params: {},
+					})
+				);
+			});
+			// Finally, we'll close the websocket
+			close();
+			// And we'll clear `remoteWebsocket`
+			setRemoteWebSocket(undefined);
+		};
+	}, [
+		props.inspectorUrl,
+		props.logToTerminal,
+		props.sourceMapPath,
+		wsServer,
+		// We use a state value as a sigil to trigger a retry of the
+		// remote websocket connection. It's not used inside the effect,
+		// so react-hooks/exhaustive-deps doesn't complain if it's not
+		// included in the dependency array. But its presence is critical,
+		// so do NOT remove it from the dependency list.
+		retryRemoteWebSocketConnectionSigil,
+	]);
+
+	/**
+	 * We want to make sure we don't lose any messages we receive from the
+	 * remote websocket before devtools connects. So we use a ref to buffer
+	 * messages, and flush them whenever devtools connects.
+	 */
+	const messageBufferRef = useRef<MessageEvent[]>([]);
+
+	// This effect tracks the state changes _between_ the local
+	// and remote websockets, and handles how messages flow between them.
+	useEffect(() => {
+		/**
+		 * This event listener is used for buffering messages from
+		 * the remote websocket, and flushing them
+		 * when the local websocket connects.
+		 */
+		function bufferMessageFromRemoteSocket(event: MessageEvent) {
+			messageBufferRef.current.push(event);
+			// TODO: maybe we should have a max limit on this?
+			// if so, we should be careful when removing messages
+			// from the front, because they could be critical for
+			// devtools (like execution context creation, etc)
+		}
+
+		if (remoteWebSocket && !localWebSocket) {
+			// The local websocket hasn't connected yet, so we'll
+			// buffer messages until it does.
+			remoteWebSocket.addEventListener(
+				"message",
+				bufferMessageFromRemoteSocket
+			);
+		}
+
+		/** Send a message from the local websocket to the remote websocket */
+		function sendMessageToRemoteWebSocket(event: MessageEvent) {
+			try {
+				// Intercept Network.loadNetworkResource to load sourcemaps
+				const message = JSON.parse(event.data as string);
+				if (message.method === "Network.loadNetworkResource") {
+					// `sourceMaps.current` and `allowSourcePaths.current` are always
+					// defined after `useRef()`
+					assert(sourceMaps.current !== undefined);
+					assert(allowedSourcePaths.current !== undefined);
+					const maybeText = maybeHandleNetworkLoadResource(
+						message.params.url,
+						sourceMaps.current,
+						allowedSourcePaths.current,
+						props.sourceMapMetadata?.tmpDir
+					);
+					if (maybeText !== undefined) {
+						sendMessageToLocalWebSocket({
+							data: JSON.stringify({
+								id: message.id,
+								result: { resource: { success: true, text: maybeText } },
+							}),
+						});
+						return;
+					}
+				}
+			} catch (e) {
+				logger.debug(e);
+				// Ignore errors, fallthrough to the remote inspector
+			}
+			try {
+				assert(
+					remoteWebSocket,
+					"Trying to send a message to an undefined `remoteWebSocket`"
+				);
+				remoteWebSocket.send(event.data);
+			} catch (e) {
+				if (
+					(e as Error).message !==
+					"WebSocket is not open: readyState 0 (CONNECTING)"
+				) {
+					/**
+					 * ^ this just means we haven't opened a websocket yet
+					 * usually happens until there's at least one request
+					 * which is weird, because we may miss something that
+					 * happens on the first request. Maybe we should buffer
+					 * these messages too?
+					 */
+					logger.error(e);
+				}
+			}
+		}
+
+		/** Send a message from the local websocket to the remote websocket */
+		function sendMessageToLocalWebSocket(event: Pick<MessageEvent, "data">) {
+			assert(
+				localWebSocket,
+				"Trying to send a message to an undefined `localWebSocket`"
+			);
+			try {
+				// Intercept Debugger.scriptParsed responses to inject URL schemes
+				if (localWebSocket.isDevTools) {
+					const message = JSON.parse(event.data as string);
+					if (message.method === "Debugger.scriptParsed") {
+						if (message.params.sourceMapURL) {
+							const url = new URL(
+								message.params.sourceMapURL,
+								message.params.url
+							);
+							if (url.protocol === "file:") {
+								// `sourceMaps.current` is always defined after `useRef()`
+								assert(sourceMaps.current !== undefined);
+								const name = props.name ?? "worker";
+								const id = crypto.randomUUID();
+								sourceMaps.current.set(id, fileURLToPath(url));
+								// The hostname of this URL will show up next to the cloud icon
+								// under authored sources, so use the worker name.
+								message.params.sourceMapURL = `worker://${name}/${id}`;
+								localWebSocket.send(JSON.stringify(message));
+								return;
+							}
+						}
+					}
+				}
+			} catch (e) {
+				logger.debug(e);
+				// Ignore errors, fallthrough to the local websocket
+			}
+
+			localWebSocket.send(event.data);
+		}
+
+		if (localWebSocket && remoteWebSocket) {
+			// Both the remote and local websockets are connected, so let's
+			// start sending messages between them.
+			localWebSocket.addEventListener("message", sendMessageToRemoteWebSocket);
+			remoteWebSocket.addEventListener("message", sendMessageToLocalWebSocket);
+
+			// Also, let's flush any buffered messages
+			messageBufferRef.current.forEach(sendMessageToLocalWebSocket);
+			messageBufferRef.current = [];
+		}
+
+		return () => {
+			// Cleanup like good citizens
+			if (remoteWebSocket) {
+				remoteWebSocket.removeEventListener(
+					"message",
+					bufferMessageFromRemoteSocket
+				);
+				remoteWebSocket.removeEventListener(
+					"message",
+					sendMessageToLocalWebSocket
+				);
+			}
+			if (localWebSocket) {
+				localWebSocket.removeEventListener(
+					"message",
+					sendMessageToRemoteWebSocket
+				);
+			}
+		};
+	}, [
+		localWebSocket,
+		remoteWebSocket,
+		props.name,
+		props.sourceMapMetadata,
+		props.sourceMapPath,
+	]);
+}
 
 /**
  * This function converts a message serialized as a devtools event
@@ -45,9 +646,7 @@ const mapConsoleAPIMessageTypeToConsoleMethod: {
 	endGroup: "groupEnd",
 };
 
-export function logConsoleMessage(
-	evt: Protocol.Runtime.ConsoleAPICalledEvent
-): void {
+function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
 	const args: string[] = [];
 	for (const ro of evt.args) {
 		switch (ro.type) {
@@ -187,20 +786,28 @@ export function logConsoleMessage(
 	}
 }
 
-export function maybeHandleNetworkLoadResource(
+function maybeHandleNetworkLoadResource(
 	url: string | URL,
-	bundle: EsbuildBundle,
+	sourceMaps: Map<string /* id */, string /* filePath */>,
+	allowedSourcePaths: Set<string /* filePath */>,
 	tmpDir?: string
 ): string | undefined {
 	if (typeof url === "string") url = new URL(url);
-	if (url.protocol !== "file:") return;
-	const filePath = fileURLToPath(url);
+	if (url.protocol !== "worker:") return;
+
+	// Check whether we have a source map matching this ID...
+	const id = url.pathname.substring(1);
+	const maybeSourceMapFilePath = sourceMaps.get(id);
+	if (maybeSourceMapFilePath !== undefined) {
+		// Assume DevTools fetches each source map once (after receipt of the
+		// `Debugger.scriptParsed` event), and remove it from the map to prevent
+		// unbounded growth.
+		sourceMaps.delete(id);
 
-	if (isAllowedSourceMapPath(bundle, filePath)) {
 		// Read and parse the source map
 		const sourceMap: RawSourceMap & {
 			x_google_ignoreList?: number[];
-		} = JSON.parse(readFileSync(filePath, "utf-8"));
+		} = JSON.parse(readFileSync(maybeSourceMapFilePath, "utf-8"));
 
 		// See https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.mt2g20loc2ct
 		// The above link documents the `x_google_ignoreList property`, which is
@@ -220,10 +827,28 @@ export function maybeHandleNetworkLoadResource(
 			})
 			.filter((i): i is number => i !== undefined);
 
+		// If this source map doesn't have inline sources, DevTools will attempt to
+		// make requests for them, so add all sources paths in this map to the
+		// allowed set.
+		if (!sourceMap.sourcesContent) {
+			const fileURL = pathToFileURL(maybeSourceMapFilePath);
+			for (const source of sourceMap.sources) {
+				const sourcePath = fileURLToPath(new URL(source, fileURL));
+				allowedSourcePaths.add(sourcePath);
+			}
+		}
+
 		return JSON.stringify(sourceMap);
 	}
 
-	if (isAllowedSourcePath(bundle, filePath)) {
+	// Otherwise, assume this is a request for a source file. Resolve the ID
+	// relative to the current working directory, and check if this is allowed.
+	const filePath = path.resolve(id);
+	if (allowedSourcePaths.has(filePath)) {
+		// Assume DevTools fetches each source once (after receipt of the
+		// `Network.loadNetworkResource` command response for the source map), and
+		// remove it from the set to prevent unbounded growth.
+		allowedSourcePaths.delete(filePath);
 		return readFileSync(filePath, "utf-8");
 	}
 }
diff --git a/packages/wrangler/src/dev/local.tsx b/packages/wrangler/src/dev/local.tsx
index 803c8bc55c23..73f1d95bb70c 100644
--- a/packages/wrangler/src/dev/local.tsx
+++ b/packages/wrangler/src/dev/local.tsx
@@ -1,12 +1,12 @@
 import assert from "node:assert";
 import chalk from "chalk";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 import onExit from "signal-exit";
+import { fetch } from "undici";
 import { registerWorker } from "../dev-registry";
 import { logger } from "../logger";
+import useInspector from "./inspect";
 import { MiniflareServer } from "./miniflare";
-import { DEFAULT_WORKER_NAME } from "./miniflare";
-import type { ProxyData } from "../api";
 import type { Config } from "../config";
 import type { CfWorkerInit, CfScriptFormat } from "../deployment-bundle/worker";
 import type { WorkerRegistry } from "../dev-registry";
@@ -25,7 +25,7 @@ export interface LocalProps {
 	bindings: CfWorkerInit["bindings"];
 	workerDefinitions: WorkerRegistry | undefined;
 	assetPaths: AssetPaths | undefined;
-	initialPort: number | undefined;
+	initialPort: number;
 	initialIp: string;
 	rules: Config["rules"];
 	inspectorPort: number;
@@ -37,9 +37,7 @@ export interface LocalProps {
 	localProtocol: "http" | "https";
 	localUpstream: string | undefined;
 	inspect: boolean;
-	onReady:
-		| ((ip: string, port: number, proxyData: ProxyData) => void)
-		| undefined;
+	onReady: ((ip: string, port: number) => void) | undefined;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
 	testScheduled?: boolean;
 	sourceMapPath: string | undefined;
@@ -117,15 +115,36 @@ export function maybeRegisterLocalWorker(event: ReloadedEvent, name?: string) {
 	});
 }
 
-export function Local(props: LocalProps) {
-	useLocalWorker(props);
+// https://chromedevtools.github.io/devtools-protocol/#endpoints
+interface InspectorWebSocketTarget {
+	id: string;
+	title: string;
+	type: "node";
+	description: string;
+	webSocketDebuggerUrl: string;
+	devtoolsFrontendUrl: string;
+	devtoolsFrontendUrlCompat: string;
+	faviconUrl: string;
+	url: string;
+}
 
+export function Local(props: LocalProps) {
+	const { inspectorUrl } = useLocalWorker(props);
+	useInspector({
+		inspectorUrl,
+		port: props.inspectorPort,
+		logToTerminal: props.bundle?.entry.format === "service-worker",
+		sourceMapPath: props.sourceMapPath,
+		name: props.name,
+		sourceMapMetadata: props.bundle?.sourceMapMetadata,
+	});
 	return null;
 }
 
 function useLocalWorker(props: LocalProps) {
 	const miniflareServerRef = useRef<MiniflareServer>();
 	const removeMiniflareServerExitListenerRef = useRef<() => void>();
+	const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
 
 	useEffect(() => {
 		if (props.bindings.services && props.bindings.services.length > 0) {
@@ -158,36 +177,33 @@ function useLocalWorker(props: LocalProps) {
 			miniflareServerRef.current = server = newServer;
 			server.addEventListener("reloaded", async (event) => {
 				await maybeRegisterLocalWorker(event, props.name);
+				props.onReady?.(event.url.hostname, parseInt(event.url.port));
 
-				const proxyData: ProxyData = {
-					userWorkerUrl: {
-						protocol: event.url.protocol,
-						hostname: event.url.hostname,
-						port: event.url.port,
-					},
-					userWorkerInspectorUrl: {
-						protocol: "ws:",
-						hostname: "127.0.0.1",
-						port: props.runtimeInspectorPort.toString(),
-						pathname: `/core:user:${props.name ?? DEFAULT_WORKER_NAME}`,
-					},
-					userWorkerInnerUrlOverrides: {
-						protocol: props.localProtocol,
-						hostname: props.localUpstream,
-						port: props.localUpstream ? "" : undefined, // `localUpstream` was essentially `host`, not `hostname`, so if it was set delete the `port`
-					},
-					headers: {}, // no headers needed in local-mode
-					liveReload: props.liveReload,
-					// in local mode, the logs are already being printed to the console by workerd but only for workers written in "module" format
-					// workers written in "service-worker" format still need to proxy logs to the ProxyController
-					proxyLogsToController: props.format === "service-worker",
-				};
-
-				props.onReady?.(
-					event.url.hostname,
-					parseInt(event.url.port),
-					proxyData
-				);
+				try {
+					// Fetch the inspector JSON response from the DevTools Inspector protocol
+					const jsonUrl = `http://127.0.0.1:${props.runtimeInspectorPort}/json`;
+					const res = await fetch(jsonUrl);
+					const body = (await res.json()) as InspectorWebSocketTarget[];
+					const debuggerUrl = body?.find(({ id }) =>
+						id.startsWith("core:user")
+					)?.webSocketDebuggerUrl;
+					if (debuggerUrl === undefined) {
+						setInspectorUrl(undefined);
+					} else {
+						const url = new URL(debuggerUrl);
+						// Force inspector URL to be different on each reload so `useEffect`
+						// in `useInspector` is re-run to connect to newly restarted
+						// `workerd` server when updating options. Can't use a query param
+						// here as that seems to cause an infinite connection loop, can't
+						// use a hash as those are forbidden by `ws`, so username it is.
+						url.username = `${Date.now()}-${Math.floor(
+							Math.random() * Number.MAX_SAFE_INTEGER
+						)}`;
+						setInspectorUrl(url.toString());
+					}
+				} catch (error: unknown) {
+					logger.error("Error attempting to retrieve debugger URL:", error);
+				}
 			});
 			server.addEventListener("error", ({ error }) => {
 				if (
@@ -238,4 +254,6 @@ function useLocalWorker(props: LocalProps) {
 		},
 		[]
 	);
+
+	return { inspectorUrl };
 }
diff --git a/packages/wrangler/src/dev/miniflare.ts b/packages/wrangler/src/dev/miniflare.ts
index 8924ed51e6e6..1c27f24412a9 100644
--- a/packages/wrangler/src/dev/miniflare.ts
+++ b/packages/wrangler/src/dev/miniflare.ts
@@ -1,7 +1,14 @@
 import assert from "node:assert";
 import { realpathSync } from "node:fs";
 import path from "node:path";
-import { Log, LogLevel, TypedEventTarget, Mutex, Miniflare } from "miniflare";
+import {
+	Log,
+	LogLevel,
+	NoOpLog,
+	TypedEventTarget,
+	Mutex,
+	Miniflare,
+} from "miniflare";
 import { ModuleTypeToRuleType } from "../deployment-bundle/module-collection";
 import { withSourceURLs } from "../deployment-bundle/source-url";
 import { getHttpsOptions } from "../https-options";
@@ -82,11 +89,6 @@ export default {
 }
 `;
 
-type SpecificPort = Exclude<number, 0>;
-type RandomConsistentPort = 0; // random port, but consistent across reloads
-type RandomDifferentPort = undefined; // random port, but different across reloads
-type Port = SpecificPort | RandomConsistentPort | RandomDifferentPort;
-
 export interface ConfigBundle {
 	// TODO(soon): maybe rename some of these options, check proposed API Google Docs
 	name: string | undefined;
@@ -98,7 +100,7 @@ export interface ConfigBundle {
 	bindings: CfWorkerInit["bindings"];
 	workerDefinitions: WorkerRegistry | undefined;
 	assetPaths: AssetPaths | undefined;
-	initialPort: Port;
+	initialPort: number;
 	initialIp: string;
 	rules: Config["rules"];
 	inspectorPort: number;
@@ -112,13 +114,13 @@ export interface ConfigBundle {
 	serviceBindings: Record<string, (_request: Request) => Promise<Response>>;
 }
 
-export class WranglerLog extends Log {
+class WranglerLog extends Log {
 	#warnedCompatibilityDateFallback = false;
 
-	log(message: string) {
+	info(message: string) {
 		// Hide request logs for external Durable Objects proxy worker
 		if (message.includes(EXTERNAL_DURABLE_OBJECTS_WORKER_NAME)) return;
-		super.log(message);
+		super.info(message);
 	}
 
 	warn(message: string) {
@@ -141,31 +143,19 @@ export class WranglerLog extends Log {
 	}
 }
 
-export const DEFAULT_WORKER_NAME = "worker";
 function getName(config: ConfigBundle) {
-	return config.name ?? DEFAULT_WORKER_NAME;
+	return config.name ?? "worker";
 }
 const IDENTIFIER_UNSAFE_REGEXP = /[^a-zA-Z0-9_$]/g;
 function getIdentifier(name: string) {
 	return name.replace(IDENTIFIER_UNSAFE_REGEXP, "_");
 }
 
-export function castLogLevel(level: LoggerLevel): LogLevel {
-	let key = level.toUpperCase() as Uppercase<LoggerLevel>;
-	if (key === "LOG") key = "INFO";
-
-	return LogLevel[key];
-}
-
 function buildLog(): Log {
-	let level = castLogLevel(logger.loggerLevel);
-
-	// if we're in DEBUG or VERBOSE mode, clamp logLevel to WARN -- ie. don't show request logs for user worker
-	if (level <= LogLevel.DEBUG) {
-		level = Math.min(level, LogLevel.WARN);
-	}
-
-	return new WranglerLog(level, { prefix: "wrangler-UserWorker" });
+	let level = logger.loggerLevel.toUpperCase() as Uppercase<LoggerLevel>;
+	if (level === "LOG") level = "INFO";
+	const logLevel = LogLevel[level];
+	return logLevel === LogLevel.NONE ? new NoOpLog() : new WranglerLog(logLevel);
 }
 
 async function buildSourceOptions(
@@ -399,7 +389,7 @@ function buildSitesOptions({ assetPaths }: ConfigBundle) {
 	}
 }
 
-export function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
+function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 	// ASSUMPTION: each chunk is a whole message from workerd
 	// This may not hold across OSes/architectures, but it seems to work on macOS M-line
 	// I'm going with this simple approach to avoid complicating this too early
@@ -410,10 +400,7 @@ export function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 			const containsLlvmSymbolizerWarning = chunk.includes(
 				"Not symbolizing stack traces because $LLVM_SYMBOLIZER is not set"
 			);
-			// Matches stack traces from workerd
-			//  - on unix: groups of 9 hex digits separated by spaces
-			//  - on windows: groups of 12 hex digits, or a single digit 0, separated by spaces
-			const containsHexStack = /stack:( (0|[a-f\d]{4,})){3,}/.test(chunk);
+			const containsHexStack = /stack:( [a-f\d]{9}){3,}/.test(chunk);
 
 			return containsLlvmSymbolizerWarning || containsHexStack;
 		},
@@ -421,9 +408,6 @@ export function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 		isAddressInUse(chunk: string) {
 			return chunk.includes("Address already in use; toString() = ");
 		},
-		isWarning(chunk: string) {
-			return /\.c\+\+:\d+: warning:/.test(chunk);
-		},
 	};
 
 	stdout.on("data", (chunk: Buffer | string) => {
@@ -443,11 +427,6 @@ export function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 			logger.debug(chunk);
 		}
 
-		// known case: warnings are not info, log them as such
-		else if (classifiers.isWarning(chunk)) {
-			logger.warn(chunk);
-		}
-
 		// anything not exlicitly handled above should be logged as info (via stdout)
 		else {
 			logger.info(chunk);
@@ -482,11 +461,6 @@ export function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 			logger.debug(chunk);
 		}
 
-		// known case: warnings are not errors, log them as such
-		else if (classifiers.isWarning(chunk)) {
-			logger.warn(chunk);
-		}
-
 		// anything not exlicitly handled above should be logged as an error (via stderr)
 		else {
 			logger.error(chunk);
diff --git a/packages/wrangler/src/dev/remote.tsx b/packages/wrangler/src/dev/remote.tsx
index 709ded5f0209..5961ee534c73 100644
--- a/packages/wrangler/src/dev/remote.tsx
+++ b/packages/wrangler/src/dev/remote.tsx
@@ -14,13 +14,12 @@ import {
 	requireApiToken,
 	saveAccountToCache,
 } from "../user";
-import { getAccessToken } from "../user/access";
 import {
 	createPreviewSession,
 	createWorkerPreview,
 } from "./create-worker-preview";
-import { startPreviewServer } from "./proxy";
-import type { ProxyData } from "../api";
+import useInspector from "./inspect";
+import { startPreviewServer, usePreviewServer } from "./proxy";
 import type { Route } from "../config/environment";
 import type {
 	CfModule,
@@ -58,9 +57,7 @@ interface RemoteProps {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady?:
-		| ((ip: string, port: number, proxyData: ProxyData) => void)
-		| undefined;
+	onReady?: ((ip: string, port: number) => void) | undefined;
 	sourceMapPath: string | undefined;
 	sendMetrics: boolean | undefined;
 }
@@ -70,7 +67,7 @@ export function Remote(props: RemoteProps) {
 	const accountChoicesRef = useRef<Promise<ChooseAccountItem[]>>();
 	const [accountChoices, setAccountChoices] = useState<ChooseAccountItem[]>();
 
-	useWorker({
+	const previewToken = useWorker({
 		name: props.name,
 		bundle: props.bundle,
 		format: props.format,
@@ -92,6 +89,29 @@ export function Remote(props: RemoteProps) {
 		port: props.port,
 	});
 
+	usePreviewServer({
+		previewToken,
+		assetDirectory: props.isWorkersSite
+			? undefined
+			: props.assetPaths?.assetDirectory,
+		localProtocol: props.localProtocol,
+		localPort: props.port,
+		ip: props.ip,
+	});
+
+	useInspector({
+		inspectorUrl:
+			props.inspect && previewToken
+				? previewToken.inspectorUrl.href
+				: undefined,
+		port: props.inspectorPort,
+		logToTerminal: true,
+		sourceMapPath: props.sourceMapPath,
+		host: previewToken?.host,
+		name: props.name,
+		sourceMapMetadata: props.bundle?.sourceMapMetadata,
+	});
+
 	const errorHandler = useErrorHandler();
 
 	// This effect handles the async step of fetching the available accounts for the current user.
@@ -153,9 +173,7 @@ interface RemoteWorkerProps {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady:
-		| ((ip: string, port: number, proxyData: ProxyData) => void)
-		| undefined;
+	onReady: ((ip: string, port: number) => void) | undefined;
 	sendMetrics: boolean | undefined;
 	port: number;
 }
@@ -307,30 +325,7 @@ export function useWorker(
 				});
 			}
 			*/
-			const accessToken = await getAccessToken(workerPreviewToken.host);
-
-			const proxyData: ProxyData = {
-				userWorkerUrl: {
-					protocol: "https:",
-					hostname: workerPreviewToken.host,
-					port: "443",
-				},
-				userWorkerInspectorUrl: {
-					protocol: workerPreviewToken.inspectorUrl.protocol,
-					hostname: workerPreviewToken.inspectorUrl.hostname,
-					port: workerPreviewToken.inspectorUrl.port.toString(),
-					pathname: workerPreviewToken.inspectorUrl.pathname,
-				},
-				userWorkerInnerUrlOverrides: {}, // there is no analagous prop for this option because we did not permit overriding request.url in remote mode
-				headers: {
-					"cf-workers-preview-token": workerPreviewToken.value,
-					Cookie: accessToken && `CF_Authorization=${accessToken}`,
-				},
-				liveReload: false, // liveReload currently disabled in remote-mode, but will be supported with startDevWorker
-				proxyLogsToController: true,
-			};
-
-			onReady?.(props.host || "localhost", props.port, proxyData);
+			onReady?.(props.host || "localhost", props.port);
 		}
 		start().catch((err) => {
 			// we want to log the error, but not end the process
@@ -424,32 +419,7 @@ export async function startRemoteServer(props: RemoteProps) {
 		localProtocol: props.localProtocol,
 		localPort: props.port,
 		ip: props.ip,
-		onReady: async (ip, port) => {
-			const accessToken = await getAccessToken(previewToken.host);
-
-			const proxyData: ProxyData = {
-				userWorkerUrl: {
-					protocol: "https:",
-					hostname: previewToken.host,
-					port: "443",
-				},
-				userWorkerInspectorUrl: {
-					protocol: previewToken.inspectorUrl.protocol,
-					hostname: previewToken.inspectorUrl.hostname,
-					port: previewToken.inspectorUrl.port.toString(),
-					pathname: previewToken.inspectorUrl.pathname,
-				},
-				userWorkerInnerUrlOverrides: {}, // there is no analagous prop for this option because we did not permit overriding request.url in remote mode
-				headers: {
-					"cf-workers-preview-token": previewToken.value,
-					Cookie: accessToken && `CF_Authorization=${accessToken}`,
-				},
-				liveReload: false, // liveReload currently disabled in remote-mode, but will be supported with startDevWorker
-				proxyLogsToController: true,
-			};
-
-			props.onReady?.(ip, port, proxyData);
-		},
+		onReady: props.onReady,
 	});
 	if (!previewServer) {
 		throw logger.error("Failed to start remote server");
diff --git a/packages/wrangler/src/dev/start-server.ts b/packages/wrangler/src/dev/start-server.ts
index 323c81e7eb9b..cb7369c901f0 100644
--- a/packages/wrangler/src/dev/start-server.ts
+++ b/packages/wrangler/src/dev/start-server.ts
@@ -2,7 +2,6 @@ import * as path from "node:path";
 import * as util from "node:util";
 import chalk from "chalk";
 import onExit from "signal-exit";
-import { DevEnv, type StartDevWorkerOptions } from "../api";
 import { bundleWorker } from "../deployment-bundle/bundle";
 import { getBundleType } from "../deployment-bundle/bundle-type";
 import { dedupeModulesByName } from "../deployment-bundle/dedupe-modules";
@@ -21,10 +20,9 @@ import {
 import { logger } from "../logger";
 import { getWranglerTmpDir } from "../paths";
 import { localPropsToConfigBundle, maybeRegisterLocalWorker } from "./local";
-import { DEFAULT_WORKER_NAME, MiniflareServer } from "./miniflare";
+import { MiniflareServer } from "./miniflare";
 import { startRemoteServer } from "./remote";
 import { validateDevProps } from "./validate-dev-props";
-import type { ProxyData } from "../api";
 import type { Config } from "../config";
 import type { DurableObjectBindings } from "../config/environment";
 import type { Entry } from "../deployment-bundle/entry";
@@ -81,38 +79,6 @@ export async function startDevServer(
 		}
 	}
 
-	const devEnv = new DevEnv();
-	const startDevWorkerOptions: StartDevWorkerOptions = {
-		name: props.name ?? "worker",
-		script: { contents: "" },
-		dev: {
-			server: {
-				hostname: props.initialIp,
-				port: props.initialPort,
-				secure: props.localProtocol === "https",
-			},
-			inspector: {
-				port: props.inspectorPort,
-			},
-			urlOverrides: {
-				secure: props.localProtocol === "https",
-				hostname: props.localUpstream,
-			},
-			liveReload: props.liveReload,
-			remote: !props.local,
-		},
-	};
-
-	// temp: fake these events by calling the handler directly
-	devEnv.proxy.onConfigUpdate({
-		type: "configUpdate",
-		config: startDevWorkerOptions,
-	});
-	devEnv.proxy.onBundleStart({
-		type: "bundleStart",
-		config: startDevWorkerOptions,
-	});
-
 	//implement a react-free version of useEsbuild
 	const bundle = await runEsbuild({
 		entry: props.entry,
@@ -142,13 +108,6 @@ export async function startDevServer(
 	});
 
 	if (props.local) {
-		// temp: fake these events by calling the handler directly
-		devEnv.proxy.onReloadStart({
-			type: "reloadStart",
-			config: startDevWorkerOptions,
-			bundle,
-		});
-
 		const { stop } = await startLocalServer({
 			name: props.name,
 			bundle: bundle,
@@ -168,25 +127,8 @@ export async function startDevServer(
 			queueConsumers: props.queueConsumers,
 			localProtocol: props.localProtocol,
 			localUpstream: props.localUpstream,
-			inspect: true,
-			onReady: async (ip, port, proxyData) => {
-				// at this point (in the layers of onReady callbacks), we have devEnv in scope
-				// so rewrite the onReady params to be the ip/port of the ProxyWorker instead of the UserWorker
-				const { proxyWorker } = await devEnv.proxy.ready.promise;
-				const url = await proxyWorker.ready;
-				ip = url.hostname;
-				port = parseInt(url.port);
-
-				props.onReady?.(ip, port, proxyData);
-
-				// temp: fake these events by calling the handler directly
-				devEnv.proxy.onReloadComplete({
-					type: "reloadComplete",
-					config: startDevWorkerOptions,
-					bundle,
-					proxyData,
-				});
-			},
+			inspect: props.inspect,
+			onReady: props.onReady,
 			enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
 			usageModel: props.usageModel,
 			workerDefinitions,
@@ -195,7 +137,7 @@ export async function startDevServer(
 
 		return {
 			stop: async () => {
-				await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
+				await Promise.all([stop(), stopWorkerRegistry()]);
 			},
 			// TODO: inspectorUrl,
 		};
@@ -221,30 +163,14 @@ export async function startDevServer(
 			zone: props.zone,
 			host: props.host,
 			routes: props.routes,
-			onReady: async (ip, port, proxyData) => {
-				// at this point (in the layers of onReady callbacks), we have devEnv in scope
-				// so rewrite the onReady params to be the ip/port of the ProxyWorker instead of the UserWorker
-				const { proxyWorker } = await devEnv.proxy.ready.promise;
-				const url = await proxyWorker.ready;
-				ip = url.hostname;
-				port = parseInt(url.port);
-
-				props.onReady?.(ip, port, proxyData);
-
-				// temp: fake these events by calling the handler directly
-				devEnv.proxy.onReloadComplete({
-					type: "reloadComplete",
-					config: startDevWorkerOptions,
-					bundle,
-					proxyData,
-				});
-			},
+			onReady: props.onReady,
 			sourceMapPath: bundle?.sourceMapPath,
 			sendMetrics: props.sendMetrics,
 		});
 		return {
 			stop: async () => {
-				await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
+				stop();
+				await stopWorkerRegistry();
 			},
 			// TODO: inspectorUrl,
 		};
@@ -285,7 +211,7 @@ async function runEsbuild({
 	projectRoot,
 }: {
 	entry: Entry;
-	destination: string;
+	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
 	processEntrypoint: boolean;
@@ -306,7 +232,9 @@ async function runEsbuild({
 	local: boolean;
 	doBindings: DurableObjectBindings;
 	projectRoot: string | undefined;
-}): Promise<EsbuildBundle> {
+}): Promise<EsbuildBundle | undefined> {
+	if (!destination) return;
+
 	if (noBundle) {
 		additionalModules = dedupeModulesByName([
 			...((await doFindAdditionalModules(entry, rules)) ?? []),
@@ -394,32 +322,7 @@ export async function startLocalServer(
 		const server = new MiniflareServer();
 		server.addEventListener("reloaded", async (event) => {
 			await maybeRegisterLocalWorker(event, props.name);
-
-			const proxyData: ProxyData = {
-				userWorkerUrl: {
-					protocol: event.url.protocol,
-					hostname: event.url.hostname,
-					port: event.url.port,
-				},
-				userWorkerInspectorUrl: {
-					protocol: "ws:",
-					hostname: "127.0.0.1",
-					port: props.runtimeInspectorPort.toString(),
-					pathname: `/core:user:${props.name ?? DEFAULT_WORKER_NAME}`,
-				},
-				userWorkerInnerUrlOverrides: {
-					protocol: props.localProtocol,
-					hostname: props.localUpstream,
-					port: props.localUpstream ? "" : undefined, // `localUpstream` was essentially `host`, not `hostname`, so if it was set delete the `port`
-				},
-				headers: {},
-				liveReload: props.liveReload,
-				// in local mode, the logs are already being printed to the console by workerd but only for workers written in "module" format
-				// workers written in "service-worker" format still need to proxy logs to the ProxyController
-				proxyLogsToController: props.format === "service-worker",
-			};
-
-			props.onReady?.(event.url.hostname, parseInt(event.url.port), proxyData);
+			props.onReady?.(event.url.hostname, parseInt(event.url.port));
 			// Note `unstable_dev` doesn't do anything with the inspector URL yet
 			resolve({
 				stop: async () => {
diff --git a/packages/wrangler/src/dev/use-esbuild.ts b/packages/wrangler/src/dev/use-esbuild.ts
index 4492efac77f5..876dc6963be4 100644
--- a/packages/wrangler/src/dev/use-esbuild.ts
+++ b/packages/wrangler/src/dev/use-esbuild.ts
@@ -57,7 +57,6 @@ export function useEsbuild({
 	testScheduled,
 	experimentalLocal,
 	projectRoot,
-	onBundleStart,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -83,7 +82,6 @@ export function useEsbuild({
 	testScheduled: boolean;
 	experimentalLocal: boolean | undefined;
 	projectRoot: string | undefined;
-	onBundleStart: () => void;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -133,9 +131,6 @@ export function useEsbuild({
 		const onEnd = {
 			name: "on-end",
 			setup(b: PluginBuild) {
-				b.onStart(() => {
-					onBundleStart();
-				});
 				b.onEnd(async (result: BuildResult) => {
 					const errors = result.errors;
 					const warnings = result.warnings;
@@ -257,7 +252,6 @@ export function useEsbuild({
 		testScheduled,
 		experimentalLocal,
 		projectRoot,
-		onBundleStart,
 	]);
 	return bundle;
 }
diff --git a/packages/wrangler/src/https-options.ts b/packages/wrangler/src/https-options.ts
index 479d5afd4e4b..e13f3d0d6395 100644
--- a/packages/wrangler/src/https-options.ts
+++ b/packages/wrangler/src/https-options.ts
@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { promisify } from "node:util";
 import { getAccessibleHosts } from "miniflare";
 import { getGlobalWranglerConfigPath } from "./global-wrangler-config-path";
 import { logger } from "./logger";
@@ -16,7 +17,7 @@ const ONE_DAY_IN_MS = 86400000;
  *
  * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
  */
-export function getHttpsOptions() {
+export async function getHttpsOptions() {
 	const certDirectory = path.join(getGlobalWranglerConfigPath(), "local-cert");
 	const keyPath = path.join(certDirectory, "key.pem");
 	const certPath = path.join(certDirectory, "cert.pem");
@@ -28,7 +29,7 @@ export function getHttpsOptions() {
 
 	if (regenerate) {
 		logger.log("Generating new self-signed certificate...");
-		const { key, cert } = generateCertificate();
+		const { key, cert } = await generateCertificate();
 		try {
 			// Write certificate files so we can reuse them later.
 			fs.mkdirSync(certDirectory, { recursive: true });
@@ -66,13 +67,14 @@ function hasCertificateExpired(keyPath: string, certPath: string): boolean {
 /**
  * Generate a new self-signed certificate and cache it in `CERT_ROOT` directory.
  */
-function generateCertificate() {
+async function generateCertificate() {
 	// `selfsigned` imports `node-forge`, which is a pretty big library.
 	// To reduce startup time, only load this dynamically when needed.
 	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-	const generate: typeof import("selfsigned").generate =
+	const generate: typeof import("selfsigned").generate = promisify(
 		// eslint-disable-next-line @typescript-eslint/no-var-requires
-		require("selfsigned").generate;
+		require("selfsigned").generate
+	);
 
 	const certAttrs: Attributes = [{ name: "commonName", value: "localhost" }];
 
@@ -107,6 +109,6 @@ function generateCertificate() {
 		],
 	};
 
-	const { private: key, cert } = generate(certAttrs, certOptions);
+	const { private: key, cert } = await generate(certAttrs, certOptions);
 	return { key, cert };
 }
diff --git a/packages/wrangler/src/worker.d.ts b/packages/wrangler/src/worker.d.ts
deleted file mode 100644
index 1df5a8e911ef..000000000000
--- a/packages/wrangler/src/worker.d.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-declare module "worker:*" {
-    const module: { path: string, contents: string };
-    export default path;
-}
diff --git a/packages/wrangler/templates/startDevWorker/InspectorProxyWorker.ts b/packages/wrangler/templates/startDevWorker/InspectorProxyWorker.ts
deleted file mode 100644
index 366fba8ee53f..000000000000
--- a/packages/wrangler/templates/startDevWorker/InspectorProxyWorker.ts
+++ /dev/null
@@ -1,608 +0,0 @@
-import assert from "node:assert";
-import {
-	DevToolsCommandRequest,
-	DevToolsCommandRequests,
-	DevToolsCommandResponses,
-	DevToolsEvent,
-	DevToolsEvents,
-	type InspectorProxyWorkerIncomingWebSocketMessage,
-	type InspectorProxyWorkerOutgoingRequestBody,
-	type InspectorProxyWorkerOutgoingWebsocketMessage,
-	type ProxyData,
-	serialiseError,
-} from "../../src/api/startDevWorker/events";
-import {
-	assertNever,
-	createDeferred,
-	DeferredPromise,
-	MaybePromise,
-	urlFromParts,
-} from "../../src/api/startDevWorker/utils";
-
-interface Env {
-	PROXY_CONTROLLER: Fetcher;
-	PROXY_CONTROLLER_AUTH_SECRET: string;
-	WRANGLER_VERSION: string;
-	DURABLE_OBJECT: DurableObjectNamespace;
-}
-
-export default {
-	fetch(req, env) {
-		const singleton = env.DURABLE_OBJECT.idFromName("");
-		const inspectorProxy = env.DURABLE_OBJECT.get(singleton);
-
-		return inspectorProxy.fetch(req);
-	},
-} as ExportedHandler<Env>;
-
-function isDevToolsEvent<Method extends DevToolsEvents["method"]>(
-	event: unknown,
-	name: Method
-): event is DevToolsEvent<Method> {
-	return (
-		typeof event === "object" &&
-		event !== null &&
-		"method" in event &&
-		event.method === name
-	);
-}
-
-export class InspectorProxyWorker implements DurableObject {
-	constructor(_state: DurableObjectState, readonly env: Env) {}
-
-	websockets: {
-		proxyController?: WebSocket;
-		runtime?: WebSocket;
-		devtools?: WebSocket;
-
-		// Browser DevTools cannot read the filesystem,
-		// instead they fetch via `Network.loadNetworkResource` messages.
-		// IDE DevTools can read the filesystem and expect absolute paths.
-		devtoolsHasFileSystemAccess?: boolean;
-
-		// We want to be able to delay devtools connection response
-		// until we've connected to the runtime inspector server
-		// so this deferred holds a promise to websockets.runtime
-		runtimeDeferred: DeferredPromise<WebSocket>;
-	} = {
-		runtimeDeferred: createDeferred<WebSocket>(),
-	};
-	proxyData?: ProxyData;
-	runtimeMessageBuffer: (DevToolsCommandResponses | DevToolsEvents)[] = [];
-
-	async fetch(req: Request) {
-		if (
-			req.headers.get("Authorization") === this.env.PROXY_CONTROLLER_AUTH_SECRET
-		) {
-			return this.handleProxyControllerRequest(req);
-		}
-
-		if (req.headers.get("Upgrade") === "websocket") {
-			return this.handleDevToolsWebSocketUpgradeRequest(req);
-		}
-
-		return this.handleDevToolsJsonRequest(req);
-	}
-
-	// ************************
-	// **  PROXY CONTROLLER  **
-	// ************************
-
-	handleProxyControllerRequest(req: Request) {
-		assert(
-			req.headers.get("Upgrade") === "websocket",
-			"Expected proxy controller data request to be WebSocket upgrade"
-		);
-
-		const { 0: response, 1: proxyController } = new WebSocketPair();
-		proxyController.accept();
-		proxyController.addEventListener("close", (event) => {
-			// don't reconnect the proxyController websocket
-			// ProxyController can detect this event and reconnect itself
-
-			this.sendDebugLog(
-				"PROXY CONTROLLER WEBSOCKET CLOSED",
-				event.code,
-				event.reason
-			);
-
-			if (this.websockets.proxyController === proxyController) {
-				this.websockets.proxyController = undefined;
-			}
-		});
-		proxyController.addEventListener("error", (event) => {
-			// don't reconnect the proxyController websocket
-			// ProxyController can detect this event and reconnect itself
-
-			const error = serialiseError(event.error);
-			this.sendDebugLog("PROXY CONTROLLER WEBSOCKET ERROR", error);
-
-			if (this.websockets.proxyController === proxyController) {
-				this.websockets.proxyController = undefined;
-			}
-		});
-		proxyController.addEventListener(
-			"message",
-			this.handleProxyControllerIncomingMessage
-		);
-
-		this.websockets.proxyController = proxyController;
-
-		return new Response(null, {
-			status: 101,
-			webSocket: response,
-		});
-	}
-
-	handleProxyControllerIncomingMessage = (event: MessageEvent) => {
-		assert(
-			typeof event.data === "string",
-			"Expected event.data from proxy controller to be string"
-		);
-
-		const message: InspectorProxyWorkerIncomingWebSocketMessage = JSON.parse(
-			event.data
-		);
-
-		this.sendDebugLog("handleProxyControllerIncomingMessage", event.data);
-
-		switch (message.type) {
-			case "reloadStart": {
-				this.sendRuntimeDiscardConsoleEntries();
-
-				break;
-			}
-			case "reloadComplete": {
-				this.proxyData = message.proxyData;
-
-				this.reconnectRuntimeWebSocket();
-
-				break;
-			}
-			default: {
-				assertNever(message);
-			}
-		}
-	};
-
-	sendProxyControllerMessage(
-		message: string | InspectorProxyWorkerOutgoingWebsocketMessage
-	) {
-		message = typeof message === "string" ? message : JSON.stringify(message);
-
-		// if the proxyController websocket is disconnected, throw away the message
-		this.websockets.proxyController?.send(message);
-	}
-
-	async sendProxyControllerRequest(
-		message: InspectorProxyWorkerOutgoingRequestBody
-	) {
-		try {
-			const res = await this.env.PROXY_CONTROLLER.fetch("http://dummy", {
-				method: "POST",
-				body: JSON.stringify(message),
-			});
-			return res.ok ? await res.text() : undefined;
-		} catch (e) {
-			this.sendDebugLog(
-				"FAILED TO SEND PROXY CONTROLLER REQUEST",
-				serialiseError(e)
-			);
-			return undefined;
-		}
-	}
-
-	sendDebugLog: typeof console.debug = (...args) => {
-		this.sendProxyControllerRequest({ type: "debug-log", args });
-	};
-
-	// ***************
-	// **  RUNTIME  **
-	// ***************
-
-	handleRuntimeIncomingMessage = (event: MessageEvent) => {
-		assert(typeof event.data === "string");
-
-		const msg = JSON.parse(event.data) as
-			| DevToolsCommandResponses
-			| DevToolsEvents;
-		this.sendDebugLog("RUNTIME INCOMING MESSAGE", msg);
-
-		if (isDevToolsEvent(msg, "Runtime.exceptionThrown")) {
-			this.sendProxyControllerMessage(event.data);
-		}
-		if (
-			this.proxyData?.proxyLogsToController &&
-			isDevToolsEvent(msg, "Runtime.consoleAPICalled")
-		) {
-			this.sendProxyControllerMessage(event.data);
-		}
-
-		this.runtimeMessageBuffer.push(msg);
-		this.tryDrainRuntimeMessageBuffer();
-	};
-
-	handleRuntimeScriptParsed(msg: DevToolsEvent<"Debugger.scriptParsed">) {
-		// If the devtools does not have filesystem access,
-		// rewrite the sourceMapURL to use a special scheme.
-		// This special scheme is used to indicate whether
-		// to intercept each loadNetworkResource message.
-
-		if (
-			!this.websockets.devtoolsHasFileSystemAccess &&
-			msg.params.sourceMapURL !== undefined &&
-			// Don't try to find a sourcemap for e.g. node-internal: scripts
-			msg.params.url.startsWith("file:")
-		) {
-			const url = new URL(msg.params.sourceMapURL, msg.params.url);
-			// Check for file: in case msg.params.sourceMapURL has a different
-			// protocol (e.g. data). In that case we should ignore this file
-			if (url.protocol === "file:") {
-				msg.params.sourceMapURL = url.href.replace("file:", "wrangler-file:");
-			}
-		}
-
-		void this.sendDevToolsMessage(msg);
-	}
-
-	tryDrainRuntimeMessageBuffer = () => {
-		// If we don't have a DevTools WebSocket, try again later
-		if (this.websockets.devtools === undefined) return;
-
-		// clear the buffer and replay each message to devtools
-		for (const msg of this.runtimeMessageBuffer.splice(0)) {
-			if (isDevToolsEvent(msg, "Debugger.scriptParsed")) {
-				this.handleRuntimeScriptParsed(msg);
-			} else {
-				void this.sendDevToolsMessage(msg);
-			}
-		}
-	};
-
-	runtimeAbortController = new AbortController(); // will abort the in-flight websocket upgrade request to the remote runtime
-	runtimeKeepAliveInterval: number | null = null;
-	async reconnectRuntimeWebSocket() {
-		assert(this.proxyData, "Expected this.proxyData to be defined");
-
-		this.sendDebugLog("reconnectRuntimeWebSocket");
-
-		this.websockets.runtime?.close();
-		this.websockets.runtime = undefined;
-		this.runtimeAbortController.abort();
-		this.runtimeAbortController = new AbortController();
-		this.websockets.runtimeDeferred = createDeferred<WebSocket>(
-			this.websockets.runtimeDeferred
-		);
-
-		const runtimeWebSocketUrl = urlFromParts(
-			this.proxyData.userWorkerInspectorUrl
-		);
-		runtimeWebSocketUrl.protocol = this.proxyData.userWorkerUrl.protocol; // http: or https:
-
-		this.sendDebugLog("NEW RUNTIME WEBSOCKET", runtimeWebSocketUrl);
-
-		const upgrade = await fetch(runtimeWebSocketUrl, {
-			headers: {
-				...this.proxyData.headers,
-				Upgrade: "websocket",
-			},
-			signal: this.runtimeAbortController.signal,
-		});
-
-		const runtime = upgrade.webSocket;
-		if (!runtime) {
-			const error = new Error(
-				`Failed to establish the WebSocket connection: expected server to reply with HTTP status code 101 (switching protocols), but received ${upgrade.status} instead.`
-			);
-
-			this.websockets.runtimeDeferred.reject(error);
-			this.sendProxyControllerRequest({
-				type: "runtime-websocket-error",
-				error: serialiseError(error),
-			});
-
-			return;
-		}
-
-		this.websockets.runtime = runtime;
-
-		runtime.addEventListener("message", this.handleRuntimeIncomingMessage);
-
-		runtime.addEventListener("close", (event) => {
-			this.sendDebugLog("RUNTIME WEBSOCKET CLOSED", event.code, event.reason);
-
-			clearInterval(this.runtimeKeepAliveInterval);
-
-			if (this.websockets.runtime === runtime) {
-				this.websockets.runtime = undefined;
-			}
-
-			// don't reconnect the runtime websocket
-			// if it closes unexpectedly (very rare or a case where reconnecting won't succeed anyway)
-			// wait for a new proxy-data message or manual restart
-		});
-
-		runtime.addEventListener("error", (event) => {
-			const error = serialiseError(event.error);
-			this.sendDebugLog("RUNTIME WEBSOCKET ERROR", error);
-
-			clearInterval(this.runtimeKeepAliveInterval);
-
-			if (this.websockets.runtime === runtime) {
-				this.websockets.runtime = undefined;
-			}
-
-			this.sendProxyControllerRequest({
-				type: "runtime-websocket-error",
-				error,
-			});
-
-			// don't reconnect the runtime websocket
-			// if it closes unexpectedly (very rare or a case where reconnecting won't succeed anyway)
-			// wait for a new proxy-data message or manual restart
-		});
-
-		runtime.accept();
-
-		// fetch(Upgrade: websocket) resolves when the websocket is open
-		// therefore the open event will not fire, so just trigger the handler
-		this.handleRuntimeWebSocketOpen(runtime);
-	}
-
-	#runtimeMessageCounter = 1e8;
-	nextCounter() {
-		return ++this.#runtimeMessageCounter;
-	}
-	handleRuntimeWebSocketOpen(runtime: WebSocket) {
-		this.sendDebugLog("RUNTIME WEBSOCKET OPENED");
-
-		this.sendRuntimeMessage(
-			{ method: "Runtime.enable", id: this.nextCounter() },
-			runtime
-		);
-		this.sendRuntimeMessage(
-			{ method: "Debugger.enable", id: this.nextCounter() },
-			runtime
-		);
-		this.sendRuntimeMessage(
-			{ method: "Network.enable", id: this.nextCounter() },
-			runtime
-		);
-
-		clearInterval(this.runtimeKeepAliveInterval);
-		this.runtimeKeepAliveInterval = setInterval(() => {
-			this.sendRuntimeMessage(
-				{ method: "Runtime.getIsolateId", id: this.nextCounter() },
-				runtime
-			);
-		}, 10_000) as any;
-
-		this.websockets.runtimeDeferred.resolve(runtime);
-	}
-
-	sendRuntimeDiscardConsoleEntries() {
-		// by default, sendRuntimeMessage waits for the runtime websocket to connect
-		// but we only want to send this message now or never
-		// if we schedule it to send later (like waiting for the websocket, by default)
-		// then we risk clearing logs that have occured since we scheduled it too
-		// which is worse than leaving logs from the previous version on screen
-		if (this.websockets.runtime) {
-			this.sendRuntimeMessage(
-				{
-					method: "Runtime.discardConsoleEntries",
-					id: this.nextCounter(),
-				},
-				this.websockets.runtime
-			);
-		}
-	}
-
-	async sendRuntimeMessage(
-		message: string | DevToolsCommandRequests,
-		runtime: MaybePromise<WebSocket> = this.websockets.runtimeDeferred.promise
-	) {
-		runtime = await runtime;
-		message = typeof message === "string" ? message : JSON.stringify(message);
-
-		this.sendDebugLog("SEND TO RUNTIME", message);
-
-		runtime.send(message);
-	}
-
-	// ****************
-	// **  DEVTOOLS  **
-	// ****************
-
-	#inspectorId = crypto.randomUUID();
-	async handleDevToolsJsonRequest(req: Request) {
-		const url = new URL(req.url);
-
-		if (url.pathname === "/json/version") {
-			return Response.json({
-				Browser: `wrangler/v${this.env.WRANGLER_VERSION}`,
-				// TODO: (someday): The DevTools protocol should match that of workerd.
-				// This could be exposed by the preview API.
-				"Protocol-Version": "1.3",
-			});
-		}
-
-		if (url.pathname === "/json" || url.pathname === "/json/list") {
-			// TODO: can we remove the `/ws` here if we only have a single worker?
-			const localHost = `${url.host}/ws`;
-			const devtoolsFrontendUrl = `https://devtools.devprod.cloudflare.dev/js_app?theme=systemPreferred&debugger=true&ws=${localHost}`;
-
-			return Response.json([
-				{
-					id: this.#inspectorId,
-					type: "node", // TODO: can we specify different type?
-					description: "workers",
-					webSocketDebuggerUrl: `ws://${localHost}`,
-					devtoolsFrontendUrl,
-					devtoolsFrontendUrlCompat: devtoolsFrontendUrl,
-					// Below are fields that are visible in the DevTools UI.
-					title: "Cloudflare Worker",
-					faviconUrl: "https://workers.cloudflare.com/favicon.ico",
-					// url: "http://" + localHost, // looks unnecessary
-				},
-			]);
-		}
-
-		return new Response(null, { status: 404 });
-	}
-
-	async handleDevToolsWebSocketUpgradeRequest(req: Request) {
-		// DevTools attempting to connect
-		this.sendDebugLog("DEVTOOLS WEBSOCKET TRYING TO CONNECT");
-
-		// Delay devtools connection response until we've connected to the runtime inspector server
-		await this.websockets.runtimeDeferred.promise;
-
-		this.sendDebugLog("DEVTOOLS WEBSOCKET CAN NOW CONNECT");
-
-		assert(
-			req.headers.get("Upgrade") === "websocket",
-			"Expected DevTools connection to be WebSocket upgrade"
-		);
-		const { 0: response, 1: devtools } = new WebSocketPair();
-		devtools.accept();
-
-		if (this.websockets.devtools !== undefined) {
-			/** We only want to have one active Devtools instance at a time. */
-			// TODO(consider): prioritise new websocket over previous
-			devtools.close(
-				1013,
-				"Too many clients; only one can be connected at a time"
-			);
-		} else {
-			devtools.addEventListener("message", this.handleDevToolsIncomingMessage);
-			devtools.addEventListener("close", (event) => {
-				this.sendDebugLog(
-					"DEVTOOLS WEBSOCKET CLOSED",
-					event.code,
-					event.reason
-				);
-
-				if (this.websockets.devtools === devtools) {
-					this.websockets.devtools = undefined;
-				}
-			});
-			devtools.addEventListener("error", (event) => {
-				const error = serialiseError(event.error);
-				this.sendDebugLog("DEVTOOLS WEBSOCKET ERROR", error);
-
-				if (this.websockets.devtools === devtools) {
-					this.websockets.devtools = undefined;
-				}
-			});
-
-			// Since Wrangler proxies the inspector, reloading Chrome DevTools won't trigger debugger initialisation events (because it's connecting to an extant session).
-			// This sends a `Debugger.disable` message to the remote when a new WebSocket connection is initialised,
-			// with the assumption that the new connection will shortly send a `Debugger.enable` event and trigger re-initialisation.
-			// The key initialisation messages that are needed are the `Debugger.scriptParsed events`.
-			this.sendRuntimeMessage({
-				id: this.nextCounter(),
-				method: "Debugger.disable",
-			});
-
-			this.sendDebugLog("DEVTOOLS WEBSOCKET CONNECTED");
-
-			// Our patched DevTools are hosted on a `https://` URL. These cannot
-			// access `file://` URLs, meaning local source maps cannot be fetched.
-			// To get around this, we can rewrite `Debugger.scriptParsed` events to
-			// include a special `worker:` scheme for source maps, and respond to
-			// `Network.loadNetworkResource` commands for these. Unfortunately, this
-			// breaks IDE's built-in debuggers (e.g. VSCode and WebStorm), so we only
-			// want to enable this transformation when we detect hosted DevTools has
-			// connected. We do this by looking at the WebSocket handshake headers:
-			//
-			//  DevTools
-			//
-			// Upgrade: websocket
-			// Host: localhost:9229
-			// (from Chrome)  User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36
-			// (from Firefox) User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/116.0
-			// Origin: https://devtools.devprod.cloudflare.dev
-			// ...
-			//
-			//  VSCode
-			//
-			// Upgrade: websocket
-			// Host: localhost
-			// ...
-			//
-			//  WebStorm
-			//
-			// Upgrade: websocket
-			// Host: localhost:9229
-			// Origin: http://localhost:9229
-			// ...
-			//
-			// From this, we could just use the presence of a `User-Agent` header to
-			// determine if DevTools connected, but VSCode/WebStorm could very well
-			// add this in future versions. We could also look for an `Origin` header
-			// matching the hosted DevTools URL, but this would prevent preview/local
-			// versions working. Instead, we look for a browser-like `User-Agent`.
-			const userAgent = req.headers.get("User-Agent") ?? "";
-			const hasFileSystemAccess = !/mozilla/i.test(userAgent);
-
-			this.websockets.devtools = devtools;
-			this.websockets.devtoolsHasFileSystemAccess = hasFileSystemAccess;
-
-			this.tryDrainRuntimeMessageBuffer();
-		}
-
-		return new Response(null, { status: 101, webSocket: response });
-	}
-
-	handleDevToolsIncomingMessage = (event: MessageEvent) => {
-		assert(
-			typeof event.data === "string",
-			"Expected devtools incoming message to be of type string"
-		);
-
-		const message = JSON.parse(event.data) as DevToolsCommandRequests;
-		this.sendDebugLog("DEVTOOLS INCOMING MESSAGE", message);
-
-		if (message.method === "Network.loadNetworkResource") {
-			return void this.handleDevToolsLoadNetworkResource(message);
-		}
-
-		this.sendRuntimeMessage(JSON.stringify(message));
-	};
-
-	async handleDevToolsLoadNetworkResource(
-		message: DevToolsCommandRequest<"Network.loadNetworkResource">
-	) {
-		const response = await this.sendProxyControllerRequest({
-			type: "load-network-resource",
-			url: message.params.url,
-		});
-		if (response === undefined) {
-			this.sendDebugLog(
-				`ProxyController could not resolve Network.loadNetworkResource for "${message.params.url}"`
-			);
-
-			// When the ProxyController cannot resolve a resource, let the runtime handle the request
-			this.sendRuntimeMessage(JSON.stringify(message));
-		} else {
-			// this.websockets.devtools can be undefined here
-			// the incoming message implies we have a devtools connection, but after
-			// the await it could've dropped in which case we can safely not respond
-			this.sendDevToolsMessage({
-				id: message.id,
-				// @ts-expect-error DevTools Protocol type does not match our patched devtools -- result.resource.text was added
-				result: { resource: { success: true, text: response } },
-			});
-		}
-	}
-
-	sendDevToolsMessage(
-		message: string | DevToolsCommandResponses | DevToolsEvents
-	) {
-		message = typeof message === "string" ? message : JSON.stringify(message);
-
-		this.sendDebugLog("SEND TO DEVTOOLS", message);
-
-		this.websockets.devtools?.send(message);
-	}
-}
diff --git a/packages/wrangler/templates/startDevWorker/ProxyWorker.ts b/packages/wrangler/templates/startDevWorker/ProxyWorker.ts
deleted file mode 100644
index 35a08936bd02..000000000000
--- a/packages/wrangler/templates/startDevWorker/ProxyWorker.ts
+++ /dev/null
@@ -1,252 +0,0 @@
-import assert from "node:assert";
-import type {
-	ProxyWorkerIncomingRequestBody,
-	ProxyWorkerOutgoingRequestBody,
-	ProxyData,
-} from "../../src/api/startDevWorker/events";
-import {
-	DeferredPromise,
-	createDeferred,
-} from "../../src/api/startDevWorker/utils";
-
-interface Env {
-	PROXY_CONTROLLER: Fetcher;
-	PROXY_CONTROLLER_AUTH_SECRET: string;
-	DURABLE_OBJECT: DurableObjectNamespace;
-}
-
-// request.cf.hostMetadata is verbose to type using the workers-types Request -- this allows us to have Request correctly typed in this scope
-type Request = Parameters<
-	NonNullable<
-		ExportedHandler<Env, unknown, ProxyWorkerIncomingRequestBody>["fetch"]
-	>
->[0];
-
-const LIVE_RELOAD_PROTOCOL = "WRANGLER_PROXYWORKER_LIVE_RELOAD_PROTOCOL";
-export default {
-	fetch(req, env) {
-		const singleton = env.DURABLE_OBJECT.idFromName("");
-		const inspectorProxy = env.DURABLE_OBJECT.get(singleton);
-
-		return inspectorProxy.fetch(req);
-	},
-} as ExportedHandler<Env, unknown, ProxyWorkerIncomingRequestBody>;
-
-export class ProxyWorker implements DurableObject {
-	constructor(readonly state: DurableObjectState, readonly env: Env) {}
-
-	proxyData?: ProxyData;
-	requestQueue = new Map<Request, DeferredPromise<Response>>();
-
-	fetch(request: Request) {
-		if (isRequestForLiveReloadWebsocket(request)) {
-			// requests for live-reload websocket
-
-			return this.handleLiveReloadWebSocket(request);
-		}
-
-		if (isRequestFromProxyController(request, this.env)) {
-			// requests from ProxyController
-
-			return this.processProxyControllerRequest(request);
-		}
-
-		// regular requests to be proxied
-		const deferred = createDeferred<Response>();
-
-		this.requestQueue.set(request, deferred);
-		this.processQueue();
-
-		return deferred.promise;
-	}
-
-	handleLiveReloadWebSocket(request: Request) {
-		const { 0: response, 1: liveReload } = new WebSocketPair();
-		const websocketProtocol =
-			request.headers.get("Sec-WebSocket-Protocol") ?? "";
-
-		this.state.acceptWebSocket(liveReload, ["live-reload"]);
-
-		return new Response(null, {
-			status: 101,
-			webSocket: response,
-			headers: { "Sec-WebSocket-Protocol": websocketProtocol },
-		});
-	}
-
-	processProxyControllerRequest(request: Request) {
-		const event = request.cf?.hostMetadata;
-		switch (event?.type) {
-			case "pause":
-				this.proxyData = undefined;
-				break;
-
-			case "play":
-				this.proxyData = event.proxyData;
-				this.processQueue();
-				this.state
-					.getWebSockets("live-reload")
-					.forEach((ws) => ws.send("reload"));
-
-				break;
-		}
-
-		return new Response(null, { status: 204 });
-	}
-
-	processQueue() {
-		const { proxyData } = this; // destructuring is required to keep the type-narrowing (not undefined) in the .then callback and to ensure the same proxyData is used throughout each request
-		if (proxyData === undefined) return;
-
-		for (const [request, deferredResponse] of this.requestQueue) {
-			this.requestQueue.delete(request);
-
-			const userWorkerUrl = new URL(request.url);
-			const headers = new Headers(request.headers);
-
-			// override url parts for proxying
-			Object.assign(userWorkerUrl, proxyData.userWorkerUrl);
-
-			// set request.url in the UserWorker
-			const innerUrl = new URL(request.url);
-			Object.assign(innerUrl, proxyData.userWorkerInnerUrlOverrides);
-			headers.set("MF-Original-URL", innerUrl.href);
-			headers.set("MF-Disable-Pretty-Error", "true"); // disables the UserWorker miniflare instance from rendering the pretty error -- instead the ProxyWorker miniflare instance will intercept the json error response and render the pretty error page
-
-			// merge proxyData headers with the request headers
-			for (const [key, value] of Object.entries(proxyData.headers ?? {})) {
-				if (key.toLowerCase() === "cookie") {
-					const existing = request.headers.get("cookie") ?? "";
-					headers.set("cookie", `${existing};${value}`);
-				} else {
-					headers.set(key, value);
-				}
-			}
-
-			// explicitly NOT await-ing this promise, we are in a loop and want to process the whole queue quickly
-			// if we decide to await, we should include a timeout (~100ms) in case the user worker has long-running/parellel requests
-			void fetch(userWorkerUrl, new Request(request, { headers }))
-				.then((res) => {
-					if (isHtmlResponse(res)) {
-						res = insertLiveReloadScript(request, res, this.env, proxyData);
-					}
-
-					deferredResponse.resolve(res);
-				})
-				.catch((error: Error) => {
-					// errors here are network errors or from response post-processing
-					// to catch only network errors, use the 2nd param of the fetch.then()
-
-					void sendMessageToProxyController(this.env, {
-						type: "error",
-						error: {
-							name: error.name,
-							message: error.message,
-							stack: error.stack,
-							cause: error.cause,
-						},
-					});
-
-					deferredResponse.reject(error);
-				});
-		}
-	}
-}
-
-function isRequestFromProxyController(req: Request, env: Env): boolean {
-	return req.headers.get("Authorization") === env.PROXY_CONTROLLER_AUTH_SECRET;
-}
-function isHtmlResponse(res: Response): boolean {
-	return res.headers.get("content-type")?.startsWith("text/html") ?? false;
-}
-function isRequestForLiveReloadWebsocket(req: Request): boolean {
-	const websocketProtocol = req.headers.get("Sec-WebSocket-Protocol");
-	const isWebSocketUpgrade = req.headers.get("Upgrade") === "websocket";
-
-	return isWebSocketUpgrade && websocketProtocol === LIVE_RELOAD_PROTOCOL;
-}
-
-async function sendMessageToProxyController(
-	env: Env,
-	message: ProxyWorkerOutgoingRequestBody,
-	retries = 3
-) {
-	try {
-		await env.PROXY_CONTROLLER.fetch("http://dummy", {
-			method: "POST",
-			body: JSON.stringify(message),
-		});
-	} catch (cause) {
-		if (retries > 0) {
-			return sendMessageToProxyController(env, message, retries - 1);
-		}
-
-		// no point sending an error message if we can't send this message
-
-		throw cause;
-	}
-}
-
-function insertLiveReloadScript(
-	request: Request,
-	response: Response,
-	env: Env,
-	proxyData: ProxyData
-) {
-	const htmlRewriter = new HTMLRewriter();
-
-	// if preview-token-expired response, errorDetails will contain "Invalid Workers Preview configuration"
-	let errorDetails = "";
-	htmlRewriter.on("#cf-error-details", {
-		text(element) {
-			errorDetails += element.text;
-		},
-	});
-
-	htmlRewriter.onDocument({
-		end(end) {
-			if (
-				response.status === 400 &&
-				errorDetails.includes("Invalid Workers Preview configuration")
-			) {
-				void sendMessageToProxyController(env, {
-					type: "previewTokenExpired",
-					proxyData,
-				});
-			}
-
-			// if liveReload enabled, append a script tag
-			// TODO: compare to existing nodejs implementation
-			if (proxyData.liveReload) {
-				const websocketUrl = new URL(request.url);
-				websocketUrl.protocol =
-					websocketUrl.protocol === "http:" ? "ws:" : "wss:";
-
-				end.append(
-					`
-					<script>
-						(function() {
-							var ws;
-							function recover() {
-								ws = null;
-								setTimeout(initLiveReload, 100);
-							}
-							function initLiveReload() {
-								if (ws) return;
-                var origin = (location.protocol === "http:" ? "ws://" : "wss://") + location.host;
-								ws = new WebSocket(origin + "/cdn-cgi/live-reload", "${LIVE_RELOAD_PROTOCOL}");
-								ws.onclose = recover;
-								ws.onerror = recover;
-								ws.onmessage = location.reload.bind(location);
-							}
-						})();
-					</script>
-				`,
-					{ html: true }
-				);
-			}
-		},
-	});
-
-	return htmlRewriter.transform(response);
-}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3779289b6998..97381ccef272 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -106,30 +106,6 @@ importers:
         specifier: workspace:*
         version: link:../../packages/wrangler
 
-  fixtures/dev-env:
-    devDependencies:
-      '@cloudflare/workers-tsconfig':
-        specifier: workspace:^
-        version: link:../../packages/workers-tsconfig
-      '@types/ws':
-        specifier: ^8.5.7
-        version: 8.5.9
-      get-port:
-        specifier: ^7.0.0
-        version: 7.0.0
-      miniflare:
-        specifier: 3.20231025.1
-        version: link:../../packages/miniflare
-      undici:
-        specifier: ^5.23.0
-        version: 5.23.0
-      wrangler:
-        specifier: workspace:*
-        version: link:../../packages/wrangler
-      ws:
-        specifier: ^8.14.2
-        version: 8.14.2
-
   fixtures/durable-objects-app:
     devDependencies:
       '@cloudflare/workers-tsconfig':
@@ -655,7 +631,7 @@ importers:
         version: 8.4.0
       pnpm:
         specifier: ^8.10.0
-        version: 8.10.2
+        version: 8.10.0
       recast:
         specifier: ^0.22.0
         version: 0.22.0
@@ -721,7 +697,7 @@ importers:
         version: 8.49.0
       eslint-config-turbo:
         specifier: latest
-        version: 1.10.16(eslint@8.49.0)
+        version: 1.10.14(eslint@8.49.0)
       eslint-plugin-import:
         specifier: 2.26.x
         version: 2.26.0(@typescript-eslint/parser@6.7.2)(eslint@8.49.0)
@@ -796,7 +772,7 @@ importers:
         version: 1.20231030.0
       ws:
         specifier: ^8.11.0
-        version: 8.14.2
+        version: 8.13.0
       youch:
         specifier: ^3.2.2
         version: 3.2.3
@@ -815,7 +791,7 @@ importers:
         version: 4.20231025.0
       '@microsoft/api-extractor':
         specifier: ^7.36.3
-        version: 7.38.2(@types/node@18.16.10)
+        version: 7.38.1(@types/node@18.16.10)
       '@types/debug':
         specifier: ^4.1.7
         version: 4.1.7
@@ -839,19 +815,19 @@ importers:
         version: 0.5.7
       '@types/stoppable':
         specifier: ^1.1.1
-        version: 1.1.3
+        version: 1.1.2
       '@types/which':
         specifier: ^2.0.1
         version: 2.0.2
       '@types/ws':
         specifier: ^8.5.3
-        version: 8.5.9
+        version: 8.5.3
       '@typescript-eslint/eslint-plugin':
         specifier: ^6.9.0
-        version: 6.10.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0)(typescript@5.0.4)
+        version: 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.49.0)(typescript@5.0.4)
       '@typescript-eslint/parser':
         specifier: ^6.9.0
-        version: 6.10.0(eslint@8.49.0)(typescript@5.0.4)
+        version: 6.9.1(eslint@8.49.0)(typescript@5.0.4)
       ava:
         specifier: ^5.2.0
         version: 5.3.1(@ava/typescript@4.1.0)
@@ -878,7 +854,7 @@ importers:
         version: 4.1.0(eslint@8.49.0)
       eslint-plugin-import:
         specifier: 2.26.x
-        version: 2.26.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0)
+        version: 2.26.0(@typescript-eslint/parser@6.9.1)(eslint@8.49.0)
       eslint-plugin-prettier:
         specifier: ^5.0.1
         version: 5.0.1(eslint-config-prettier@9.0.0)(eslint@8.49.0)(prettier@3.0.3)
@@ -961,7 +937,7 @@ importers:
         version: 5.23.0
       wrangler:
         specifier: ^3.5.1
-        version: link:../wrangler
+        version: 3.16.0
 
   packages/prerelease-registry:
     dependencies:
@@ -1523,7 +1499,7 @@ importers:
         version: 6.5.1
       wrangler:
         specifier: ^3.0.0
-        version: link:../wrangler
+        version: 3.16.0
 
 packages:
 
@@ -3558,7 +3534,6 @@ packages:
     resolution: {integrity: sha512-MVbXLbTcAotOPUj0pAMhVtJ+3/kFkwJqc5qNOleOZTv6QkZZABDMS21dSrSlVswEHwrpWC03e4fWytjqKvuE2A==}
     dependencies:
       mime: 3.0.0
-    dev: false
 
   /@cloudflare/kv-asset-handler@0.3.0:
     resolution: {integrity: sha512-9CB/MKf/wdvbfkUdfrj+OkEwZ5b7rws0eogJ4293h+7b6KX5toPwym+VQKmILafNB9YiehqY0DlNrDcDhdWHSQ==}
@@ -3666,7 +3641,6 @@ packages:
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
-    dev: false
     optional: true
 
   /@cloudflare/workerd-darwin-arm64@1.20231030.0:
@@ -3675,7 +3649,6 @@ packages:
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
-    dev: false
     optional: true
 
   /@cloudflare/workerd-linux-64@1.20231030.0:
@@ -3684,7 +3657,6 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
-    dev: false
     optional: true
 
   /@cloudflare/workerd-linux-arm64@1.20231030.0:
@@ -3693,7 +3665,6 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
-    dev: false
     optional: true
 
   /@cloudflare/workerd-windows-64@1.20231030.0:
@@ -3702,7 +3673,6 @@ packages:
     cpu: [x64]
     os: [win32]
     requiresBuild: true
-    dev: false
     optional: true
 
   /@cloudflare/workers-types@3.18.0:
@@ -3774,7 +3744,6 @@ packages:
       esbuild: '*'
     dependencies:
       esbuild: 0.17.19
-    dev: false
 
   /@esbuild-plugins/node-modules-polyfill@0.2.2(esbuild@0.17.19):
     resolution: {integrity: sha512-LXV7QsWJxRuMYvKbiznh+U1ilIop3g2TeKRzUxOG5X3YITc8JyyTa90BmLwqqv0YnX4v32CSlG+vsziZp9dMvA==}
@@ -3784,7 +3753,6 @@ packages:
       esbuild: 0.17.19
       escape-string-regexp: 4.0.0
       rollup-plugin-node-polyfills: 0.2.1
-    dev: false
 
   /@esbuild/android-arm64@0.16.17:
     resolution: {integrity: sha512-MIGl6p5sc3RDTLLkYL1MyL8BMRN4tLMRCn+yRJJmEDvYZ2M7tmAf80hx1kbNEUX2KJ50RRtxZ4JHLvCfuB6kBg==}
@@ -4789,7 +4757,7 @@ packages:
       debug: 4.3.4(supports-color@9.2.2)
       espree: 9.5.2
       globals: 13.20.0
-      ignore: 5.2.0
+      ignore: 5.2.4
       import-fresh: 3.3.0
       js-yaml: 4.1.0
       minimatch: 3.1.2
@@ -4806,7 +4774,7 @@ packages:
       debug: 4.3.4(supports-color@9.2.2)
       espree: 9.6.1
       globals: 13.20.0
-      ignore: 5.2.0
+      ignore: 5.2.4
       import-fresh: 3.3.0
       js-yaml: 4.1.0
       minimatch: 3.1.2
@@ -5258,8 +5226,8 @@ packages:
       typescript: 4.6.4
     dev: true
 
-  /@microsoft/api-extractor@7.38.2(@types/node@18.16.10):
-    resolution: {integrity: sha512-JOARuhTwOcOMIU0O2czscoJy3ddVzIRhSA9/7T1ALuZSNphgWsPk+Bv4E7AnBDmTV4pP4lBNLtCxEHjjpWaytQ==}
+  /@microsoft/api-extractor@7.38.1(@types/node@18.16.10):
+    resolution: {integrity: sha512-Hxu/RrVpItQ4dzeMyfwlk4lGQFsXMoMS7bYU9YUrpW16hH04PXLRiTXJz77WhBiSGNtTuufz2xh6hWyXhC9JuQ==}
     hasBin: true
     dependencies:
       '@microsoft/api-extractor-model': 7.28.2(@types/node@18.16.10)
@@ -5267,7 +5235,7 @@ packages:
       '@microsoft/tsdoc-config': 0.16.1
       '@rushstack/node-core-library': 3.61.0(@types/node@18.16.10)
       '@rushstack/rig-package': 0.5.1
-      '@rushstack/ts-command-line': 4.17.1
+      '@rushstack/ts-command-line': 4.17.0
       colors: 1.2.5
       lodash: 4.17.21
       resolve: 1.22.2
@@ -5795,8 +5763,8 @@ packages:
       string-argv: 0.3.1
     dev: true
 
-  /@rushstack/ts-command-line@4.17.1:
-    resolution: {integrity: sha512-2jweO1O57BYP5qdBGl6apJLB+aRIn5ccIRTPDyULh0KMwVzFqWtw6IZWt1qtUoZD/pD2RNkIOosH6Cq45rIYeg==}
+  /@rushstack/ts-command-line@4.17.0:
+    resolution: {integrity: sha512-1S0sXuEpZlzKTfvUqNs7Rg4leVkeLJc4Dn9cm+pSIn35a0Ztp5GxPN2gabD2G4RrQoQcJLLyVu+twzrJl1C0eA==}
     dependencies:
       '@types/argparse': 1.0.38
       argparse: 1.0.10
@@ -6457,8 +6425,8 @@ packages:
     resolution: {integrity: sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==}
     dev: true
 
-  /@types/stoppable@1.1.3:
-    resolution: {integrity: sha512-7wGKIBJGE4ZxFjk9NkjAxZMLlIXroETqP1FJCdoSvKmEznwmBxQFmTB1dsCkAvVcNemuSZM5qkkd9HE/NL2JTw==}
+  /@types/stoppable@1.1.2:
+    resolution: {integrity: sha512-zRBGFTIdkCAdM4VDeFvka5NbD6JVfz7yEYzggKrXQ03ZplrZp5vqQPWHTw0wk81wer61dwi44Tp6FDDXoPBW5A==}
     dependencies:
       '@types/node': 18.16.10
     dev: true
@@ -6507,12 +6475,6 @@ packages:
       '@types/node': 18.16.10
     dev: true
 
-  /@types/ws@8.5.9:
-    resolution: {integrity: sha512-jbdrY0a8lxfdTp/+r7Z4CkycbOFN8WX+IOchLJr3juT/xzbJ8URyTVSJ/hvNdadTgM1mnedb47n+Y31GsFnQlg==}
-    dependencies:
-      '@types/node': 18.16.10
-    dev: true
-
   /@types/yargs-parser@20.2.1:
     resolution: {integrity: sha512-7tFImggNeNBVMsn0vLrpn1H1uPrUBdnARPTpZoitY37ZrdJREzf7I16tMrlK3hen349gr1NYh8CmZQa7CTG6Aw==}
     dev: true
@@ -6582,7 +6544,7 @@ packages:
       graphemer: 1.4.0
       ignore: 5.2.0
       natural-compare-lite: 1.4.0
-      semver: 7.5.1
+      semver: 7.5.4
       tsutils: 3.21.0(typescript@4.9.5)
       typescript: 4.9.5
     transitivePeerDependencies:
@@ -6638,15 +6600,15 @@ packages:
       graphemer: 1.4.0
       ignore: 5.2.0
       natural-compare-lite: 1.4.0
-      semver: 7.5.1
+      semver: 7.5.4
       tsutils: 3.21.0(typescript@5.0.3)
       typescript: 5.0.3
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/eslint-plugin@6.10.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-uoLj4g2OTL8rfUQVx2AFO1hp/zja1wABJq77P6IclQs6I/m9GLrm7jCdgzZkvWdDCQf1uEvoa8s8CupsgWQgVg==}
+  /@typescript-eslint/eslint-plugin@6.7.2(@typescript-eslint/parser@6.7.2)(eslint@8.49.0)(typescript@4.9.5):
+    resolution: {integrity: sha512-ooaHxlmSgZTM6CHYAFRlifqh1OAr3PAQEwi7lhYhaegbnXrnh7CDcHmc3+ihhbQC7H0i4JF0psI5ehzkF6Yl6Q==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
@@ -6656,26 +6618,26 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.8.1
-      '@typescript-eslint/parser': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
-      '@typescript-eslint/scope-manager': 6.10.0
-      '@typescript-eslint/type-utils': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
-      '@typescript-eslint/utils': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
-      '@typescript-eslint/visitor-keys': 6.10.0
+      '@eslint-community/regexpp': 4.5.1
+      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 6.7.2
+      '@typescript-eslint/type-utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 6.7.2
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
       graphemer: 1.4.0
       ignore: 5.2.4
       natural-compare: 1.4.0
       semver: 7.5.4
-      ts-api-utils: 1.0.3(typescript@5.0.4)
-      typescript: 5.0.4
+      ts-api-utils: 1.0.3(typescript@4.9.5)
+      typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
-    dev: true
+    dev: false
 
-  /@typescript-eslint/eslint-plugin@6.7.2(@typescript-eslint/parser@6.7.2)(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-ooaHxlmSgZTM6CHYAFRlifqh1OAr3PAQEwi7lhYhaegbnXrnh7CDcHmc3+ihhbQC7H0i4JF0psI5ehzkF6Yl6Q==}
+  /@typescript-eslint/eslint-plugin@6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-w0tiiRc9I4S5XSXXrMHOWgHgxbrBn1Ro+PmiYhSg2ZVdxrAJtQgzU5o2m1BfP6UOn7Vxcc6152vFjQfmZR4xEg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
@@ -6685,23 +6647,23 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.5.1
-      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
-      '@typescript-eslint/scope-manager': 6.7.2
-      '@typescript-eslint/type-utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
-      '@typescript-eslint/utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
-      '@typescript-eslint/visitor-keys': 6.7.2
+      '@eslint-community/regexpp': 4.8.1
+      '@typescript-eslint/parser': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/type-utils': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/utils': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/visitor-keys': 6.9.1
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
       graphemer: 1.4.0
       ignore: 5.2.4
       natural-compare: 1.4.0
       semver: 7.5.4
-      ts-api-utils: 1.0.3(typescript@4.9.5)
-      typescript: 4.9.5
+      ts-api-utils: 1.0.3(typescript@5.0.4)
+      typescript: 5.0.4
     transitivePeerDependencies:
       - supports-color
-    dev: false
+    dev: true
 
   /@typescript-eslint/parser@5.59.9(eslint@8.49.0)(typescript@5.0.3):
     resolution: {integrity: sha512-FsPkRvBtcLQ/eVK1ivDiNYBjn3TGJdXy2fhXX+rc7czWl4ARwnpArwbihSOHI2Peg9WbtGHrbThfBUkZZGTtvQ==}
@@ -6783,8 +6745,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@6.10.0(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-+sZwIj+s+io9ozSxIWbNB5873OSdfeBEH/FR0re14WLI6BaKuSOnnwCJ2foUiu8uXf4dRp1UqHP0vrZ1zXGrog==}
+  /@typescript-eslint/parser@6.7.2(eslint@8.49.0)(typescript@4.9.5):
+    resolution: {integrity: sha512-KA3E4ox0ws+SPyxQf9iSI25R6b4Ne78ORhNHeVKrPQnoYsb9UhieoiRoJgrzgEeKGOXhcY1i8YtOeCHHTDa6Fw==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6793,19 +6755,19 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 6.10.0
-      '@typescript-eslint/types': 6.10.0
-      '@typescript-eslint/typescript-estree': 6.10.0(typescript@5.0.4)
-      '@typescript-eslint/visitor-keys': 6.10.0
+      '@typescript-eslint/scope-manager': 6.7.2
+      '@typescript-eslint/types': 6.7.2
+      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 6.7.2
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
-      typescript: 5.0.4
+      typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
-    dev: true
+    dev: false
 
-  /@typescript-eslint/parser@6.7.2(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-KA3E4ox0ws+SPyxQf9iSI25R6b4Ne78ORhNHeVKrPQnoYsb9UhieoiRoJgrzgEeKGOXhcY1i8YtOeCHHTDa6Fw==}
+  /@typescript-eslint/parser@6.9.1(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-C7AK2wn43GSaCUZ9do6Ksgi2g3mwFkMO3Cis96kzmgudoVaKyt62yNzJOktP0HDLb/iO2O0n2lBOzJgr6Q/cyg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6814,16 +6776,16 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 6.7.2
-      '@typescript-eslint/types': 6.7.2
-      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
-      '@typescript-eslint/visitor-keys': 6.7.2
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.0.4)
+      '@typescript-eslint/visitor-keys': 6.9.1
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
-      typescript: 4.9.5
+      typescript: 5.0.4
     transitivePeerDependencies:
       - supports-color
-    dev: false
+    dev: true
 
   /@typescript-eslint/scope-manager@5.59.9:
     resolution: {integrity: sha512-8RA+E+w78z1+2dzvK/tGZ2cpGigBZ58VMEHDZtpE1v+LLjzrYGc8mMaTONSxKyEkz3IuXFM0IqYiGHlCsmlZxQ==}
@@ -6841,14 +6803,6 @@ packages:
       '@typescript-eslint/visitor-keys': 5.62.0
     dev: true
 
-  /@typescript-eslint/scope-manager@6.10.0:
-    resolution: {integrity: sha512-TN/plV7dzqqC2iPNf1KrxozDgZs53Gfgg5ZHyw8erd6jd5Ta/JIEcdCheXFt9b1NYb93a1wmIIVW/2gLkombDg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dependencies:
-      '@typescript-eslint/types': 6.10.0
-      '@typescript-eslint/visitor-keys': 6.10.0
-    dev: true
-
   /@typescript-eslint/scope-manager@6.7.2:
     resolution: {integrity: sha512-bgi6plgyZjEqapr7u2mhxGR6E8WCzKNUFWNh6fkpVe9+yzRZeYtDTbsIBzKbcxI+r1qVWt6VIoMSNZ4r2A+6Yw==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -6857,6 +6811,14 @@ packages:
       '@typescript-eslint/visitor-keys': 6.7.2
     dev: false
 
+  /@typescript-eslint/scope-manager@6.9.1:
+    resolution: {integrity: sha512-38IxvKB6NAne3g/+MyXMs2Cda/Sz+CEpmm+KLGEM8hx/CvnSRuw51i8ukfwB/B/sESdeTGet1NH1Wj7I0YXswg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/visitor-keys': 6.9.1
+    dev: true
+
   /@typescript-eslint/type-utils@5.59.9(eslint@8.49.0)(typescript@5.0.3):
     resolution: {integrity: sha512-ksEsT0/mEHg9e3qZu98AlSrONAQtrSTljL3ow9CGej8eRo7pe+yaC/mvTjptp23Xo/xIf2mLZKC6KPv4Sji26Q==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -6937,8 +6899,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/type-utils@6.10.0(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-wYpPs3hgTFblMYwbYWPT3eZtaDOjbLyIYuqpwuLBBqhLiuvJ+9sEp2gNRJEtR5N/c9G1uTtQQL5AhV0fEPJYcg==}
+  /@typescript-eslint/type-utils@6.7.2(eslint@8.49.0)(typescript@4.9.5):
+    resolution: {integrity: sha512-36F4fOYIROYRl0qj95dYKx6kybddLtsbmPIYNK0OBeXv2j9L5nZ17j9jmfy+bIDHKQgn2EZX+cofsqi8NPATBQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6947,18 +6909,18 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 6.10.0(typescript@5.0.4)
-      '@typescript-eslint/utils': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
+      '@typescript-eslint/utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
-      ts-api-utils: 1.0.3(typescript@5.0.4)
-      typescript: 5.0.4
+      ts-api-utils: 1.0.3(typescript@4.9.5)
+      typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
-    dev: true
+    dev: false
 
-  /@typescript-eslint/type-utils@6.7.2(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-36F4fOYIROYRl0qj95dYKx6kybddLtsbmPIYNK0OBeXv2j9L5nZ17j9jmfy+bIDHKQgn2EZX+cofsqi8NPATBQ==}
+  /@typescript-eslint/type-utils@6.9.1(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-eh2oHaUKCK58qIeYp19F5V5TbpM52680sB4zNSz29VBQPTWIlE/hCj5P5B1AChxECe/fmZlspAWFuRniep1Skg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6967,15 +6929,15 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
-      '@typescript-eslint/utils': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.0.4)
+      '@typescript-eslint/utils': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
       debug: 4.3.4(supports-color@9.2.2)
       eslint: 8.49.0
-      ts-api-utils: 1.0.3(typescript@4.9.5)
-      typescript: 4.9.5
+      ts-api-utils: 1.0.3(typescript@5.0.4)
+      typescript: 5.0.4
     transitivePeerDependencies:
       - supports-color
-    dev: false
+    dev: true
 
   /@typescript-eslint/types@5.59.9:
     resolution: {integrity: sha512-uW8H5NRgTVneSVTfiCVffBb8AbwWSKg7qcA4Ot3JI3MPCJGsB4Db4BhvAODIIYE5mNj7Q+VJkK7JxmRhk2Lyjw==}
@@ -6987,16 +6949,16 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
-  /@typescript-eslint/types@6.10.0:
-    resolution: {integrity: sha512-36Fq1PWh9dusgo3vH7qmQAj5/AZqARky1Wi6WpINxB6SkQdY5vQoT2/7rW7uBIsPDcvvGCLi4r10p0OJ7ITAeg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dev: true
-
   /@typescript-eslint/types@6.7.2:
     resolution: {integrity: sha512-flJYwMYgnUNDAN9/GAI3l8+wTmvTYdv64fcH8aoJK76Y+1FCZ08RtI5zDerM/FYT5DMkAc+19E4aLmd5KqdFyg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     dev: false
 
+  /@typescript-eslint/types@6.9.1:
+    resolution: {integrity: sha512-BUGslGOb14zUHOUmDB2FfT6SI1CcZEJYfF3qFwBeUrU6srJfzANonwRYHDpLBuzbq3HaoF2XL2hcr01c8f8OaQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dev: true
+
   /@typescript-eslint/typescript-estree@5.59.9(typescript@4.9.5):
     resolution: {integrity: sha512-pmM0/VQ7kUhd1QyIxgS+aRvMgw+ZljB3eDb+jYyp6d2bC0mQWLzUDF+DLwCTkQ3tlNyVsvZRXjFyV0LkU/aXjA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -7081,8 +7043,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/typescript-estree@6.10.0(typescript@5.0.4):
-    resolution: {integrity: sha512-ek0Eyuy6P15LJVeghbWhSrBCj/vJpPXXR+EpaRZqou7achUWL8IdYnMSC5WHAeTWswYQuP2hAZgij/bC9fanBg==}
+  /@typescript-eslint/typescript-estree@6.7.2(typescript@4.9.5):
+    resolution: {integrity: sha512-kiJKVMLkoSciGyFU0TOY0fRxnp9qq1AzVOHNeN1+B9erKFCJ4Z8WdjAkKQPP+b1pWStGFqezMLltxO+308dJTQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       typescript: '*'
@@ -7090,20 +7052,20 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 6.10.0
-      '@typescript-eslint/visitor-keys': 6.10.0
+      '@typescript-eslint/types': 6.7.2
+      '@typescript-eslint/visitor-keys': 6.7.2
       debug: 4.3.4(supports-color@9.2.2)
       globby: 11.1.0
       is-glob: 4.0.3
       semver: 7.5.4
-      ts-api-utils: 1.0.3(typescript@5.0.4)
-      typescript: 5.0.4
+      ts-api-utils: 1.0.3(typescript@4.9.5)
+      typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
-    dev: true
+    dev: false
 
-  /@typescript-eslint/typescript-estree@6.7.2(typescript@4.9.5):
-    resolution: {integrity: sha512-kiJKVMLkoSciGyFU0TOY0fRxnp9qq1AzVOHNeN1+B9erKFCJ4Z8WdjAkKQPP+b1pWStGFqezMLltxO+308dJTQ==}
+  /@typescript-eslint/typescript-estree@6.9.1(typescript@5.0.4):
+    resolution: {integrity: sha512-U+mUylTHfcqeO7mLWVQ5W/tMLXqVpRv61wm9ZtfE5egz7gtnmqVIw9ryh0mgIlkKk9rZLY3UHygsBSdB9/ftyw==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       typescript: '*'
@@ -7111,17 +7073,17 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 6.7.2
-      '@typescript-eslint/visitor-keys': 6.7.2
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/visitor-keys': 6.9.1
       debug: 4.3.4(supports-color@9.2.2)
       globby: 11.1.0
       is-glob: 4.0.3
       semver: 7.5.4
-      ts-api-utils: 1.0.3(typescript@4.9.5)
-      typescript: 4.9.5
+      ts-api-utils: 1.0.3(typescript@5.0.4)
+      typescript: 5.0.4
     transitivePeerDependencies:
       - supports-color
-    dev: false
+    dev: true
 
   /@typescript-eslint/utils@5.59.9(eslint@8.42.0)(typescript@4.9.5):
     resolution: {integrity: sha512-1PuMYsju/38I5Ggblaeb98TOoUvjhRvLpLa1DoTOFaLWqaXl/1iQ1eGurTXgBY58NUdtfTXKP5xBq7q9NDaLKg==}
@@ -7137,7 +7099,7 @@ packages:
       '@typescript-eslint/typescript-estree': 5.59.9(typescript@4.9.5)
       eslint: 8.42.0
       eslint-scope: 5.1.1
-      semver: 7.5.1
+      semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -7157,7 +7119,7 @@ packages:
       '@typescript-eslint/typescript-estree': 5.59.9(typescript@5.0.3)
       eslint: 8.49.0
       eslint-scope: 5.1.1
-      semver: 7.5.1
+      semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -7223,8 +7185,8 @@ packages:
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@6.10.0(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-v+pJ1/RcVyRc0o4wAGux9x42RHmAjIGzPRo538Z8M1tVx6HOnoQBCX/NoadHQlZeC+QO2yr4nNSFWOoraZCAyg==}
+  /@typescript-eslint/utils@6.7.2(eslint@8.49.0)(typescript@4.9.5):
+    resolution: {integrity: sha512-ZCcBJug/TS6fXRTsoTkgnsvyWSiXwMNiPzBUani7hDidBdj1779qwM1FIAmpH4lvlOZNF3EScsxxuGifjpLSWQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -7232,18 +7194,18 @@ packages:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.49.0)
       '@types/json-schema': 7.0.13
       '@types/semver': 7.5.1
-      '@typescript-eslint/scope-manager': 6.10.0
-      '@typescript-eslint/types': 6.10.0
-      '@typescript-eslint/typescript-estree': 6.10.0(typescript@5.0.4)
+      '@typescript-eslint/scope-manager': 6.7.2
+      '@typescript-eslint/types': 6.7.2
+      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
       eslint: 8.49.0
       semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
-    dev: true
+    dev: false
 
-  /@typescript-eslint/utils@6.7.2(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-ZCcBJug/TS6fXRTsoTkgnsvyWSiXwMNiPzBUani7hDidBdj1779qwM1FIAmpH4lvlOZNF3EScsxxuGifjpLSWQ==}
+  /@typescript-eslint/utils@6.9.1(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-L1T0A5nFdQrMVunpZgzqPL6y2wVreSyHhKGZryS6jrEN7bD9NplVAyMryUhXsQ4TWLnZmxc2ekar/lSGIlprCA==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -7251,15 +7213,15 @@ packages:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.49.0)
       '@types/json-schema': 7.0.13
       '@types/semver': 7.5.1
-      '@typescript-eslint/scope-manager': 6.7.2
-      '@typescript-eslint/types': 6.7.2
-      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.0.4)
       eslint: 8.49.0
       semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
-    dev: false
+    dev: true
 
   /@typescript-eslint/visitor-keys@5.59.9:
     resolution: {integrity: sha512-bT7s0td97KMaLwpEBckbzj/YohnvXtqbe2XgqNvTl6RJVakY5mvENOTPvw5u66nljfZxthESpDozs86U+oLY8Q==}
@@ -7277,14 +7239,6 @@ packages:
       eslint-visitor-keys: 3.4.3
     dev: true
 
-  /@typescript-eslint/visitor-keys@6.10.0:
-    resolution: {integrity: sha512-xMGluxQIEtOM7bqFCo+rCMh5fqI+ZxV5RUUOa29iVPz1OgCZrtc7rFnz5cLUazlkPKYqX+75iuDq7m0HQ48nCg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dependencies:
-      '@typescript-eslint/types': 6.10.0
-      eslint-visitor-keys: 3.4.3
-    dev: true
-
   /@typescript-eslint/visitor-keys@6.7.2:
     resolution: {integrity: sha512-uVw9VIMFBUTz8rIeaUT3fFe8xIUx8r4ywAdlQv1ifH+6acn/XF8Y6rwJ7XNmkNMDrTW+7+vxFFPIF40nJCVsMQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -7293,6 +7247,14 @@ packages:
       eslint-visitor-keys: 3.4.1
     dev: false
 
+  /@typescript-eslint/visitor-keys@6.9.1:
+    resolution: {integrity: sha512-MUaPUe/QRLEffARsmNfmpghuQkW436DvESW+h+M52w0coICHRfD6Np9/K6PdACwnrq1HmuLl+cSPZaJmeVPkSw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.1
+      eslint-visitor-keys: 3.4.3
+    dev: true
+
   /@vanilla-extract/babel-plugin-debug-ids@1.0.3:
     resolution: {integrity: sha512-vm4jYu1xhSa6ofQ9AhIpR3DkAp4c+eoR1Rpm8/TQI4DmWbmGbOjYRcqV0aWsfaIlNhN4kFuxFMKBNN9oG6iRzA==}
     dependencies:
@@ -7665,7 +7627,7 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       es-abstract: 1.22.1
       es-array-method-boxes-properly: 1.0.0
       get-intrinsic: 1.2.1
@@ -7687,7 +7649,7 @@ packages:
     dependencies:
       array-buffer-byte-length: 1.0.0
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       get-intrinsic: 1.2.1
       is-array-buffer: 3.0.2
       is-shared-array-buffer: 1.0.2
@@ -7711,7 +7673,6 @@ packages:
     resolution: {integrity: sha512-xvsWESUJn0JN421Xb9MQw6AsMHRCUknCe0Wjlxvjud80mU4E6hQf1A6NzQKcYNmYw62MfzEtXc+badstZP3JpQ==}
     dependencies:
       printable-characters: 1.0.42
-    dev: false
 
   /assert@2.0.0:
     resolution: {integrity: sha512-se5Cd+js9dXJnu6Ag2JFc00t+HmHOen+8Q+L7O9zI0PqQXr20uk2J0XQqMxZEeo5U50o8Nvmmx7dZrl+Ufr35A==}
@@ -8069,7 +8030,6 @@ packages:
 
   /blake3-wasm@2.1.5:
     resolution: {integrity: sha512-F1+K8EbfOZE49dtoPtmxUQrpXaBIl3ICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUg2ka5g==}
-    dev: false
 
   /blueimp-md5@2.19.0:
     resolution: {integrity: sha512-DRQrD6gJyy8FbiE4s+bDoXS9hiW3Vbx5uCdwvcCf3zLHL+Iv7LtGHLpr+GZV8rHG8tK766FGYBwRbu8pELTt+w==}
@@ -8340,7 +8300,6 @@ packages:
       tslib: 2.5.3
     transitivePeerDependencies:
       - supports-color
-    dev: false
     patched: true
 
   /capnpc-ts@0.7.0:
@@ -8764,7 +8723,7 @@ packages:
       js-string-escape: 1.0.1
       lodash: 4.17.21
       md5-hex: 3.0.1
-      semver: 7.5.1
+      semver: 7.5.4
       well-known-symbols: 2.0.0
     dev: true
 
@@ -9053,7 +9012,6 @@ packages:
 
   /data-uri-to-buffer@2.0.2:
     resolution: {integrity: sha512-ND9qDTLc6diwj+Xe5cdAgVTbLVdXbtxTJRXRhli8Mowuaan+0EJOtdqJ0QCHNSSPyoXGx9HX2/VMnKeC34AChA==}
-    dev: false
 
   /data-uri-to-buffer@3.0.1:
     resolution: {integrity: sha512-WboRycPNsVw3B3TL559F7kuBUM4d8CgMEvk6xEJlOp7OBPjt6G7z8WMWlD2rOFZLk6OYfFIUGsCOWzcQH9K2og==}
@@ -9245,7 +9203,6 @@ packages:
       get-intrinsic: 1.2.1
       gopd: 1.0.1
       has-property-descriptors: 1.0.0
-    dev: false
 
   /define-lazy-prop@2.0.0:
     resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
@@ -9271,7 +9228,6 @@ packages:
       define-data-property: 1.1.0
       has-property-descriptors: 1.0.0
       object-keys: 1.1.1
-    dev: false
 
   /define-property@0.2.5:
     resolution: {integrity: sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA==}
@@ -9914,13 +9870,13 @@ packages:
       eslint: 8.49.0
     dev: true
 
-  /eslint-config-turbo@1.10.16(eslint@8.49.0):
-    resolution: {integrity: sha512-O3NQI72bQHV7FvSC6lWj66EGx8drJJjuT1kuInn6nbMLOHdMBhSUX/8uhTAlHRQdlxZk2j9HtgFCIzSc93w42g==}
+  /eslint-config-turbo@1.10.14(eslint@8.49.0):
+    resolution: {integrity: sha512-ZeB+IcuFXy1OICkLuAplVa0euoYbhK+bMEQd0nH9+Lns18lgZRm33mVz/iSoH9VdUzl/1ZmFmoK+RpZc+8R80A==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
       eslint: 8.49.0
-      eslint-plugin-turbo: 1.10.16(eslint@8.49.0)
+      eslint-plugin-turbo: 1.10.14(eslint@8.49.0)
     dev: false
 
   /eslint-import-resolver-node@0.3.7:
@@ -9986,7 +9942,7 @@ packages:
       - supports-color
     dev: true
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.10.0)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.7.2)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -10007,15 +9963,15 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
       debug: 3.2.7
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.7
     transitivePeerDependencies:
       - supports-color
-    dev: true
+    dev: false
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.7.2)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -10036,13 +9992,13 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
       debug: 3.2.7
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.7
     transitivePeerDependencies:
       - supports-color
-    dev: false
+    dev: true
 
   /eslint-plugin-es@3.0.1(eslint@8.42.0):
     resolution: {integrity: sha512-GUmAsJaN4Fc7Gbtl8uOBlayo2DqhwWvEzykMHSCZHU3XdJ+NSzzZcVhXh3VxX5icqQ+oQdIEawXX8xkR3mIFmQ==}
@@ -10066,7 +10022,7 @@ packages:
       regexpp: 3.2.0
     dev: true
 
-  /eslint-plugin-import@2.26.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0):
+  /eslint-plugin-import@2.26.0(@typescript-eslint/parser@6.7.2)(eslint@8.49.0):
     resolution: {integrity: sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -10076,14 +10032,14 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.10.0(eslint@8.49.0)(typescript@5.0.4)
+      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
       array-includes: 3.1.6
       array.prototype.flat: 1.3.1
       debug: 2.6.9(supports-color@9.2.2)
       doctrine: 2.1.0
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.7
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.10.0)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.7.2)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0)
       has: 1.0.3
       is-core-module: 2.13.0
       is-glob: 4.0.3
@@ -10095,9 +10051,9 @@ packages:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
-    dev: true
+    dev: false
 
-  /eslint-plugin-import@2.26.0(@typescript-eslint/parser@6.7.2)(eslint@8.49.0):
+  /eslint-plugin-import@2.26.0(@typescript-eslint/parser@6.9.1)(eslint@8.49.0):
     resolution: {integrity: sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -10107,14 +10063,14 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.7.2(eslint@8.49.0)(typescript@4.9.5)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.49.0)(typescript@5.0.4)
       array-includes: 3.1.6
       array.prototype.flat: 1.3.1
       debug: 2.6.9(supports-color@9.2.2)
       doctrine: 2.1.0
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.7
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.7.2)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0)
       has: 1.0.3
       is-core-module: 2.13.0
       is-glob: 4.0.3
@@ -10126,7 +10082,7 @@ packages:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
-    dev: false
+    dev: true
 
   /eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.62.0)(eslint-import-resolver-typescript@3.5.5)(eslint@8.42.0):
     resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==}
@@ -10347,8 +10303,8 @@ packages:
       - typescript
     dev: true
 
-  /eslint-plugin-turbo@1.10.16(eslint@8.49.0):
-    resolution: {integrity: sha512-ZjrR88MTN64PNGufSEcM0tf+V1xFYVbeiMeuIqr0aiABGomxFLo4DBkQ7WI4WzkZtWQSIA2sP+yxqSboEfL9MQ==}
+  /eslint-plugin-turbo@1.10.14(eslint@8.49.0):
+    resolution: {integrity: sha512-sBdBDnYr9AjT1g4lR3PBkZDonTrMnR4TvuGv5W0OiF7z9az1rI68yj2UHJZvjkwwcGu5mazWA1AfB0oaagpmfg==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
@@ -10598,7 +10554,6 @@ packages:
 
   /estree-walker@0.6.1:
     resolution: {integrity: sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==}
-    dev: false
 
   /estree-walker@2.0.2:
     resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
@@ -11216,7 +11171,7 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       es-abstract: 1.22.1
       functions-have-names: 1.2.3
 
@@ -11265,17 +11220,11 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: true
 
-  /get-port@7.0.0:
-    resolution: {integrity: sha512-mDHFgApoQd+azgMdwylJrv2DX47ywGq1i5VFJE7fZ0dttNq3iQMfsU4IvEgBHojA3KqEudyu7Vq+oN8kNaNkWw==}
-    engines: {node: '>=16'}
-    dev: true
-
   /get-source@2.0.12:
     resolution: {integrity: sha512-X5+4+iD+HoSeEED+uwrQ07BOQr0kEDFMVqqpBuI+RaZBpBpHCuXxo70bjar6f0b0u/DQJsJ7ssurpP0V60Az+w==}
     dependencies:
       data-uri-to-buffer: 2.0.2
       source-map: 0.6.1
-    dev: false
 
   /get-stream@4.1.0:
     resolution: {integrity: sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==}
@@ -12001,7 +11950,7 @@ packages:
       mute-stream: 0.0.8
       ora: 5.4.1
       run-async: 2.4.1
-      rxjs: 7.8.1
+      rxjs: 7.8.0
       string-width: 4.2.3
       strip-ansi: 6.0.1
       through: 2.3.8
@@ -13565,7 +13514,6 @@ packages:
     resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==}
     dependencies:
       sourcemap-codec: 1.4.8
-    dev: false
 
   /magic-string@0.30.3:
     resolution: {integrity: sha512-B7xGbll2fG/VjP+SWg4sX3JynwIU0mjoTc6MPpKNuIvftk6u6vqhDnk1R80b8C2GBR6ywqy+1DcKBrevBg+bmw==}
@@ -14172,6 +14120,29 @@ packages:
     engines: {node: '>=4'}
     dev: false
 
+  /miniflare@3.20231030.0:
+    resolution: {integrity: sha512-iCg1dNauUG+kNp7jizcNmV/1XFItuTDvD/6xIC34PrszgKxYCbBO2R72y5NEDJTwaqr5ohQI/320wuJ8GEe7nQ==}
+    engines: {node: '>=16.13'}
+    hasBin: true
+    dependencies:
+      acorn: 8.10.0
+      acorn-walk: 8.2.0
+      capnp-ts: 0.7.0(patch_hash=l4yimnxyvkiyj6alnps2ec3sii)
+      exit-hook: 2.2.1
+      glob-to-regexp: 0.4.1
+      source-map-support: 0.5.21
+      stoppable: 1.1.0
+      undici: 5.23.0
+      workerd: 1.20231030.0
+      ws: 8.13.0
+      youch: 3.2.3
+      zod: 3.22.3
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /minimatch@3.1.2:
     resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
     dependencies:
@@ -14453,7 +14424,6 @@ packages:
   /node-forge@1.3.0:
     resolution: {integrity: sha512-08ARB91bUi6zNKzVmaj3QO7cr397uiDT2nJ63cHjyNtCTWIgvS47j3eT0WfzUwS9+6Z5YshRaoasFkXCKrIYbA==}
     engines: {node: '>= 6.13.0'}
-    dev: false
 
   /node-int64@0.4.0:
     resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
@@ -15210,8 +15180,8 @@ packages:
       irregular-plurals: 3.5.0
     dev: true
 
-  /pnpm@8.10.2:
-    resolution: {integrity: sha512-B4IJPVumx62UYggbwe8HdQFqS0EJ7KHh/tzqbxEBQ69fUJk9s2xCfU+oxivjkgoyJNsS2nGdJGyhndnxgEjDPA==}
+  /pnpm@8.10.0:
+    resolution: {integrity: sha512-nCy4Pyts9qJdjFgwC/mRl8fvO+hM8+dm8pBUtAuDtC+Kq6b8wxSp7PJ8APfOgKdXu0xgiADnrb4tKdxccFb1vg==}
     engines: {node: '>=16.14'}
     hasBin: true
     dev: true
@@ -15427,7 +15397,6 @@ packages:
 
   /printable-characters@1.0.42:
     resolution: {integrity: sha512-dKp+C4iXWK4vVYZmYSd0KBH5F/h1HoZRsbJ82AVKRO3PEo8L4lBS/vLwhVtpwwuYcoIsVY+1JYKR268yn480uQ==}
-    dev: false
 
   /prism-react-renderer@1.3.5(react@18.2.0):
     resolution: {integrity: sha512-IJ+MSwBWKG+SM3b2SUfdrhC+gu01QkV2KmRQgREThBfSQRoufqRfxfHUxpG1WcaFjP+kojcFyO9Qqtpgt3qLCg==}
@@ -16288,19 +16257,16 @@ packages:
       estree-walker: 0.6.1
       magic-string: 0.25.9
       rollup-pluginutils: 2.8.2
-    dev: false
 
   /rollup-plugin-node-polyfills@0.2.1:
     resolution: {integrity: sha512-4kCrKPTJ6sK4/gLL/U5QzVT8cxJcofO0OU74tnB19F40cmuAKSzH5/siithxlofFEjwvw1YAhPmbvGNA6jEroA==}
     dependencies:
       rollup-plugin-inject: 3.0.2
-    dev: false
 
   /rollup-pluginutils@2.8.2:
     resolution: {integrity: sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==}
     dependencies:
       estree-walker: 0.6.1
-    dev: false
 
   /rollup@3.25.1:
     resolution: {integrity: sha512-tywOR+rwIt5m2ZAWSe5AIJcTat8vGlnPFAv15ycCrw33t6iFsXZ6mzHVFh2psSjxQPmI+xgzMZZizUAukBI4aQ==}
@@ -16435,7 +16401,6 @@ packages:
     engines: {node: '>=10'}
     dependencies:
       node-forge: 1.3.0
-    dev: false
 
   /semiver@1.1.0:
     resolution: {integrity: sha512-QNI2ChmuioGC1/xjyYwyZYADILWyW6AmS1UH6gDj/SFUUUS4MBAWs/7mxnkRPc/F4iHezDP+O8t0dO8WHiEOdg==}
@@ -16468,6 +16433,7 @@ packages:
     hasBin: true
     dependencies:
       lru-cache: 6.0.0
+    dev: true
 
   /semver@7.5.4:
     resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==}
@@ -16819,7 +16785,6 @@ packages:
   /sourcemap-codec@1.4.8:
     resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==}
     deprecated: Please use @jridgewell/sourcemap-codec instead
-    dev: false
 
   /space-separated-tokens@2.0.2:
     resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
@@ -16898,7 +16863,6 @@ packages:
     dependencies:
       as-table: 1.0.55
       get-source: 2.0.12
-    dev: false
 
   /standard-as-callback@2.1.0:
     resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==}
@@ -16924,7 +16888,6 @@ packages:
   /stoppable@1.1.0:
     resolution: {integrity: sha512-KXDYZ9dszj6bzvnEMRYvxgeTHU74QBFL54XKtP3nyMuJ81CFYtABZ3bAzL2EdFUaEwJOBOgENyFj3R7oTzDyyw==}
     engines: {node: '>=4', npm: '>=6'}
-    dev: false
 
   /stream-shift@1.0.1:
     resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==}
@@ -17010,21 +16973,21 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       es-abstract: 1.22.1
 
   /string.prototype.trimend@1.0.6:
     resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       es-abstract: 1.22.1
 
   /string.prototype.trimstart@1.0.6:
     resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.0
+      define-properties: 1.2.1
       es-abstract: 1.22.1
 
   /string_decoder@0.10.31:
@@ -18459,7 +18422,33 @@ packages:
       '@cloudflare/workerd-linux-64': 1.20231030.0
       '@cloudflare/workerd-linux-arm64': 1.20231030.0
       '@cloudflare/workerd-windows-64': 1.20231030.0
-    dev: false
+
+  /wrangler@3.16.0:
+    resolution: {integrity: sha512-MIx35sSdFKE3hnfWB6xWUnrt3OiyKK+PQnc9kFLjksLESX0tLmEk1gdvThYHliY90kkelS+nbH48SUGTFAI5BA==}
+    engines: {node: '>=16.17.0'}
+    hasBin: true
+    dependencies:
+      '@cloudflare/kv-asset-handler': 0.2.0
+      '@esbuild-plugins/node-globals-polyfill': 0.2.3(esbuild@0.17.19)
+      '@esbuild-plugins/node-modules-polyfill': 0.2.2(esbuild@0.17.19)
+      blake3-wasm: 2.1.5
+      chokidar: 3.5.3
+      esbuild: 0.17.19
+      miniflare: 3.20231030.0
+      nanoid: 3.3.6
+      path-to-regexp: 6.2.0
+      resolve.exports: 2.0.2
+      selfsigned: 2.1.1
+      source-map: 0.6.1
+      source-map-support: 0.5.21
+      xxhash-wasm: 1.0.1
+    optionalDependencies:
+      fsevents: 2.3.2
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    dev: true
 
   /wrap-ansi@6.2.0:
     resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
@@ -18539,8 +18528,8 @@ packages:
         optional: true
     dev: true
 
-  /ws@8.14.2:
-    resolution: {integrity: sha512-wEBG1ftX4jcglPxgFCMJmZ2PLtSbJ2Peg6TmpJFTbe9GZYOQCDPdMYu/Tm0/bGZkw8paZnJY45J4K2PZrLYq8g==}
+  /ws@8.13.0:
+    resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -18610,7 +18599,6 @@ packages:
 
   /xxhash-wasm@1.0.1:
     resolution: {integrity: sha512-Lc9CTvDrH2vRoiaUzz25q7lRaviMhz90pkx6YxR9EPYtF99yOJnv2cB+CQ0hp/TLoqrUsk8z/W2EN31T568Azw==}
-    dev: false
 
   /y18n@4.0.3:
     resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==}
@@ -18730,7 +18718,6 @@ packages:
       cookie: 0.5.0
       mustache: 4.2.0
       stacktracey: 2.1.8
-    dev: false
 
   /z-schema@5.0.3:
     resolution: {integrity: sha512-sGvEcBOTNum68x9jCpCVGPFJ6mWnkD0YxOcddDlJHRx3tKdB2q8pCHExMVZo/AV/6geuVJXG7hljDaWG8+5GDw==}