nitro 3.0.1-alpha.1 → 3.0.260311-beta

package/dist/_dev.mjs

@@ -1,220 +1,17 @@
-import { S as extname$1, k as resolve$1, n as debounce, w as join$1 } from "./_libs/c12.mjs";
-import { n as T, r as a } from "./_libs/std-env.mjs";
-import { t as src_default } from "./_libs/mime.mjs";
-import { r as writeDevBuildInfo } from "./_build/common.mjs";
-import { n as createProxyServer } from "./_libs/httpxy.mjs";
-import { i as watch$1 } from "./_libs/chokidar.mjs";
-import consola$1 from "consola";
+import { A as src_default, H as v, V as m, ct as join$1, dt as resolve$1, g as writeDevBuildInfo, ot as extname$1 } from "./_build/common.mjs";
+import { n as watch$1 } from "./_libs/readdirp+chokidar.mjs";
+import { t as debounce } from "./_libs/perfect-debounce.mjs";
+import { t as createProxyServer } from "./_libs/httpxy.mjs";
+import consola from "consola";
+import { createReadStream } from "node:fs";
+import { readFile, stat as stat$1 } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
-import { createReadStream, existsSync } from "node:fs";
 import { joinURL } from "ufo";
-import { readFile, rm, stat } from "node:fs/promises";
 import { createBrotliCompress, createGzip } from "node:zlib";
-import { Worker } from "node:worker_threads";
+import { RunnerManager, loadRunner } from "env-runner";
 import { H3, HTTPError, defineHandler, fromNodeHandler, getRequestIP, getRequestURL, serveStatic, toEventHandler } from "h3";
-import { Agent } from "undici";
 import { serve } from "srvx/node";
-import { ErrorParser } from "youch-core";
-import { Youch } from "youch";
-import { SourceMapConsumer } from "source-map";
 import { FastResponse } from "srvx";
