diff --git a/.changeset/serious-toys-repeat.md b/.changeset/serious-toys-repeat.md
new file mode 100644
index 00000000000..bcb2b71609a
--- /dev/null
+++ b/.changeset/serious-toys-repeat.md
@@ -0,0 +1,12 @@
+---
+"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
new file mode 100644
index 00000000000..1521c8b7652
--- /dev/null
+++ b/fixtures/dev-env/.gitignore
@@ -0,0 +1 @@
+dist
diff --git a/fixtures/dev-env/package.json b/fixtures/dev-env/package.json
new file mode 100644
index 00000000000..11103f0de5a
--- /dev/null
+++ b/fixtures/dev-env/package.json
@@ -0,0 +1,25 @@
+{
+	"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
new file mode 100644
index 00000000000..a30da78cbad
--- /dev/null
+++ b/fixtures/dev-env/tests/index.test.ts
@@ -0,0 +1,556 @@
+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
new file mode 100644
index 00000000000..c35cdd8fea5
--- /dev/null
+++ b/fixtures/dev-env/tests/tsconfig.json
@@ -0,0 +1,12 @@
+{
+	"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 a2894af5b17..8148ae47085 100644
--- a/packages/edge-preview-authenticated-proxy/tests/index.test.ts
+++ b/packages/edge-preview-authenticated-proxy/tests/index.test.ts
@@ -74,7 +74,6 @@ 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,
 		});
 	});
 
@@ -92,7 +91,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:6756/exchange"
+				`http://127.0.0.1:${remote.port}/exchange`
 			)}`,
 			{
 				method: "POST",
@@ -117,9 +116,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:6756/prewarm"
+				`http://127.0.0.1:${remote.port}/prewarm`
 			)}&remote=${encodeURIComponent(
-				"http://127.0.0.1:6756"
+				`http://127.0.0.1:${remote.port}`
 			)}&suffix=${encodeURIComponent("/hello?world")}`,
 			{
 				method: "GET",
@@ -151,17 +150,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.headers.find(([h]: [string]) => h === "cf-workers-preview-token")[1]
-		).toBe(token);
-		expect(json.url).toMatchInlineSnapshot('"http://127.0.0.1:6756/"');
+		expect(json).toMatchObject({
+			url: `http://127.0.0.1:${remote.port}/`,
+			headers: expect.arrayContaining([["cf-workers-preview-token", token]]),
+		});
 	});
 	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:6756/prewarm"
+				`http://127.0.0.1:${remote.port}/prewarm`
 			)}&remote=${encodeURIComponent(
-				"http://127.0.0.1:6756"
+				`http://127.0.0.1:${remote.port}`
 			)}&suffix=${encodeURIComponent("/hello?world")}`,
 			{
 				method: "GET",
@@ -193,10 +192,12 @@ compatibility_date = "2023-01-01"
 		);
 
 		const json = (await resp.json()) as { headers: string[][]; url: string };
-		expect(Object.fromEntries([...json.headers])).toMatchObject({
-			"cf-workers-preview-token": "TEST_TOKEN",
+		expect(json).toMatchObject({
+			url: `http://127.0.0.1:${remote.port}/`,
+			headers: expect.arrayContaining([
+				["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 c7d6b30416e..8738c6659f9 100644
--- a/packages/wrangler/.eslintrc.js
+++ b/packages/wrangler/.eslintrc.js
@@ -10,6 +10,7 @@ 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 b54836daa45..fbb2e7c543f 100644
--- a/packages/wrangler/e2e/tsconfig.json
+++ b/packages/wrangler/e2e/tsconfig.json
@@ -3,6 +3,6 @@
 	"compilerOptions": {
 		"types": ["node"]
 	},
-	"include": ["**/*.ts"],
+	"include": ["**/*.ts", "../src/*.d.ts"],
 	"exclude": []
 }
diff --git a/packages/wrangler/package.json b/packages/wrangler/package.json
index 558e8413bfc..22fdd8ee25f 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 --runInBand --testTimeout=50000 --watch",
+		"test:watch": "pnpm run test --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 62ebc01c98d..11741c74707 100644
--- a/packages/wrangler/scripts/bundle.ts
+++ b/packages/wrangler/scripts/bundle.ts
@@ -1,14 +1,17 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { build, context } from "esbuild";
+import * as esbuild from "esbuild";
 import { EXTERNAL_DEPENDENCIES } from "./deps";
-import type { BuildOptions } from "esbuild";
+import type { BuildOptions, Plugin, BuildContext } 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(".");
@@ -52,13 +55,14 @@ async function buildMain(flags: BuildFlags = {}) {
 				? { ALGOLIA_PUBLIC_KEY: `"${process.env.ALGOLIA_PUBLIC_KEY}"` }
 				: {}),
 		},
+		plugins: [embedWorkersPlugin],
 	};
 
 	if (flags.watch) {
-		const ctx = await context(options);
+		const ctx = await esbuild.context(options);
 		await ctx.watch();
 	} else {
-		await build(options);
+		await esbuild.build(options);
 	}
 
 	// Copy `yoga-layout` `.wasm` file
@@ -74,14 +78,63 @@ 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 (process.argv.includes("--watch")) {
+	if (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 746d2f8a379..955d1022d78 100644
--- a/packages/wrangler/src/__tests__/api-devregistry.test.ts
+++ b/packages/wrangler/src/__tests__/api-devregistry.test.ts
@@ -13,6 +13,8 @@ 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(
@@ -24,6 +26,8 @@ describe("multi-worker testing", () => {
 				},
 			}
 		);
+		workers.push(childWorker);
+
 		parentWorker = await unstable_dev(
 			"src/__tests__/helpers/worker-scripts/parent-worker.js",
 			{
@@ -33,11 +37,13 @@ describe("multi-worker testing", () => {
 				},
 			}
 		);
+		workers.push(parentWorker);
 	});
 
 	afterAll(async () => {
-		await childWorker.stop();
-		await parentWorker.stop();
+		for (const worker of workers) {
+			await worker.stop();
+		}
 	});
 
 	it("parentWorker and childWorker should be added devRegistry", async () => {
@@ -81,13 +87,15 @@ 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 (/\[mf:inf].+GET.+\/.+200.+OK/.test(String(args))) requestResolve();
+				if (/\[wrangler.*:inf].+GET.+\/.+200.+OK/.test(String(args)))
+					requestResolve();
 			})
 		);
 
 		async function startWorker() {
-			return await unstable_dev(
+			const worker = await unstable_dev(
 				"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 				{
 					// We need the wrangler.toml config to specify a Worker name
@@ -100,29 +108,27 @@ describe("multi-worker testing", () => {
 					},
 				}
 			);
+
+			workers.push(worker);
+
+			return worker;
 		}
 
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		let worker: any;
-		try {
-			worker = await startWorker();
+		let 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);
 
-			expect(logs).not.toMatch(
-				/Failed to register worker in local service registry/
-			);
+		await requestPromise;
 
-			await requestPromise;
-		} finally {
-			await worker?.stop();
-		}
+		expect(logs).not.toMatch(
+			/Failed to register worker in local service registry/
+		);
 	}, 10000);
 });