-
-//#region src/dev/proxy.ts
-function createHTTPProxy(defaults = {}) {
-	const proxy = createProxyServer(defaults);
-	proxy.on("proxyReq", (proxyReq, req) => {
-		if (!proxyReq.hasHeader("x-forwarded-for")) {
-			const address = req.socket.remoteAddress;
-			if (address) proxyReq.appendHeader("x-forwarded-for", address);
-		}
-		if (!proxyReq.hasHeader("x-forwarded-port")) {
-			if (req?.socket?.localPort) proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
-		}
-		if (!proxyReq.hasHeader("x-forwarded-Proto")) {
-			const encrypted = (req?.connection)?.encrypted;
-			proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
-		}
-	});
-	return {
-		proxy,
-		async handleEvent(event, opts) {
-			try {
-				return await fromNodeHandler((req, res) => proxy.web(req, res, opts))(event);
-			} catch (error) {
-				event.res.headers.set("refresh", "3");
-				throw new HTTPError({
-					status: 503,
-					message: "Dev server is unavailable.",
-					cause: error
-				});
-			}
-		}
-	};
-}
-function fetchAddress(addr, input, inputInit) {
-	let url;
-	let init;
-	if (input instanceof Request) {
-		url = new URL(input.url);
-		init = {
-			method: input.method,
-			headers: input.headers,
-			body: input.body,
-			...inputInit
-		};
-	} else {
-		url = new URL(input);
-		init = inputInit;
-	}
-	init = {
-		duplex: "half",
-		redirect: "manual",
-		...init
-	};
-	if (addr.socketPath) {
-		url.protocol = "http:";
-		return fetch(url, {
-			...init,
-			...fetchSocketOptions(addr.socketPath)
-		});
-	}
-	const origin = `http://${addr.host}${addr.port ? `:${addr.port}` : ""}`;
-	const outURL = new URL(url.pathname + url.search, origin);
-	return fetch(outURL, init);
-}
-function fetchSocketOptions(socketPath) {
-	if ("Bun" in globalThis) return { unix: socketPath };
-	if ("Deno" in globalThis) return { client: Deno.createHttpClient({
-		transport: "unix",
-		path: socketPath
-	}) };
-	return { dispatcher: new Agent({ connect: { socketPath } }) };
-}
-
-//#endregion
-//#region src/dev/worker.ts
-var NodeDevWorker = class {
-	closed = false;
-	#name;
-	#entry;
-	#data;
-	#hooks;
-	#worker;
-	#address;
-	#proxy;
-	#messageListeners;
-	constructor(opts) {
-		this.#name = opts.name;
-		this.#entry = opts.entry;
-		this.#data = opts.data;
-		this.#hooks = opts.hooks;
-		this.#proxy = createHTTPProxy();
-		this.#messageListeners = /* @__PURE__ */ new Set();
-		this.#initWorker();
-	}
-	get ready() {
-		return Boolean(!this.closed && this.#address && this.#proxy && this.#worker);
-	}
-	async fetch(input, init) {
-		for (let i = 0; i < 5 && !(this.#address && this.#proxy); i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
-		if (!(this.#address && this.#proxy)) return new Response("Dev worker is unavailable", { status: 503 });
-		return fetchAddress(this.#address, input, init);
-	}
-	upgrade(req, socket, head) {
-		if (!this.ready) return;
-		return this.#proxy.proxy.ws(req, socket, {
-			target: this.#address,
-			xfwd: true
-		}, head).catch((error) => {
-			consola$1.error("WebSocket proxy error:", error);
-		});
-	}
-	sendMessage(message) {
-		if (!this.#worker) throw new Error("Dev worker should be initialized before sending messages.");
-		this.#worker.postMessage(message);
-	}
-	onMessage(listener) {
-		this.#messageListeners.add(listener);
-	}
-	offMessage(listener) {
-		this.#messageListeners.delete(listener);
-	}
-	async close(cause) {
-		if (this.closed) return;
-		this.closed = true;
-		this.#hooks.onClose?.(this, cause);
-		this.#hooks = {};
-		const onError = (error) => consola$1.error(error);
-		await this.#closeWorker().catch(onError);
-		await this.#closeProxy().catch(onError);
-		await this.#closeSocket().catch(onError);
-	}
-	[Symbol.for("nodejs.util.inspect.custom")]() {
-		const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
-		return `NodeDevWorker#${this.#name}(${status})`;
-	}
-	#initWorker() {
-		if (!existsSync(this.#entry)) {
-			this.close(`worker entry not found in "${this.#entry}".`);
-			return;
-		}
-		const worker = new Worker(this.#entry, {
-			env: { ...process.env },
-			workerData: {
-				name: this.#name,
-				...this.#data
-			}
-		});
-		worker.once("exit", (code) => {
-			worker._exitCode = code;
-			this.close(`worker exited with code ${code}`);
-		});
-		worker.once("error", (error) => {
-			consola$1.error(`Worker error:`, error);
-			this.close(error);
-		});
-		worker.on("message", (message) => {
-			if (message?.address) {
-				this.#address = message.address;
-				this.#hooks.onReady?.(this, this.#address);
-			}
-			for (const listener of this.#messageListeners) listener(message);
-		});
-		this.#worker = worker;
-	}
-	async #closeProxy() {
-		this.#proxy?.proxy?.close(() => {});
-		this.#proxy = void 0;
-	}
-	async #closeSocket() {
-		const socketPath = this.#address?.socketPath;
-		if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\pipe`)) await rm(socketPath).catch(() => {});
-		this.#address = void 0;
-	}
-	async #closeWorker() {
-		if (!this.#worker) return;
-		this.#worker.postMessage({ event: "shutdown" });
-		if (!this.#worker._exitCode && !a && !T) await new Promise((resolve$2) => {
-			const gracefulShutdownTimeoutMs = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 5e3;
-			const timeout = setTimeout(() => {
-				if (process.env.DEBUG) consola$1.warn(`force closing dev worker...`);
-			}, gracefulShutdownTimeoutMs);
-			this.#worker?.on("message", (message) => {
-				if (message.event === "exit") {
-					clearTimeout(timeout);
-					resolve$2();
-				}
-			});
-		});
-		this.#worker.removeAllListeners();
-		await this.#worker.terminate().catch((error) => {
-			consola$1.error(error);
-		});
-		this.#worker = void 0;
-	}
-};
-
-//#endregion
 //#region src/dev/vfs.ts
 function createVFSHandler(nitro) {
 	return defineHandler(async (event) => {
@@ -224,24 +21,19 @@ function createVFSHandler(nitro) {
 			statusText: `Forbidden IP: "${ip || "?"}"`,
 			status: 403
 		});
-		const vfsEntries = {
-			...nitro.vfs,
-			...nitro.options.virtual
-		};
 		const url = event.context.params?._ || "";
 		const isJson = url.endsWith(".json") || event.req.headers.get("accept")?.includes("application/json");
 		const id = decodeURIComponent(url.replace(/^(\.json)?\/?/, "") || "");
-		if (id && !(id in vfsEntries)) throw new HTTPError({
+		if (id && !nitro.vfs.has(id)) throw new HTTPError({
 			message: "File not found",
 			status: 404
 		});
-		let content = id ? vfsEntries[id] : void 0;
-		if (typeof content === "function") content = await content();
+		const content = id ? await nitro.vfs.get(id)?.render() : void 0;
 		if (isJson) return {
 			rootDir: nitro.options.rootDir,
-			entries: Object.keys(vfsEntries).map((id$1) => ({
-				id: id$1,
-				path: "/_vfs.json/" + encodeURIComponent(id$1)
+			entries: [...nitro.vfs.keys()].map((id) => ({
+				id,
+				path: "/_vfs.json/" + encodeURIComponent(id)
 			})),
 			current: id ? {
 				id,
@@ -249,7 +41,7 @@ function createVFSHandler(nitro) {
 			} : null
 		};
 		const directories = { [nitro.options.rootDir]: {} };
-		const fpaths = Object.keys(vfsEntries);
+		const fpaths = [...nitro.vfs.keys()];
 		for (const item of fpaths) {
 			const segments = item.replace(nitro.options.rootDir, "").split("/").filter(Boolean);
 			let currentDir = item.startsWith(nitro.options.rootDir) ? directories[nitro.options.rootDir] : directories;
@@ -258,8 +50,8 @@ function createVFSHandler(nitro) {
 				currentDir = currentDir[segment];
 			}
 		}
-		const generateHTML = (directory, path$1 = []) => Object.entries(directory).map(([fname, value = {}]) => {
-			const subpath = [...path$1, fname];
+		const generateHTML = (directory, path = []) => Object.entries(directory).map(([fname, value = {}]) => {
+			const subpath = [...path, fname];
 			const key = subpath.join("/");
 			const encodedUrl = encodeURIComponent(key);
 			const linkClass = url === `/${encodedUrl}` ? "bg-gray-700 text-white" : "hover:bg-gray-800 text-gray-200";
@@ -350,22 +142,20 @@ const editorTemplate = (options) => `
   }, 0);
 <\/script>
 `;
-
 //#endregion
 //#region src/runtime/internal/error/utils.ts
 function defineNitroErrorHandler(handler) {
 	return handler;
 }
-
 //#endregion
 //#region src/runtime/internal/error/dev.ts
-var dev_default = defineNitroErrorHandler(async function defaultNitroErrorHandler(error, event) {
+const errorHandler = defineNitroErrorHandler(async function defaultNitroErrorHandler(error, event) {
 	const res = await defaultHandler(error, event);
 	return new FastResponse(typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2), res);
 });
 async function defaultHandler(error, event, opts) {
-	const isSensitive = error.unhandled;
-	const status = error.status || 500;
+	const unhandled = error.unhandled ?? !HTTPError.isError(error);
+	const { status = 500, statusText = "" } = unhandled ? {} : error;
 	const url = getRequestURL(event, {
 		xForwardedHost: true,
 		xForwardedProto: true
@@ -375,58 +165,63 @@ async function defaultHandler(error, event, opts) {
 		if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) return {
 			status: 302,
 			statusText: "Found",
-			headers: { location: `${baseURL}${url.pathname.slice(1)}${url.search}` },
+			headers: new Headers({ location: `${baseURL}${url.pathname.slice(1)}${url.search}` }),
 			body: `Redirecting...`
 		};
 	}
-	await loadStackTrace(error).catch(consola$1.error);
+	await loadStackTrace(error).catch(consola.error);
+	const { Youch } = await import("youch");
 	const youch = new Youch();
-	if (isSensitive && !opts?.silent) {
-		const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
-		const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
-		consola$1.error(`[request error] ${tags} [${event.req.method}] ${url}\n\n`, ansiError);
+	if (unhandled && !opts?.silent) {
+		const ansiError = (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+		consola.error(`[request error] [${event.req.method}] ${url}\n\n`, ansiError);
 	}
-	const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
-	const headers = {
-		"content-type": useJSON ? "application/json" : "text/html",
-		"x-content-type-options": "nosniff",
-		"x-frame-options": "DENY",
-		"referrer-policy": "no-referrer",
-		"content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
-	};
-	if (status === 404 || !event.res.headers.has("cache-control")) headers["cache-control"] = "no-cache";
-	const body = useJSON ? {
-		error: true,
-		url,
-		status,
-		statusText: error.statusText,
-		message: error.message,
-		data: error.data,
-		stack: error.stack?.split("\n").map((line) => line.trim())
-	} : await youch.toHTML(error, { request: {
-		url: url.href,
-		method: event.req.method,
-		headers: Object.fromEntries(event.req.headers.entries())
-	} });
+	const useJSON = opts?.json ?? !event.req.headers.get("accept")?.includes("text/html");
+	const headers = new Headers(unhandled ? {} : error.headers);
+	if (useJSON) {
+		headers.set("Content-Type", "application/json; charset=utf-8");
+		const jsonBody = typeof error.toJSON === "function" ? error.toJSON() : {
+			status,
+			statusText,
+			message: error.message
+		};
+		return {
+			status,
+			statusText,
+			headers,
+			body: {
+				error: true,
+				stack: error.stack?.split("\n").map((line) => line.trim()),
+				...jsonBody
+			}
+		};
+	}
+	headers.set("Content-Type", "text/html; charset=utf-8");
 	return {
 		status,
-		statusText: error.statusText,
+		statusText: unhandled ? "" : error.statusText,
 		headers,
-		body
+		body: await youch.toHTML(error, { request: {
+			url: url.href,
+			method: event.req.method,
+			headers: Object.fromEntries(event.req.headers.entries())
+		} })
 	};
 }
 async function loadStackTrace(error) {
 	if (!(error instanceof Error)) return;
+	const { ErrorParser } = await import("youch-core");
 	const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
 	const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
 	Object.defineProperty(error, "stack", { value: stack });
-	if (error.cause) await loadStackTrace(error.cause).catch(consola$1.error);
+	if (error.cause) await loadStackTrace(error.cause).catch(consola.error);
 }
 async function sourceLoader(frame) {
 	if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") return;
 	if (frame.type === "app") {
 		const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {});
 		if (rawSourceMap) {
+			const { SourceMapConsumer } = await import("source-map");
 			const originalPosition = (await new SourceMapConsumer(rawSourceMap)).originalPositionFor({
 				line: frame.lineNumber,
 				column: frame.columnNumber
@@ -446,7 +241,6 @@ function fmtFrame(frame) {
 	const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
 	return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
 }
-
 //#endregion
 //#region src/dev/app.ts
 var NitroDevApp = class {
@@ -461,9 +255,9 @@ var NitroDevApp = class {
 		const app = new H3({
 			debug: true,
 			onError: async (error, event) => {
-				const errorHandler = this.nitro.options.devErrorHandler || dev_default;
+				const errorHandler$1 = this.nitro.options.devErrorHandler || errorHandler;
 				await loadStackTrace(error).catch(() => {});
-				return errorHandler(error, event, { defaultHandler });
+				return errorHandler$1(error, event, { defaultHandler });
 			}
 		});
 		for (const h of this.nitro.options.devHandlers) {
@@ -506,11 +300,11 @@ function serveStaticDir(event, opts) {
 	return serveStatic(event, {
 		fallthrough: opts.fallthrough,
 		getMeta: async (id) => {
-			const path$1 = r(id);
-			if (!path$1) return;
-			const s = await stat(path$1).catch(() => null);
+			const path = r(id);
+			if (!path) return;
+			const s = await stat$1(path).catch(() => null);
 			if (!s?.isFile()) return;
-			const ext = extname$1(path$1);
+			const ext = extname$1(path);
 			return {
 				size: s.size,
 				mtime: s.mtime,
@@ -518,9 +312,9 @@ function serveStaticDir(event, opts) {
 			};
 		},
 		getContents(id) {
-			const path$1 = r(id);
-			if (!path$1) return;
-			const stream = createReadStream(path$1);
+			const path = r(id);
+			if (!path) return;
+			const stream = createReadStream(path);
 			const acceptEncoding = event.req.headers.get("accept-encoding") || "";
 			if (acceptEncoding.includes("br")) {
 				event.res.headers.set("Content-Encoding", "br");
@@ -537,7 +331,29 @@ function serveStaticDir(event, opts) {
 		}
 	});
 }
-
+function createHTTPProxy(defaults = {}) {
+	const proxy = createProxyServer({
+		xfwd: true,
+		...defaults
+	});
+	return {
+		proxy,
+		async handleEvent(event, opts) {
+			try {
+				return await fromNodeHandler((req, res) => {
+					return proxy.web(req, res, opts);
+				})(event);
+			} catch (error) {
+				event.res.headers.set("refresh", "3");
+				throw new HTTPError({
+					status: 503,
+					message: "Dev server is unavailable.",
+					cause: error
+				});
+			}
+		}
+	};
+}
 //#endregion
 //#region src/dev/server.ts
 function createDevServer(nitro) {
@@ -548,17 +364,21 @@ var NitroDevServer = class NitroDevServer extends NitroDevApp {
 	#workerData = {};
 	#listeners = [];
 	#watcher;
-	#workers = [];
+	#manager;
 	#workerIdCtr = 0;
 	#workerError;
+	#workerRetries = 0;
 	#building = true;
 	#buildError;
-	#messageListeners = /* @__PURE__ */ new Set();
+	#reloadPromise;
 	constructor(nitro) {
 		super(nitro, async (event) => {
-			const worker = await this.#getWorker();
-			if (!worker) return this.#generateError();
-			return worker.fetch(event.req);
+			if (this.#building) await this.#waitForBuild();
+			if (this.#reloadPromise) await this.#reloadPromise;
+			if (this.#buildError) return this.#generateError();
+			const response = await this.#manager.fetch(event.req);
+			if (response.status === 503 && !this.#manager.ready) return this.#generateError();
+			return response;
 		});
 		for (const key of Object.getOwnPropertyNames(NitroDevServer.prototype)) {
 			const value = this[key];
@@ -566,6 +386,20 @@ var NitroDevServer = class NitroDevServer extends NitroDevApp {
 		}
 		nitro.fetch = this.fetch.bind(this);
 		this.#entry = resolve$1(nitro.options.output.dir, nitro.options.output.serverDir, "index.mjs");
+		this.#manager = new RunnerManager();
+		this.#manager.onReady(async (_runner, addr) => {
+			this.#workerRetries = 0;
+			writeDevBuildInfo(this.nitro, addr).catch((error) => {
+				this.nitro.logger.warn(`Failed to write dev build info: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		});
+		this.#manager.onClose((_runner, cause) => {
+			this.#workerError = cause;
+			if (this.#workerRetries++ < 3) {
+				this.nitro.logger.info("Restarting dev worker...", cause ? `Cause: ${cause}` : "");
+				this.reload();
+			} else this.nitro.logger.error("Dev worker failed after 3 retries.", cause ? `Last cause: ${cause}` : "");
+		});
 		nitro.hooks.hook("close", () => this.close());
 		nitro.hooks.hook("dev:start", () => {
 			this.#building = true;
@@ -581,21 +415,24 @@ var NitroDevServer = class NitroDevServer extends NitroDevApp {
 		nitro.hooks.hook("dev:error", (cause) => {
 			this.#buildError = cause;
 			this.#building = false;
-			for (const worker of this.#workers) worker.close();
 		});
-		if (nitro.options.devServer.watch.length > 0) {
+		const devWatch = nitro.options.devServer.watch;
+		if (devWatch && devWatch.length > 0) {
 			const debouncedReload = debounce(() => this.reload());
-			this.#watcher = watch$1(nitro.options.devServer.watch, nitro.options.watchOptions);
+			this.#watcher = watch$1(devWatch, nitro.options.watchOptions);
 			this.#watcher.on("add", debouncedReload).on("change", debouncedReload);
 		}
 	}
 	async upgrade(req, socket, head) {
-		const worker = await this.#getWorker();
-		if (!worker) throw new HTTPError({
-			status: 503,
-			statusText: "No worker available."
+		if (!this.#manager.upgrade) throw new HTTPError({
+			status: 501,
+			statusText: "Worker does not support upgrades."
 		});
-		return worker.upgrade(req, socket, head);
+		return this.#manager.upgrade({ node: {
+			req,
+			socket,
+			head
+		} });
 	}
 	listen(opts) {
 		const server = serve({
@@ -612,64 +449,42 @@ var NitroDevServer = class NitroDevServer extends NitroDevApp {
 			Promise.all(this.#listeners.map((l) => l.close())).then(() => {
 				this.#listeners = [];
 			}),
-			Promise.all(this.#workers.map((w) => w.close())).then(() => {
-				this.#workers = [];
-			}),
+			this.#manager.close(),
 			Promise.resolve(this.#watcher?.close()).then(() => {
 				this.#watcher = void 0;
 			})
 		].map((p) => p.catch((error) => {
-			consola$1.error(error);
+			consola.error(error);
 		})));
 	}
 	reload() {
-		for (const worker$1 of this.#workers) worker$1.close();
-		const worker = new NodeDevWorker({
+		const nextReload = (this.#reloadPromise ?? Promise.resolve()).catch(() => {}).then(() => this.#reload());
+		this.#reloadPromise = nextReload.finally(() => {
+			if (this.#reloadPromise === nextReload) this.#reloadPromise = void 0;
+		});
+	}
+	async #reload() {
+		const runner = await loadRunner(this.nitro.options.devServer.runner || process.env.NITRO_DEV_RUNNER || "node-worker", {
 			name: `Nitro_${this.#workerIdCtr++}`,
-			entry: this.#entry,
 			data: {
-				...this.#workerData,
-				globals: {
-					__NITRO_RUNTIME_CONFIG__: this.nitro.options.runtimeConfig,
-					...this.#workerData.globals
-				}
-			},
-			hooks: {
-				onClose: (worker$1, cause) => {
-					this.#workerError = cause;
-					const index = this.#workers.indexOf(worker$1);
-					if (index !== -1) this.#workers.splice(index, 1);
-				},
-				onReady: async (_worker, addr) => {
-					writeDevBuildInfo(this.nitro, addr).catch(() => {});
-				}
+				entry: this.#entry,
+				...this.#workerData
 			}
 		});
-		if (!worker.closed) {
-			for (const listener of this.#messageListeners) worker.onMessage(listener);
-			this.#workers.unshift(worker);
-		}
+		await this.#manager.reload(runner);
 	}
 	sendMessage(message) {
-		for (const worker of this.#workers) if (!worker.closed) worker.sendMessage(message);
+		this.#manager.sendMessage(message);
 	}
 	onMessage(listener) {
-		this.#messageListeners.add(listener);
-		for (const worker of this.#workers) worker.onMessage(listener);
+		this.#manager.onMessage(listener);
 	}
 	offMessage(listener) {
-		this.#messageListeners.delete(listener);
-		for (const worker of this.#workers) worker.offMessage(listener);
+		this.#manager.offMessage(listener);
 	}
-	async #getWorker() {
-		let retry = 0;
-		const maxRetries = a || T ? 100 : 10;
-		while (this.#building || ++retry < maxRetries) {
-			if ((this.#workers.length === 0 || this.#buildError) && !this.#building) return;
-			const activeWorker = this.#workers.find((w) => w.ready);
-			if (activeWorker) return activeWorker;
-			await new Promise((resolve$2) => setTimeout(resolve$2, 600));
-		}
+	async #waitForBuild() {
+		const timeout = v || m ? 6e4 : 6e3;
+		await this.#manager.waitForReady(timeout);
 	}
 	#generateError() {
 		const error = this.#buildError || this.#workerError;
@@ -700,6 +515,5 @@ var NitroDevServer = class NitroDevServer extends NitroDevApp {
 		});
 	}
 };
-
 //#endregion
-export { NodeDevWorker as i, createDevServer as n, NitroDevApp as r, NitroDevServer as t };
+export { createDevServer as n, NitroDevApp as r, NitroDevServer as t };

package/dist/_libs/_.mjs

@@ -0,0 +1,3 @@
+import { a as loadDotenv } from "./c12+rc9.mjs";
+import "../_build/common.mjs";
+export { loadDotenv };

package/dist/_libs/_2.mjs

@@ -0,0 +1,2 @@
+import { t as mergeAssets } from "./pluginutils.mjs";
+export { mergeAssets };

package/dist/_libs/_3.mjs

@@ -0,0 +1,3 @@
+import "../_build/common.mjs";
+import { t as inject } from "./plugin-inject.mjs";
+export { inject as default };

package/dist/_libs/_4.mjs

@@ -0,0 +1,2 @@
+import { n as utils_exports, t as dist_exports } from "./c12+rc9.mjs";
+export { dist_exports as n, utils_exports as t };

package/dist/_libs/_5.mjs

@@ -0,0 +1,3 @@
+import "../_build/common.mjs";
+import { n as addDevDependency } from "./nypm+tinyexec.mjs";
+export { addDevDependency };

package/dist/_libs/_6.mjs

@@ -0,0 +1,4 @@
+import "../_build/common.mjs";
+import "./estree-walker.mjs";
+import { a as detectImportsAcorn } from "./unimport+unplugin.mjs";
+export { detectImportsAcorn };

package/dist/_libs/_7.mjs

@@ -0,0 +1,5 @@
+import "../_build/common.mjs";
+import { r as unplugin } from "./unimport+unplugin.mjs";
+import "./resolve-uri+gen-mapping.mjs";
+import "./remapping.mjs";
+export { unplugin as default };