diff --git a/packages/wrangler/src/__tests__/dev.test.tsx b/packages/wrangler/src/__tests__/dev.test.tsx
index d38b9f20777..45e4e0dc374 100644
--- a/packages/wrangler/src/__tests__/dev.test.tsx
+++ b/packages/wrangler/src/__tests__/dev.test.tsx
@@ -878,6 +878,7 @@ 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",
 			});
@@ -896,6 +897,7 @@ 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 e3d63a2cd37..f6168d6200e 100644
--- a/packages/wrangler/src/__tests__/jest.setup.ts
+++ b/packages/wrangler/src/__tests__/jest.setup.ts
@@ -24,9 +24,10 @@ 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().mockImplementation(async (options) => options.port),
+		default: jest.fn(getPort),
 	};
 });
 
@@ -101,6 +102,12 @@ 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}
 				`
@@ -228,3 +235,34 @@ 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 d4bfaee1276..2d55dc595a8 100644
--- a/packages/wrangler/src/api/dev.ts
+++ b/packages/wrangler/src/api/dev.ts
@@ -7,6 +7,7 @@ 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";
 
@@ -75,6 +76,7 @@ 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>;
@@ -128,7 +130,11 @@ export async function unstable_dev(
 		);
 	}
 
-	type ReadyInformation = { address: string; port: number };
+	type ReadyInformation = {
+		address: string;
+		port: number;
+		proxyData: ProxyData;
+	};
 	let readyResolve: (info: ReadyInformation) => void;
 	const readyPromise = new Promise<ReadyInformation>((resolve) => {
 		readyResolve = resolve;
@@ -152,8 +158,8 @@ export async function unstable_dev(
 		forceLocal,
 		liveReload,
 		showInteractiveDevSession,
-		onReady: (address, port) => {
-			readyResolve({ address, port });
+		onReady: (address, port, proxyData) => {
+			readyResolve({ address, port, proxyData });
 		},
 		config: options?.config,
 		env: options?.env,
@@ -163,7 +169,7 @@ export async function unstable_dev(
 		compatibilityDate: options?.compatibilityDate,
 		compatibilityFlags: options?.compatibilityFlags,
 		ip: options?.ip,
-		inspectorPort: options?.inspectorPort,
+		inspectorPort: options?.inspectorPort ?? 0,
 		v: undefined,
 		localProtocol: options?.localProtocol,
 		assets: options?.assets,
@@ -203,10 +209,11 @@ 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 } = await readyPromise;
+		const { port, address, proxyData } = await readyPromise;
 		return {
 			port,
 			address,
+			proxyData,
 			stop: devServer.stop,
 			fetch: async (input?: RequestInfo, init?: RequestInit) => {
 				return await fetch(
@@ -227,10 +234,11 @@ 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 } = await readyPromise;
+		const { port, address, proxyData } = 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 2cf99840526..dac524fe319 100644
--- a/packages/wrangler/src/api/index.ts
+++ b/packages/wrangler/src/api/index.ts
@@ -9,3 +9,4 @@ 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
new file mode 100644
index 00000000000..7bd9b689831
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/BaseController.ts
@@ -0,0 +1,40 @@
+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
new file mode 100644
index 00000000000..d78cc135bce
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/BundlerController.ts
@@ -0,0 +1,44 @@
+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
new file mode 100644
index 00000000000..74aa66456f2
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/ConfigController.ts
@@ -0,0 +1,42 @@
+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
new file mode 100644
index 00000000000..b110a720790
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/DevEnv.ts
@@ -0,0 +1,185 @@
+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
new file mode 100644
index 00000000000..699070b1456
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts
@@ -0,0 +1,41 @@
+// 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
new file mode 100644
index 00000000000..7bfc32be7fb
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/NotImplementedError.ts
@@ -0,0 +1,15 @@
+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
new file mode 100644
index 00000000000..d07625b4cf2
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/ProxyController.ts
@@ -0,0 +1,526 @@
+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
new file mode 100644
index 00000000000..71f289b338c
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/RemoteRuntimeController.ts
@@ -0,0 +1,41 @@
+// 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
new file mode 100644
index 00000000000..b459971997f
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/bundle-allowed-paths.ts
@@ -0,0 +1,99 @@
+/**
+ * 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
new file mode 100644
index 00000000000..8a3afb85a63
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/devtools.ts
@@ -0,0 +1,41 @@
+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
new file mode 100644
index 00000000000..1c9b6f6e107
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/events.ts
@@ -0,0 +1,150 @@
+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
new file mode 100644
index 00000000000..582a4c3206d
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/index.ts
@@ -0,0 +1,12 @@
+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
new file mode 100644
index 00000000000..b476d38dab4
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/types.ts
@@ -0,0 +1,197 @@
+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
new file mode 100644
index 00000000000..694f0405d31
--- /dev/null
+++ b/packages/wrangler/src/api/startDevWorker/utils.ts
@@ -0,0 +1,43 @@
+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 0c062f57ddd..13b57085500 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 } from "./api";
+import { unstable_dev, unstable_pages, DevEnv as unstable_DevEnv } 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 };
+export { unstable_dev, unstable_pages, unstable_DevEnv };
 export type { UnstableDevWorker, UnstableDevOptions };
diff --git a/packages/wrangler/src/dev.tsx b/packages/wrangler/src/dev.tsx
index 868ea01858b..b64136ad4dc 100644
--- a/packages/wrangler/src/dev.tsx
+++ b/packages/wrangler/src/dev.tsx
@@ -26,6 +26,7 @@ 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";
@@ -340,7 +341,7 @@ export type StartDevOptions = DevArguments &
 		forceLocal?: boolean;
 		disableDevRegistry?: boolean;
 		enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
-		onReady?: (ip: string, port: number) => void;
+		onReady?: (ip: string, port: number, proxyData: ProxyData) => void;
 		showInteractiveDevSession?: boolean;
 		updateCheck?: boolean;
 	};
diff --git a/packages/wrangler/src/dev/dev.tsx b/packages/wrangler/src/dev/dev.tsx
index dd725e63611..564cfcd0267 100644
--- a/packages/wrangler/src/dev/dev.tsx
+++ b/packages/wrangler/src/dev/dev.tsx
@@ -5,10 +5,17 @@ import { watch } from "chokidar";
 import clipboardy from "clipboardy";
 import commandExists from "command-exists";
 import { Box, Text, useApp, useInput, useStdin } from "ink";
-import React, { useEffect, useRef, useState } from "react";
+import React, {
+	useCallback,
+	useEffect,
+	useMemo,
+	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,
@@ -24,6 +31,7 @@ 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";
@@ -32,6 +40,7 @@ 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,
@@ -157,7 +166,9 @@ export type DevProps = {
 	host: string | undefined;
 	routes: Route[] | undefined;
 	inspect: boolean;
-	onReady: ((ip: string, port: number) => void) | undefined;
+	onReady:
+		| ((ip: string, port: number, proxyData: ProxyData) => void)
+		| undefined;
 	showInteractiveDevSession: boolean | undefined;
 	forceLocal: boolean | undefined;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
@@ -204,12 +215,12 @@ function InteractiveDevSession(props: DevProps) {
 
 	useTunnel(toggles.tunnel);
 
-	const onReady = (newIp: string, newPort: number) => {
+	const onReady = (newIp: string, newPort: number, proxyData: ProxyData) => {
 		if (newIp !== props.initialIp || newPort !== props.initialPort) {
 			ip = newIp;
 			port = newPort;
 			if (props.onReady) {
-				props.onReady(newIp, newPort);
+				props.onReady(newIp, newPort, proxyData);
 			}
 		}
 	};
@@ -247,7 +258,60 @@ type DevSessionProps = DevProps & {
 };
 
 function DevSession(props: DevSessionProps) {
-	useCustomBuild(props.entry, props.build);
+	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);
 
 	const directory = useTmpDir(props.projectRoot);
 
@@ -257,6 +321,13 @@ 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,
@@ -286,7 +357,11 @@ 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 (
@@ -298,7 +373,24 @@ function DevSession(props: DevSessionProps) {
 		);
 	}
 
-	const announceAndOnReady: typeof props.onReady = (finalIp, finalPort) => {
+	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);
+
 		if (process.send) {
 			process.send(
 				JSON.stringify({
@@ -309,8 +401,17 @@ function DevSession(props: DevSessionProps) {
 			);
 		}
 
+		if (bundle) {
+			devEnv.proxy.onReloadComplete({
+				type: "reloadComplete",
+				config: startDevWorkerOptions,
+				bundle,
+				proxyData,
+			});
+		}
+
 		if (props.onReady) {
-			props.onReady(finalIp, finalPort);
+			props.onReady(finalIp, finalPort, proxyData);
 		}
 	};
 
@@ -325,8 +426,8 @@ function DevSession(props: DevSessionProps) {
 			bindings={props.bindings}
 			workerDefinitions={workerDefinitions}
 			assetPaths={props.assetPaths}
-			initialPort={props.initialPort}
-			initialIp={props.initialIp}
+			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
 			rules={props.rules}
 			inspectorPort={props.inspectorPort}
 			runtimeInspectorPort={props.runtimeInspectorPort}
@@ -334,7 +435,7 @@ function DevSession(props: DevSessionProps) {
 			liveReload={props.liveReload}
 			crons={props.crons}
 			queueConsumers={props.queueConsumers}
-			localProtocol={props.localProtocol}
+			localProtocol={"http"} // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
 			localUpstream={props.localUpstream}
 			inspect={props.inspect}
 			onReady={announceAndOnReady}
@@ -392,7 +493,11 @@ function useTmpDir(projectRoot: string | undefined): string | undefined {
 	return directory;
 }
 
-function useCustomBuild(expectedEntry: Entry, build: Config["build"]): void {
+function useCustomBuild(
+	expectedEntry: Entry,
+	build: Config["build"],
+	onBundleStart: () => void
+): void {
 	useEffect(() => {
 		if (!build.command) return;
 		let watcher: ReturnType<typeof watch> | undefined;
@@ -405,6 +510,7 @@ function useCustomBuild(expectedEntry: Entry, build: Config["build"]): void {
 					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);
 				});
@@ -414,7 +520,7 @@ function useCustomBuild(expectedEntry: Entry, build: Config["build"]): void {
 		return () => {
 			void watcher?.close();
 		};
-	}, [build, expectedEntry]);
+	}, [build, expectedEntry, onBundleStart]);
 }
 
 function sleep(period: number) {
diff --git a/packages/wrangler/src/dev/inspect.ts b/packages/wrangler/src/dev/inspect.ts
index 5732b703c22..605a12cf304 100644
--- a/packages/wrangler/src/dev/inspect.ts
+++ b/packages/wrangler/src/dev/inspect.ts
@@ -1,617 +1,16 @@
 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 path from "node:path";
-import { URL, fileURLToPath, pathToFileURL } from "node:url";
+import { URL, fileURLToPath } from "node:url";
+import path from "path";
 import open from "open";
-import { useEffect, useRef, useState } from "react";
-import WebSocket, { WebSocketServer } from "ws";
-import { version } from "../../package.json";
+import {
+	isAllowedSourceMapPath,
+	isAllowedSourcePath,
+} from "../api/startDevWorker/bundle-allowed-paths";
 import { logger } from "../logger";
-import { getSourceMappedStack } from "../sourcemap";
-import { getAccessToken } from "../user/access";
-import { waitForPortToBeAvailable } from "./proxy";
-import type { SourceMapMetadata } from "../deployment-bundle/bundle";
+import type { EsbuildBundle } from "../dev/use-esbuild";
 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
@@ -646,7 +45,9 @@ const mapConsoleAPIMessageTypeToConsoleMethod: {
 	endGroup: "groupEnd",
 };
 
-function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
+export function logConsoleMessage(
+	evt: Protocol.Runtime.ConsoleAPICalledEvent
+): void {
 	const args: string[] = [];
 	for (const ro of evt.args) {
 		switch (ro.type) {
@@ -786,28 +187,20 @@ function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
 	}
 }
 
-function maybeHandleNetworkLoadResource(
+export function maybeHandleNetworkLoadResource(
 	url: string | URL,
-	sourceMaps: Map<string /* id */, string /* filePath */>,
-	allowedSourcePaths: Set<string /* filePath */>,
+	bundle: EsbuildBundle,
 	tmpDir?: string
 ): string | undefined {
 	if (typeof url === "string") url = new URL(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 (url.protocol !== "file:") return;
+	const filePath = fileURLToPath(url);
 
+	if (isAllowedSourceMapPath(bundle, filePath)) {
 		// Read and parse the source map
 		const sourceMap: RawSourceMap & {
 			x_google_ignoreList?: number[];
-		} = JSON.parse(readFileSync(maybeSourceMapFilePath, "utf-8"));
+		} = JSON.parse(readFileSync(filePath, "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
@@ -827,28 +220,10 @@ 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);
 	}
 
-	// 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);
+	if (isAllowedSourcePath(bundle, filePath)) {
 		return readFileSync(filePath, "utf-8");
 	}
 }
diff --git a/packages/wrangler/src/dev/local.tsx b/packages/wrangler/src/dev/local.tsx
index 73f1d95bb70..803c8bc55c2 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, useState } from "react";
+import { useEffect, useRef } 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;
+	initialPort: number | undefined;
 	initialIp: string;
 	rules: Config["rules"];
 	inspectorPort: number;
@@ -37,7 +37,9 @@ export interface LocalProps {
 	localProtocol: "http" | "https";
 	localUpstream: string | undefined;
 	inspect: boolean;
-	onReady: ((ip: string, port: number) => void) | undefined;
+	onReady:
+		| ((ip: string, port: number, proxyData: ProxyData) => void)
+		| undefined;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
 	testScheduled?: boolean;
 	sourceMapPath: string | undefined;
@@ -115,36 +117,15 @@ export function maybeRegisterLocalWorker(event: ReloadedEvent, name?: string) {
 	});
 }
 
-// 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,
-	});
+	useLocalWorker(props);
+
 	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) {
@@ -177,33 +158,36 @@ 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));
 
-				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);
-				}
+				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
+				);
 			});
 			server.addEventListener("error", ({ error }) => {
 				if (
@@ -254,6 +238,4 @@ function useLocalWorker(props: LocalProps) {
 		},
 		[]
 	);
-
-	return { inspectorUrl };
 }
diff --git a/packages/wrangler/src/dev/miniflare.ts b/packages/wrangler/src/dev/miniflare.ts
index 1c27f24412a..8924ed51e6e 100644
--- a/packages/wrangler/src/dev/miniflare.ts
+++ b/packages/wrangler/src/dev/miniflare.ts
@@ -1,14 +1,7 @@
 import assert from "node:assert";
 import { realpathSync } from "node:fs";
 import path from "node:path";
-import {
-	Log,
-	LogLevel,
-	NoOpLog,
-	TypedEventTarget,
-	Mutex,
-	Miniflare,
-} from "miniflare";
+import { Log, LogLevel, TypedEventTarget, Mutex, Miniflare } from "miniflare";
 import { ModuleTypeToRuleType } from "../deployment-bundle/module-collection";
 import { withSourceURLs } from "../deployment-bundle/source-url";
 import { getHttpsOptions } from "../https-options";
@@ -89,6 +82,11 @@ 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;
@@ -100,7 +98,7 @@ export interface ConfigBundle {
 	bindings: CfWorkerInit["bindings"];
 	workerDefinitions: WorkerRegistry | undefined;
 	assetPaths: AssetPaths | undefined;
-	initialPort: number;
+	initialPort: Port;
 	initialIp: string;
 	rules: Config["rules"];
 	inspectorPort: number;
@@ -114,13 +112,13 @@ export interface ConfigBundle {
 	serviceBindings: Record<string, (_request: Request) => Promise<Response>>;
 }
 
-class WranglerLog extends Log {
+export class WranglerLog extends Log {
 	#warnedCompatibilityDateFallback = false;
 
-	info(message: string) {
+	log(message: string) {
 		// Hide request logs for external Durable Objects proxy worker
 		if (message.includes(EXTERNAL_DURABLE_OBJECTS_WORKER_NAME)) return;
-		super.info(message);
+		super.log(message);
 	}
 
 	warn(message: string) {
@@ -143,19 +141,31 @@ class WranglerLog extends Log {
 	}
 }
 
+export const DEFAULT_WORKER_NAME = "worker";
 function getName(config: ConfigBundle) {
-	return config.name ?? "worker";
+	return config.name ?? DEFAULT_WORKER_NAME;
 }
 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 = logger.loggerLevel.toUpperCase() as Uppercase<LoggerLevel>;
-	if (level === "LOG") level = "INFO";
-	const logLevel = LogLevel[level];
-	return logLevel === LogLevel.NONE ? new NoOpLog() : new WranglerLog(logLevel);
+	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" });
 }
 
 async function buildSourceOptions(
@@ -389,7 +399,7 @@ function buildSitesOptions({ assetPaths }: ConfigBundle) {
 	}
 }
 
-function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
+export 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
@@ -400,7 +410,10 @@ function handleRuntimeStdio(stdout: Readable, stderr: Readable) {
 			const containsLlvmSymbolizerWarning = chunk.includes(
 				"Not symbolizing stack traces because $LLVM_SYMBOLIZER is not set"
 			);
-			const containsHexStack = /stack:( [a-f\d]{9}){3,}/.test(chunk);
+			// 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);
 
 			return containsLlvmSymbolizerWarning || containsHexStack;
 		},
@@ -408,6 +421,9 @@ 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) => {
@@ -427,6 +443,11 @@ 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);
@@ -461,6 +482,11 @@ 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 5961ee534c7..709ded5f020 100644
--- a/packages/wrangler/src/dev/remote.tsx
+++ b/packages/wrangler/src/dev/remote.tsx
@@ -14,12 +14,13 @@ import {
 	requireApiToken,
 	saveAccountToCache,
 } from "../user";
+import { getAccessToken } from "../user/access";
 import {
 	createPreviewSession,
 	createWorkerPreview,
 } from "./create-worker-preview";
-import useInspector from "./inspect";
-import { startPreviewServer, usePreviewServer } from "./proxy";
+import { startPreviewServer } from "./proxy";
+import type { ProxyData } from "../api";
 import type { Route } from "../config/environment";
 import type {
 	CfModule,
@@ -57,7 +58,9 @@ interface RemoteProps {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady?: ((ip: string, port: number) => void) | undefined;
+	onReady?:
+		| ((ip: string, port: number, proxyData: ProxyData) => void)
+		| undefined;
 	sourceMapPath: string | undefined;
 	sendMetrics: boolean | undefined;
 }
@@ -67,7 +70,7 @@ export function Remote(props: RemoteProps) {
 	const accountChoicesRef = useRef<Promise<ChooseAccountItem[]>>();
 	const [accountChoices, setAccountChoices] = useState<ChooseAccountItem[]>();
 
-	const previewToken = useWorker({
+	useWorker({
 		name: props.name,
 		bundle: props.bundle,
 		format: props.format,
@@ -89,29 +92,6 @@ 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.
@@ -173,7 +153,9 @@ interface RemoteWorkerProps {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady: ((ip: string, port: number) => void) | undefined;
+	onReady:
+		| ((ip: string, port: number, proxyData: ProxyData) => void)
+		| undefined;
 	sendMetrics: boolean | undefined;
 	port: number;
 }
@@ -325,7 +307,30 @@ export function useWorker(
 				});
 			}
 			*/
-			onReady?.(props.host || "localhost", props.port);
+			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);
 		}
 		start().catch((err) => {
 			// we want to log the error, but not end the process
@@ -419,7 +424,32 @@ export async function startRemoteServer(props: RemoteProps) {
 		localProtocol: props.localProtocol,
 		localPort: props.port,
 		ip: props.ip,
-		onReady: props.onReady,
+		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);
+		},
 	});
 	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 cb7369c901f..323c81e7eb9 100644
--- a/packages/wrangler/src/dev/start-server.ts
+++ b/packages/wrangler/src/dev/start-server.ts
@@ -2,6 +2,7 @@ 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";
@@ -20,9 +21,10 @@ import {
 import { logger } from "../logger";
 import { getWranglerTmpDir } from "../paths";
 import { localPropsToConfigBundle, maybeRegisterLocalWorker } from "./local";
-import { MiniflareServer } from "./miniflare";
+import { DEFAULT_WORKER_NAME, 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";
@@ -79,6 +81,38 @@ 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,
@@ -108,6 +142,13 @@ 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,
@@ -127,8 +168,25 @@ export async function startDevServer(
 			queueConsumers: props.queueConsumers,
 			localProtocol: props.localProtocol,
 			localUpstream: props.localUpstream,
-			inspect: props.inspect,
-			onReady: props.onReady,
+			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,
+				});
+			},
 			enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
 			usageModel: props.usageModel,
 			workerDefinitions,
@@ -137,7 +195,7 @@ export async function startDevServer(
 
 		return {
 			stop: async () => {
-				await Promise.all([stop(), stopWorkerRegistry()]);
+				await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
 			},
 			// TODO: inspectorUrl,
 		};
@@ -163,14 +221,30 @@ export async function startDevServer(
 			zone: props.zone,
 			host: props.host,
 			routes: props.routes,
-			onReady: props.onReady,
+			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,
+				});
+			},
 			sourceMapPath: bundle?.sourceMapPath,
 			sendMetrics: props.sendMetrics,
 		});
 		return {
 			stop: async () => {
-				stop();
-				await stopWorkerRegistry();
+				await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
 			},
 			// TODO: inspectorUrl,
 		};
@@ -211,7 +285,7 @@ async function runEsbuild({
 	projectRoot,
 }: {
 	entry: Entry;
-	destination: string | undefined;
+	destination: string;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
 	processEntrypoint: boolean;
@@ -232,9 +306,7 @@ async function runEsbuild({
 	local: boolean;
 	doBindings: DurableObjectBindings;
 	projectRoot: string | undefined;
-}): Promise<EsbuildBundle | undefined> {
-	if (!destination) return;
-
+}): Promise<EsbuildBundle> {
 	if (noBundle) {
 		additionalModules = dedupeModulesByName([
 			...((await doFindAdditionalModules(entry, rules)) ?? []),
@@ -322,7 +394,32 @@ export async function startLocalServer(
 		const server = new MiniflareServer();
 		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: {},
+				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);
 			// 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 876dc6963be..4492efac77f 100644
--- a/packages/wrangler/src/dev/use-esbuild.ts
+++ b/packages/wrangler/src/dev/use-esbuild.ts
@@ -57,6 +57,7 @@ export function useEsbuild({
 	testScheduled,
 	experimentalLocal,
 	projectRoot,
+	onBundleStart,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -82,6 +83,7 @@ export function useEsbuild({
 	testScheduled: boolean;
 	experimentalLocal: boolean | undefined;
 	projectRoot: string | undefined;
+	onBundleStart: () => void;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -131,6 +133,9 @@ 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;
@@ -252,6 +257,7 @@ 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 e13f3d0d639..479d5afd4e4 100644
--- a/packages/wrangler/src/https-options.ts
+++ b/packages/wrangler/src/https-options.ts
@@ -1,6 +1,5 @@
 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";
@@ -17,7 +16,7 @@ const ONE_DAY_IN_MS = 86400000;
  *
  * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
  */
-export async function getHttpsOptions() {
+export function getHttpsOptions() {
 	const certDirectory = path.join(getGlobalWranglerConfigPath(), "local-cert");
 	const keyPath = path.join(certDirectory, "key.pem");
 	const certPath = path.join(certDirectory, "cert.pem");
@@ -29,7 +28,7 @@ export async function getHttpsOptions() {
 
 	if (regenerate) {
 		logger.log("Generating new self-signed certificate...");
-		const { key, cert } = await generateCertificate();
+		const { key, cert } = generateCertificate();
 		try {
 			// Write certificate files so we can reuse them later.
 			fs.mkdirSync(certDirectory, { recursive: true });
@@ -67,14 +66,13 @@ function hasCertificateExpired(keyPath: string, certPath: string): boolean {
 /**
  * Generate a new self-signed certificate and cache it in `CERT_ROOT` directory.
  */
-async function generateCertificate() {
+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 = promisify(
+	const generate: typeof import("selfsigned").generate =
 		// eslint-disable-next-line @typescript-eslint/no-var-requires
-		require("selfsigned").generate
-	);
+		require("selfsigned").generate;
 
 	const certAttrs: Attributes = [{ name: "commonName", value: "localhost" }];
 
@@ -109,6 +107,6 @@ async function generateCertificate() {
 		],
 	};
 
-	const { private: key, cert } = await generate(certAttrs, certOptions);
+	const { private: key, cert } = generate(certAttrs, certOptions);
 	return { key, cert };
 }
diff --git a/packages/wrangler/src/worker.d.ts b/packages/wrangler/src/worker.d.ts
new file mode 100644
index 00000000000..1df5a8e911e
--- /dev/null
+++ b/packages/wrangler/src/worker.d.ts
@@ -0,0 +1,4 @@
+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
new file mode 100644
index 00000000000..366fba8ee53
--- /dev/null
+++ b/packages/wrangler/templates/startDevWorker/InspectorProxyWorker.ts
@@ -0,0 +1,608 @@
+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
new file mode 100644
index 00000000000..35a08936bd0
--- /dev/null
+++ b/packages/wrangler/templates/startDevWorker/ProxyWorker.ts
@@ -0,0 +1,252 @@
+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 97381ccef27..3779289b699 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -106,6 +106,30 @@ 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':
@@ -631,7 +655,7 @@ importers:
         version: 8.4.0
       pnpm:
         specifier: ^8.10.0
-        version: 8.10.0
+        version: 8.10.2
       recast:
         specifier: ^0.22.0
         version: 0.22.0
@@ -697,7 +721,7 @@ importers:
         version: 8.49.0
       eslint-config-turbo:
         specifier: latest
-        version: 1.10.14(eslint@8.49.0)
+        version: 1.10.16(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)
@@ -772,7 +796,7 @@ importers:
         version: 1.20231030.0
       ws:
         specifier: ^8.11.0
-        version: 8.13.0
+        version: 8.14.2
       youch:
         specifier: ^3.2.2
         version: 3.2.3
@@ -791,7 +815,7 @@ importers:
         version: 4.20231025.0
       '@microsoft/api-extractor':
         specifier: ^7.36.3
-        version: 7.38.1(@types/node@18.16.10)
+        version: 7.38.2(@types/node@18.16.10)
       '@types/debug':
         specifier: ^4.1.7
         version: 4.1.7
@@ -815,19 +839,19 @@ importers:
         version: 0.5.7
       '@types/stoppable':
         specifier: ^1.1.1
-        version: 1.1.2
+        version: 1.1.3
       '@types/which':
         specifier: ^2.0.1
         version: 2.0.2
       '@types/ws':
         specifier: ^8.5.3
-        version: 8.5.3
+        version: 8.5.9
       '@typescript-eslint/eslint-plugin':
         specifier: ^6.9.0
-        version: 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.49.0)(typescript@5.0.4)
+        version: 6.10.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0)(typescript@5.0.4)
       '@typescript-eslint/parser':
         specifier: ^6.9.0
-        version: 6.9.1(eslint@8.49.0)(typescript@5.0.4)
+        version: 6.10.0(eslint@8.49.0)(typescript@5.0.4)
       ava:
         specifier: ^5.2.0
         version: 5.3.1(@ava/typescript@4.1.0)
@@ -854,7 +878,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.9.1)(eslint@8.49.0)
+        version: 2.26.0(@typescript-eslint/parser@6.10.0)(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)
@@ -937,7 +961,7 @@ importers:
         version: 5.23.0
       wrangler:
         specifier: ^3.5.1
-        version: 3.16.0
+        version: link:../wrangler
 
   packages/prerelease-registry:
     dependencies:
@@ -1499,7 +1523,7 @@ importers:
         version: 6.5.1
       wrangler:
         specifier: ^3.0.0
-        version: 3.16.0
+        version: link:../wrangler
 
 packages:
 
@@ -3534,6 +3558,7 @@ 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==}
@@ -3641,6 +3666,7 @@ packages:
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
+    dev: false
     optional: true
 
   /@cloudflare/workerd-darwin-arm64@1.20231030.0:
@@ -3649,6 +3675,7 @@ packages:
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
+    dev: false
     optional: true
 
   /@cloudflare/workerd-linux-64@1.20231030.0:
@@ -3657,6 +3684,7 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
+    dev: false
     optional: true
 
   /@cloudflare/workerd-linux-arm64@1.20231030.0:
@@ -3665,6 +3693,7 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
+    dev: false
     optional: true
 
   /@cloudflare/workerd-windows-64@1.20231030.0:
@@ -3673,6 +3702,7 @@ packages:
     cpu: [x64]
     os: [win32]
     requiresBuild: true
+    dev: false
     optional: true
 
   /@cloudflare/workers-types@3.18.0:
@@ -3744,6 +3774,7 @@ 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==}
@@ -3753,6 +3784,7 @@ 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==}
@@ -4757,7 +4789,7 @@ packages:
       debug: 4.3.4(supports-color@9.2.2)
       espree: 9.5.2
       globals: 13.20.0
-      ignore: 5.2.4
+      ignore: 5.2.0
       import-fresh: 3.3.0
       js-yaml: 4.1.0
       minimatch: 3.1.2
@@ -4774,7 +4806,7 @@ packages:
       debug: 4.3.4(supports-color@9.2.2)
       espree: 9.6.1
       globals: 13.20.0
-      ignore: 5.2.4
+      ignore: 5.2.0
       import-fresh: 3.3.0
       js-yaml: 4.1.0
       minimatch: 3.1.2
@@ -5226,8 +5258,8 @@ packages:
       typescript: 4.6.4
     dev: true
 
-  /@microsoft/api-extractor@7.38.1(@types/node@18.16.10):
-    resolution: {integrity: sha512-Hxu/RrVpItQ4dzeMyfwlk4lGQFsXMoMS7bYU9YUrpW16hH04PXLRiTXJz77WhBiSGNtTuufz2xh6hWyXhC9JuQ==}
+  /@microsoft/api-extractor@7.38.2(@types/node@18.16.10):
+    resolution: {integrity: sha512-JOARuhTwOcOMIU0O2czscoJy3ddVzIRhSA9/7T1ALuZSNphgWsPk+Bv4E7AnBDmTV4pP4lBNLtCxEHjjpWaytQ==}
     hasBin: true
     dependencies:
       '@microsoft/api-extractor-model': 7.28.2(@types/node@18.16.10)
@@ -5235,7 +5267,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.0
+      '@rushstack/ts-command-line': 4.17.1
       colors: 1.2.5
       lodash: 4.17.21
       resolve: 1.22.2
@@ -5763,8 +5795,8 @@ packages:
       string-argv: 0.3.1
     dev: true
 
-  /@rushstack/ts-command-line@4.17.0:
-    resolution: {integrity: sha512-1S0sXuEpZlzKTfvUqNs7Rg4leVkeLJc4Dn9cm+pSIn35a0Ztp5GxPN2gabD2G4RrQoQcJLLyVu+twzrJl1C0eA==}
+  /@rushstack/ts-command-line@4.17.1:
+    resolution: {integrity: sha512-2jweO1O57BYP5qdBGl6apJLB+aRIn5ccIRTPDyULh0KMwVzFqWtw6IZWt1qtUoZD/pD2RNkIOosH6Cq45rIYeg==}
     dependencies:
       '@types/argparse': 1.0.38
       argparse: 1.0.10
@@ -6425,8 +6457,8 @@ packages:
     resolution: {integrity: sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==}
     dev: true
 
-  /@types/stoppable@1.1.2:
-    resolution: {integrity: sha512-zRBGFTIdkCAdM4VDeFvka5NbD6JVfz7yEYzggKrXQ03ZplrZp5vqQPWHTw0wk81wer61dwi44Tp6FDDXoPBW5A==}
+  /@types/stoppable@1.1.3:
+    resolution: {integrity: sha512-7wGKIBJGE4ZxFjk9NkjAxZMLlIXroETqP1FJCdoSvKmEznwmBxQFmTB1dsCkAvVcNemuSZM5qkkd9HE/NL2JTw==}
     dependencies:
       '@types/node': 18.16.10
     dev: true
@@ -6475,6 +6507,12 @@ 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
@@ -6544,7 +6582,7 @@ packages:
       graphemer: 1.4.0
       ignore: 5.2.0
       natural-compare-lite: 1.4.0
-      semver: 7.5.4
+      semver: 7.5.1
       tsutils: 3.21.0(typescript@4.9.5)
       typescript: 4.9.5
     transitivePeerDependencies:
@@ -6600,15 +6638,15 @@ packages:
       graphemer: 1.4.0
       ignore: 5.2.0
       natural-compare-lite: 1.4.0
-      semver: 7.5.4
+      semver: 7.5.1
       tsutils: 3.21.0(typescript@5.0.3)
       typescript: 5.0.3
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@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.10.0(@typescript-eslint/parser@6.10.0)(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-uoLj4g2OTL8rfUQVx2AFO1hp/zja1wABJq77P6IclQs6I/m9GLrm7jCdgzZkvWdDCQf1uEvoa8s8CupsgWQgVg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
@@ -6618,26 +6656,26 @@ 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.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
       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/eslint-plugin@6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-w0tiiRc9I4S5XSXXrMHOWgHgxbrBn1Ro+PmiYhSg2ZVdxrAJtQgzU5o2m1BfP6UOn7Vxcc6152vFjQfmZR4xEg==}
+  /@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
@@ -6647,23 +6685,23 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@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
+      '@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/parser@5.59.9(eslint@8.49.0)(typescript@5.0.3):
     resolution: {integrity: sha512-FsPkRvBtcLQ/eVK1ivDiNYBjn3TGJdXy2fhXX+rc7czWl4ARwnpArwbihSOHI2Peg9WbtGHrbThfBUkZZGTtvQ==}
@@ -6745,8 +6783,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@6.7.2(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-KA3E4ox0ws+SPyxQf9iSI25R6b4Ne78ORhNHeVKrPQnoYsb9UhieoiRoJgrzgEeKGOXhcY1i8YtOeCHHTDa6Fw==}
+  /@typescript-eslint/parser@6.10.0(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-+sZwIj+s+io9ozSxIWbNB5873OSdfeBEH/FR0re14WLI6BaKuSOnnwCJ2foUiu8uXf4dRp1UqHP0vrZ1zXGrog==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6755,19 +6793,19 @@ 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.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
       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/parser@6.9.1(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-C7AK2wn43GSaCUZ9do6Ksgi2g3mwFkMO3Cis96kzmgudoVaKyt62yNzJOktP0HDLb/iO2O0n2lBOzJgr6Q/cyg==}
+  /@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
@@ -6776,16 +6814,16 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@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
+      '@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/scope-manager@5.59.9:
     resolution: {integrity: sha512-8RA+E+w78z1+2dzvK/tGZ2cpGigBZ58VMEHDZtpE1v+LLjzrYGc8mMaTONSxKyEkz3IuXFM0IqYiGHlCsmlZxQ==}
@@ -6803,6 +6841,14 @@ 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}
@@ -6811,14 +6857,6 @@ 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}
@@ -6899,8 +6937,8 @@ packages:
       - supports-color
     dev: true
 
-  /@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.10.0(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-wYpPs3hgTFblMYwbYWPT3eZtaDOjbLyIYuqpwuLBBqhLiuvJ+9sEp2gNRJEtR5N/c9G1uTtQQL5AhV0fEPJYcg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -6909,18 +6947,18 @@ 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.10.0(typescript@5.0.4)
+      '@typescript-eslint/utils': 6.10.0(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/type-utils@6.9.1(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-eh2oHaUKCK58qIeYp19F5V5TbpM52680sB4zNSz29VBQPTWIlE/hCj5P5B1AChxECe/fmZlspAWFuRniep1Skg==}
+  /@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
@@ -6929,15 +6967,15 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@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)
+      '@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/types@5.59.9:
     resolution: {integrity: sha512-uW8H5NRgTVneSVTfiCVffBb8AbwWSKg7qcA4Ot3JI3MPCJGsB4Db4BhvAODIIYE5mNj7Q+VJkK7JxmRhk2Lyjw==}
@@ -6949,16 +6987,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}
@@ -7043,8 +7081,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/typescript-estree@6.7.2(typescript@4.9.5):
-    resolution: {integrity: sha512-kiJKVMLkoSciGyFU0TOY0fRxnp9qq1AzVOHNeN1+B9erKFCJ4Z8WdjAkKQPP+b1pWStGFqezMLltxO+308dJTQ==}
+  /@typescript-eslint/typescript-estree@6.10.0(typescript@5.0.4):
+    resolution: {integrity: sha512-ek0Eyuy6P15LJVeghbWhSrBCj/vJpPXXR+EpaRZqou7achUWL8IdYnMSC5WHAeTWswYQuP2hAZgij/bC9fanBg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       typescript: '*'
@@ -7052,20 +7090,20 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 6.7.2
-      '@typescript-eslint/visitor-keys': 6.7.2
+      '@typescript-eslint/types': 6.10.0
+      '@typescript-eslint/visitor-keys': 6.10.0
       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/typescript-estree@6.9.1(typescript@5.0.4):
-    resolution: {integrity: sha512-U+mUylTHfcqeO7mLWVQ5W/tMLXqVpRv61wm9ZtfE5egz7gtnmqVIw9ryh0mgIlkKk9rZLY3UHygsBSdB9/ftyw==}
+  /@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: '*'
@@ -7073,17 +7111,17 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 6.9.1
-      '@typescript-eslint/visitor-keys': 6.9.1
+      '@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/utils@5.59.9(eslint@8.42.0)(typescript@4.9.5):
     resolution: {integrity: sha512-1PuMYsju/38I5Ggblaeb98TOoUvjhRvLpLa1DoTOFaLWqaXl/1iQ1eGurTXgBY58NUdtfTXKP5xBq7q9NDaLKg==}
@@ -7099,7 +7137,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.4
+      semver: 7.5.1
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -7119,7 +7157,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.4
+      semver: 7.5.1
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -7185,8 +7223,8 @@ packages:
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@6.7.2(eslint@8.49.0)(typescript@4.9.5):
-    resolution: {integrity: sha512-ZCcBJug/TS6fXRTsoTkgnsvyWSiXwMNiPzBUani7hDidBdj1779qwM1FIAmpH4lvlOZNF3EScsxxuGifjpLSWQ==}
+  /@typescript-eslint/utils@6.10.0(eslint@8.49.0)(typescript@5.0.4):
+    resolution: {integrity: sha512-v+pJ1/RcVyRc0o4wAGux9x42RHmAjIGzPRo538Z8M1tVx6HOnoQBCX/NoadHQlZeC+QO2yr4nNSFWOoraZCAyg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -7194,18 +7232,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.7.2
-      '@typescript-eslint/types': 6.7.2
-      '@typescript-eslint/typescript-estree': 6.7.2(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 6.10.0
+      '@typescript-eslint/types': 6.10.0
+      '@typescript-eslint/typescript-estree': 6.10.0(typescript@5.0.4)
       eslint: 8.49.0
       semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
-    dev: false
+    dev: true
 
-  /@typescript-eslint/utils@6.9.1(eslint@8.49.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-L1T0A5nFdQrMVunpZgzqPL6y2wVreSyHhKGZryS6jrEN7bD9NplVAyMryUhXsQ4TWLnZmxc2ekar/lSGIlprCA==}
+  /@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
@@ -7213,15 +7251,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.9.1
-      '@typescript-eslint/types': 6.9.1
-      '@typescript-eslint/typescript-estree': 6.9.1(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/visitor-keys@5.59.9:
     resolution: {integrity: sha512-bT7s0td97KMaLwpEBckbzj/YohnvXtqbe2XgqNvTl6RJVakY5mvENOTPvw5u66nljfZxthESpDozs86U+oLY8Q==}
@@ -7239,6 +7277,14 @@ 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}
@@ -7247,14 +7293,6 @@ 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:
@@ -7627,7 +7665,7 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.1
+      define-properties: 1.2.0
       es-abstract: 1.22.1
       es-array-method-boxes-properly: 1.0.0
       get-intrinsic: 1.2.1
@@ -7649,7 +7687,7 @@ packages:
     dependencies:
       array-buffer-byte-length: 1.0.0
       call-bind: 1.0.2
-      define-properties: 1.2.1
+      define-properties: 1.2.0
       get-intrinsic: 1.2.1
       is-array-buffer: 3.0.2
       is-shared-array-buffer: 1.0.2
@@ -7673,6 +7711,7 @@ 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==}
@@ -8030,6 +8069,7 @@ 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==}
@@ -8300,6 +8340,7 @@ packages:
       tslib: 2.5.3
     transitivePeerDependencies:
       - supports-color
+    dev: false
     patched: true
 
   /capnpc-ts@0.7.0:
@@ -8723,7 +8764,7 @@ packages:
       js-string-escape: 1.0.1
       lodash: 4.17.21
       md5-hex: 3.0.1
-      semver: 7.5.4
+      semver: 7.5.1
       well-known-symbols: 2.0.0
     dev: true
 
@@ -9012,6 +9053,7 @@ 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==}
@@ -9203,6 +9245,7 @@ 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==}
@@ -9228,6 +9271,7 @@ 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==}
@@ -9870,13 +9914,13 @@ packages:
       eslint: 8.49.0
     dev: true
 
-  /eslint-config-turbo@1.10.14(eslint@8.49.0):
-    resolution: {integrity: sha512-ZeB+IcuFXy1OICkLuAplVa0euoYbhK+bMEQd0nH9+Lns18lgZRm33mVz/iSoH9VdUzl/1ZmFmoK+RpZc+8R80A==}
+  /eslint-config-turbo@1.10.16(eslint@8.49.0):
+    resolution: {integrity: sha512-O3NQI72bQHV7FvSC6lWj66EGx8drJJjuT1kuInn6nbMLOHdMBhSUX/8uhTAlHRQdlxZk2j9HtgFCIzSc93w42g==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
       eslint: 8.49.0
-      eslint-plugin-turbo: 1.10.14(eslint@8.49.0)
+      eslint-plugin-turbo: 1.10.16(eslint@8.49.0)
     dev: false
 
   /eslint-import-resolver-node@0.3.7:
@@ -9942,7 +9986,7 @@ packages:
       - supports-color
     dev: true
 
-  /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.10.0)(eslint-import-resolver-node@0.3.7)(eslint@8.49.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -9963,15 +10007,15 @@ 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.10.0(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-module-utils@2.8.0(@typescript-eslint/parser@6.9.1)(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:
@@ -9992,13 +10036,13 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.9.1(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-plugin-es@3.0.1(eslint@8.42.0):
     resolution: {integrity: sha512-GUmAsJaN4Fc7Gbtl8uOBlayo2DqhwWvEzykMHSCZHU3XdJ+NSzzZcVhXh3VxX5icqQ+oQdIEawXX8xkR3mIFmQ==}
@@ -10022,7 +10066,7 @@ packages:
       regexpp: 3.2.0
     dev: true
 
-  /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.10.0)(eslint@8.49.0):
     resolution: {integrity: sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -10032,14 +10076,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.10.0(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.10.0)(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
@@ -10051,9 +10095,9 @@ packages:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
-    dev: false
+    dev: true
 
-  /eslint-plugin-import@2.26.0(@typescript-eslint/parser@6.9.1)(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:
@@ -10063,14 +10107,14 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.9.1(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.9.1)(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
@@ -10082,7 +10126,7 @@ packages:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
-    dev: true
+    dev: false
 
   /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==}
@@ -10303,8 +10347,8 @@ packages:
       - typescript
     dev: true
 
-  /eslint-plugin-turbo@1.10.14(eslint@8.49.0):
-    resolution: {integrity: sha512-sBdBDnYr9AjT1g4lR3PBkZDonTrMnR4TvuGv5W0OiF7z9az1rI68yj2UHJZvjkwwcGu5mazWA1AfB0oaagpmfg==}
+  /eslint-plugin-turbo@1.10.16(eslint@8.49.0):
+    resolution: {integrity: sha512-ZjrR88MTN64PNGufSEcM0tf+V1xFYVbeiMeuIqr0aiABGomxFLo4DBkQ7WI4WzkZtWQSIA2sP+yxqSboEfL9MQ==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
@@ -10554,6 +10598,7 @@ 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==}
@@ -11171,7 +11216,7 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.1
+      define-properties: 1.2.0
       es-abstract: 1.22.1
       functions-have-names: 1.2.3
 
@@ -11220,11 +11265,17 @@ 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==}
@@ -11950,7 +12001,7 @@ packages:
       mute-stream: 0.0.8
       ora: 5.4.1
       run-async: 2.4.1
-      rxjs: 7.8.0
+      rxjs: 7.8.1
       string-width: 4.2.3
       strip-ansi: 6.0.1
       through: 2.3.8
@@ -13514,6 +13565,7 @@ 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==}
@@ -14120,29 +14172,6 @@ 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:
@@ -14424,6 +14453,7 @@ 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==}
@@ -15180,8 +15210,8 @@ packages:
       irregular-plurals: 3.5.0
     dev: true
 
-  /pnpm@8.10.0:
-    resolution: {integrity: sha512-nCy4Pyts9qJdjFgwC/mRl8fvO+hM8+dm8pBUtAuDtC+Kq6b8wxSp7PJ8APfOgKdXu0xgiADnrb4tKdxccFb1vg==}
+  /pnpm@8.10.2:
+    resolution: {integrity: sha512-B4IJPVumx62UYggbwe8HdQFqS0EJ7KHh/tzqbxEBQ69fUJk9s2xCfU+oxivjkgoyJNsS2nGdJGyhndnxgEjDPA==}
     engines: {node: '>=16.14'}
     hasBin: true
     dev: true
@@ -15397,6 +15427,7 @@ 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==}
@@ -16257,16 +16288,19 @@ 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==}
@@ -16401,6 +16435,7 @@ 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==}
@@ -16433,7 +16468,6 @@ 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==}
@@ -16785,6 +16819,7 @@ 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==}
@@ -16863,6 +16898,7 @@ packages:
     dependencies:
       as-table: 1.0.55
       get-source: 2.0.12
+    dev: false
 
   /standard-as-callback@2.1.0:
     resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==}
@@ -16888,6 +16924,7 @@ 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==}
@@ -16973,21 +17010,21 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.1
+      define-properties: 1.2.0
       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.1
+      define-properties: 1.2.0
       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.1
+      define-properties: 1.2.0
       es-abstract: 1.22.1
 
   /string_decoder@0.10.31:
@@ -18422,33 +18459,7 @@ packages:
       '@cloudflare/workerd-linux-64': 1.20231030.0
       '@cloudflare/workerd-linux-arm64': 1.20231030.0
       '@cloudflare/workerd-windows-64': 1.20231030.0
-
-  /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
+    dev: false
 
   /wrap-ansi@6.2.0:
     resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
@@ -18528,8 +18539,8 @@ packages:
         optional: true
     dev: true
 
-  /ws@8.13.0:
-    resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==}
+  /ws@8.14.2:
+    resolution: {integrity: sha512-wEBG1ftX4jcglPxgFCMJmZ2PLtSbJ2Peg6TmpJFTbe9GZYOQCDPdMYu/Tm0/bGZkw8paZnJY45J4K2PZrLYq8g==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -18599,6 +18610,7 @@ 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==}
@@ -18718,6 +18730,7 @@ 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==}