@nasti-toolchain/nasti 2.5.0 → 2.5.2

package/dist/server-Bqgl25z0.js

@@ -0,0 +1,1871 @@
+import { a as __exportAll, i as printServerUrls } from "./logger-BVZwdqqT.js";
+import { c as transformReactCode, f as resolveConfig, i as ssrDefineOverrides, n as loadEnv, o as shouldTransform, p as getPluginApi, r as replaceEnvInCode, s as transformCode, t as buildEnvDefine } from "./env-GY7K1zPK.js";
+import { a as removeTimestampQuery, c as processHtml, i as createWsHotChannel, l as readHtmlFile, o as resolvePluginList, t as NastiEnvironment, u as isAssetFile } from "./environment-B2jCrhY2.js";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path from "node:path";
+import fs from "node:fs";
+import pc from "picocolors";
+import http from "node:http";
+import os from "node:os";
+import connect from "connect";
+import sirv from "sirv";
+import { watch } from "chokidar";
+import { WebSocketServer } from "ws";
+//#region src/server/ws.ts
+function createWebSocketServer(server) {
+	const wss = new WebSocketServer({ noServer: true });
+	const clients = /* @__PURE__ */ new Set();
+	server.on("upgrade", (req, socket, head) => {
+		if (req.headers["sec-websocket-protocol"] === "nasti-hmr") wss.handleUpgrade(req, socket, head, (ws) => {
+			wss.emit("connection", ws, req);
+		});
+	});
+	wss.on("connection", (ws) => {
+		clients.add(ws);
+		ws.send(JSON.stringify({ type: "connected" }));
+		ws.on("close", () => {
+			clients.delete(ws);
+		});
+		ws.on("error", (err) => {
+			console.error("[nasti] WebSocket error:", err);
+			clients.delete(ws);
+		});
+	});
+	return {
+		send(payload) {
+			const data = JSON.stringify(payload);
+			for (const client of clients) if (client.readyState === 1) client.send(data);
+		},
+		close() {
+			clients.clear();
+			wss.close();
+		}
+	};
+}
+//#endregion
+//#region src/server/fs-allow.ts
+/** True when `abs` is a real file/dir strictly inside `root` (not root itself). */
+function isUnderRoot(abs, root) {
+	const rel = path.relative(root, abs);
+	return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+const NM = `${path.sep}node_modules${path.sep}`;
+/**
+* Walk `node_modules` from `projectRoot` (and nested package roots) following
+* symlinks. Return real paths of packages that live *outside* the project root
+* and outside any `node_modules` tree — i.e. workspace / `file:` linked
+* packages. Regular pnpm store entries (under `.pnpm/.../node_modules/`) are
+* skipped: they are not user-editable watch targets and already pass the
+* `node_modules` segment check for `?id=`.
+*/
+function discoverLinkedPackageRoots(projectRoot, maxDepth = 4) {
+	const results = [];
+	const seenReal = /* @__PURE__ */ new Set();
+	const queued = /* @__PURE__ */ new Set([projectRoot]);
+	const queue = [projectRoot];
+	for (let depth = 0; depth < maxDepth && queue.length > 0; depth++) {
+		const levelCount = queue.length;
+		for (let i = 0; i < levelCount; i++) {
+			const dir = queue.shift();
+			const nm = path.join(dir, "node_modules");
+			let entries;
+			try {
+				entries = fs.readdirSync(nm, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const ent of entries) {
+				if (ent.name.startsWith(".") || ent.name === "node_modules") continue;
+				const pkgNames = ent.name.startsWith("@") ? listScopedPackages(nm, ent.name) : [ent.name];
+				for (const pkgName of pkgNames) {
+					const pkgPath = path.join(nm, pkgName);
+					let real;
+					try {
+						real = fs.realpathSync(pkgPath);
+					} catch {
+						continue;
+					}
+					if (seenReal.has(real)) continue;
+					seenReal.add(real);
+					if (!queued.has(real)) {
+						queued.add(real);
+						queue.push(real);
+					}
+					if (real !== projectRoot && !isUnderRoot(real, projectRoot) && !real.includes(NM)) results.push(real);
+				}
+			}
+		}
+	}
+	return results;
+}
+function listScopedPackages(nm, scope) {
+	try {
+		return fs.readdirSync(path.join(nm, scope)).filter((name) => !name.startsWith(".")).map((name) => path.join(scope, name));
+	} catch {
+		return [];
+	}
+}
+const linkedRootsCache = /* @__PURE__ */ new Map();
+/** Cached discoverLinkedPackageRoots; invalidated when root/node_modules mtime changes. */
+function getLinkedPackageRoots(projectRoot) {
+	let mtimeMs = 0;
+	try {
+		mtimeMs = fs.statSync(path.join(projectRoot, "node_modules")).mtimeMs;
+	} catch {
+		mtimeMs = 0;
+	}
+	const cached = linkedRootsCache.get(projectRoot);
+	if (cached && cached.mtimeMs === mtimeMs) return cached.roots;
+	const roots = discoverLinkedPackageRoots(projectRoot);
+	linkedRootsCache.set(projectRoot, {
+		roots,
+		mtimeMs
+	});
+	return roots;
+}
+/**
+* Clear the linked-roots cache. Call from the file watcher when any
+* `node_modules` tree changes (including nested ones under linked packages).
+*/
+function clearLinkedPackageRootsCache() {
+	linkedRootsCache.clear();
+}
+/**
+* Whether a realpath'd absolute file may be served via `/@modules/...?id=`.
+*
+* Allowed:
+*   1. under the project root (includes the app's own `node_modules`)
+*   2. under a `node_modules` directory on the walk up from the project root
+*      (monorepo-hoisted stores such as `<repo>/node_modules/.pnpm/...`)
+*   3. under a workspace / file: package linked from the project's
+*      node_modules tree (realpath leaves node_modules)
+*
+* A forged path that merely contains a `node_modules` segment under an
+* unrelated directory (e.g. `/tmp/other/node_modules/x`) is rejected.
+*/
+function isAllowedDevModulePath(realId, projectRoot) {
+	if (realId === projectRoot || isUnderRoot(realId, projectRoot)) return true;
+	for (const pkgRoot of getLinkedPackageRoots(projectRoot)) if (realId === pkgRoot || realId.startsWith(pkgRoot + path.sep)) return true;
+	let dir = projectRoot;
+	for (;;) {
+		const nm = path.join(dir, "node_modules");
+		if (realId === nm || realId.startsWith(nm + path.sep)) return true;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return false;
+}
+/**
+* Walk up from `file` looking for the nearest directory with a package.json
+* that has a `name` field (a package root).
+*/
+function findNearestPackageRoot(file) {
+	let dir = path.dirname(file);
+	for (;;) {
+		const pkgJson = path.join(dir, "package.json");
+		if (fs.existsSync(pkgJson)) try {
+			const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
+			if (typeof pkg?.name === "string" && pkg.name) return dir;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+//#endregion
+//#region src/server/middleware.ts
+const __dirname_esm = path.dirname(fileURLToPath(import.meta.url));
+const __require = createRequire(import.meta.url);
+/**
+* 将 react-refresh 的 CJS 运行时包装成浏览器可用的 ESM。
+* 原 CJS 通过 `exports.xxx = fn` 写入导出；我们用假的 module/exports/process
+* 对象跑一遍，再显式 re-export 出来。
+*
+* 读一次缓存一次：dev server 生命周期内不会变。
+*/
+let __refreshRuntimeCache = null;
+function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
+	if (__refreshRuntimeCache) return includeBoundaryHelpers ? __refreshRuntimeCache + REACT_REFRESH_BOUNDARY_HELPERS : __refreshRuntimeCache;
+	let cjsPath;
+	try {
+		const pkgPath = __require.resolve("react-refresh/package.json");
+		cjsPath = path.join(path.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+	} catch (err) {
+		cjsPath = path.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+		if (!fs.existsSync(cjsPath)) {
+			const origMsg = err instanceof Error ? err.message : String(err);
+			throw new Error(`[nasti] Missing dependency "react-refresh". Install it with: npm install react-refresh\nOriginal resolve error: ${origMsg}`);
+		}
+	}
+	__refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
+const exports = {};
+const module = { exports };
+const process = { env: { NODE_ENV: 'development' } };
+${fs.readFileSync(cjsPath, "utf-8")}
+const __rt = module.exports;
+export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;
+export const register = __rt.register;
+export const createSignatureFunctionForTransform = __rt.createSignatureFunctionForTransform;
+export const performReactRefresh = __rt.performReactRefresh;
+export const isLikelyComponentType = __rt.isLikelyComponentType;
+export const hasUnrecoverableErrors = __rt.hasUnrecoverableErrors;
+export const setSignature = __rt.setSignature;
+export const getFamilyByID = __rt.getFamilyByID;
+export const getFamilyByType = __rt.getFamilyByType;
+export const findAffectedHostInstances = __rt.findAffectedHostInstances;
+export const collectCustomHooksForSignature = __rt.collectCustomHooksForSignature;
+export default __rt;
+`;
+	return includeBoundaryHelpers ? __refreshRuntimeCache + REACT_REFRESH_BOUNDARY_HELPERS : __refreshRuntimeCache;
+}
+/** @vitejs/plugin-react 同类的 Refresh boundary 校验，避免非组件导出静默保持旧值。 */
+const REACT_REFRESH_BOUNDARY_HELPERS = `
+function __nastiIsPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]' &&
+    (obj.constructor === Object || obj.constructor === undefined);
+}
+function __nastiIsCompoundComponent(type) {
+  if (!__nastiIsPlainObject(type)) return false;
+  for (const key in type) {
+    if (!isLikelyComponentType(type[key])) return false;
+  }
+  return true;
+}
+export function registerExportsForReactRefresh(filename, moduleExports) {
+  for (const key in moduleExports) {
+    if (key === '__esModule') continue;
+    const value = moduleExports[key];
+    if (isLikelyComponentType(value)) {
+      register(value, filename + ' export ' + key);
+    } else if (__nastiIsCompoundComponent(value)) {
+      for (const subKey in value) {
+        register(value[subKey], filename + ' export ' + key + '-' + subKey);
+      }
+    }
+  }
+}
+let __nastiRefreshTimer;
+function __nastiEnqueueRefresh() {
+  clearTimeout(__nastiRefreshTimer);
+  __nastiRefreshTimer = setTimeout(() => performReactRefresh(), 16);
+}
+function __nastiCheckExports(ignored, exports, predicate) {
+  for (const key in exports) {
+    if (ignored.includes(key)) continue;
+    if (!predicate(key, exports[key])) return key;
+  }
+  return true;
+}
+export function validateRefreshBoundaryAndEnqueueUpdate(id, prevExports, nextExports) {
+  const ignored = window.__getReactRefreshIgnoredExports?.({ id }) ?? [];
+  if (__nastiCheckExports(ignored, prevExports, (key) => key in nextExports) !== true) {
+    return 'Could not Fast Refresh (export removed)';
+  }
+  if (__nastiCheckExports(ignored, nextExports, (key) => key in prevExports) !== true) {
+    return 'Could not Fast Refresh (new export)';
+  }
+  let hasExports = false;
+  const compatible = __nastiCheckExports(ignored, nextExports, (key, value) => {
+    hasExports = true;
+    return isLikelyComponentType(value) ||
+      __nastiIsCompoundComponent(value) ||
+      prevExports[key] === value;
+  });
+  if (!hasExports) {
+    return 'Could not Fast Refresh (no exports)';
+  }
+  if (compatible === true) {
+    __nastiEnqueueRefresh();
+    return;
+  }
+  return 'Could not Fast Refresh ("' + compatible + '" export is incompatible)';
+}
+export const __hmr_import = (module) => import(module);
+`;
+`
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
+/**
+* 单模块的 Fast Refresh 包装。
+*
+* 包装前先把 transformed 代码里的 `import.meta.hot` 替换为本地 `__nasti_hot__`
+* 变量 —— 规避 `import.meta` 属性赋值在某些引擎下不可写的问题，并统一 JSX/非 JSX
+* 路径的 hot 来源。
+*/
+function buildReactRefreshWrapper(moduleUrl, transformedCode) {
+	const urlLit = JSON.stringify(moduleUrl);
+	return `import * as RefreshRuntime from "/@react-refresh";
+import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
+const __nasti_hot__ = __nasti_createHotContext__(${urlLit});
+
+if (!window.__vite_plugin_react_preamble_installed__) {
+  throw new Error("[nasti] React Fast Refresh preamble missing. Make sure nasti:html is wired with framework: 'react'.");
+}
+
+const prevRefreshReg = window.$RefreshReg$;
+const prevRefreshSig = window.$RefreshSig$;
+window.$RefreshReg$ = (type, id) => {
+  RefreshRuntime.register(type, ${urlLit} + " " + id);
+};
+window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+${transformedCode.replace(/\bimport\.meta\.hot\b/g, "__nasti_hot__")}
+
+window.$RefreshReg$ = prevRefreshReg;
+window.$RefreshSig$ = prevRefreshSig;
+
+if (__nasti_hot__) {
+  let __nasti_current_exports__;
+  __nasti_hot__.accept((nextExports) => {
+    if (!nextExports) return;
+    if (!__nasti_current_exports__) {
+      __nasti_hot__.invalidate('Could not Fast Refresh (previous exports unavailable)');
+      return;
+    }
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(
+      ${urlLit},
+      __nasti_current_exports__,
+      nextExports,
+    );
+    if (invalidateMessage) __nasti_hot__.invalidate(invalidateMessage);
+  });
+  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+    __nasti_current_exports__ = currentExports;
+    RefreshRuntime.registerExportsForReactRefresh(${urlLit}, currentExports);
+  });
+}
+`;
+}
+/**
+* 非 JSX 模块里用户显式写了 import.meta.hot —— 注入一段 hot context 头部并替换属性访问为本地变量。
+*/
+function injectImportMetaHot(code, moduleUrl) {
+	const matches = [...maskStringsAndComments(code).matchAll(/\bimport\.meta\.hot\b/g)];
+	if (matches.length === 0) return code;
+	for (const match of matches.reverse()) {
+		const start = match.index;
+		code = code.slice(0, start) + "__nasti_hot__" + code.slice(start + match[0].length);
+	}
+	return `import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
+const __nasti_hot__ = __nasti_createHotContext__(${JSON.stringify(moduleUrl)});
+` + code;
+}
+/** 主转译中间件 - 处理模块请求 */
+function transformMiddleware(ctx) {
+	ctx.envDefine = buildEnvDefine(loadEnv(ctx.config.mode, ctx.config.root, ctx.config.envPrefix), ctx.config.mode, ssrDefineOverrides(ctx.environment?.consumer ?? "client"));
+	return async (req, res, next) => {
+		const url = req.url ?? "/";
+		if (ctx.config.server.cors) {
+			const origin = req.headers.origin ?? "*";
+			res.setHeader("Access-Control-Allow-Origin", origin);
+			res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+			res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+			if (req.method === "OPTIONS") {
+				res.statusCode = 204;
+				res.end();
+				return;
+			}
+		}
+		if (req.method !== "GET") return next();
+		if (url === "/@nasti/client") {
+			res.setHeader("Content-Type", "application/javascript");
+			res.end(getHmrClientCode());
+			return;
+		}
+		if (url === "/" || url.endsWith(".html")) {
+			const html = await readHtmlFile(ctx.config.root, ctx.config.environments.client?.html);
+			if (html) {
+				let processedHtml = html;
+				for (const plugin of ctx.config.plugins) if (plugin.transformIndexHtml) {
+					const result = await plugin.transformIndexHtml(processedHtml);
+					if (typeof result === "string") processedHtml = result;
+					else if (result && "html" in result) processedHtml = processHtml(result.html, result.tags);
+					else if (Array.isArray(result)) processedHtml = processHtml(processedHtml, result);
+				}
+				res.setHeader("Content-Type", "text/html");
+				res.end(processedHtml);
+				return;
+			}
+		}
+		if (isModuleRequest(url, req.headers["sec-fetch-dest"])) try {
+			const result = await transformRequest(url, ctx);
+			if (result) {
+				const contentType = url.endsWith(".css") ? "application/javascript" : "application/javascript";
+				res.setHeader("Content-Type", contentType);
+				res.setHeader("Cache-Control", "no-cache");
+				res.end(typeof result === "string" ? result : result.code);
+				return;
+			}
+		} catch (err) {
+			ctx.config.logger.error(pc.red(`Transform error: ${url}\n`) + (err.stack ?? err.message), {
+				timestamp: true,
+				error: err
+			});
+			res.statusCode = 500;
+			res.end(`Transform error: ${err.message}`);
+			return;
+		}
+		next();
+	};
+}
+/** 转译单个模块 */
+async function transformRequest(url, ctx) {
+	const { config, pluginContainer, moduleGraph } = ctx;
+	url = removeTimestampQuery(url);
+	const cleanReqUrl = url.split("?")[0];
+	const cached = moduleGraph.getModuleByUrl(url);
+	if (cached?.transformResult) return cached.transformResult;
+	if (cleanReqUrl === "/@react-refresh") return { code: getReactRefreshRuntimeEsm(true) };
+	if (cleanReqUrl.startsWith("/@modules/") && url.includes("?")) {
+		const idParam = new URLSearchParams(url.slice(url.indexOf("?") + 1)).get("id");
+		let realId = null;
+		let realIdValid = false;
+		try {
+			if (idParam) {
+				realId = fs.realpathSync(idParam);
+				realIdValid = fs.statSync(realId).isFile() && isAllowedDevModulePath(realId, config.root);
+			}
+		} catch {
+			realId = null;
+			realIdValid = false;
+		}
+		if (realId && realIdValid) {
+			const mod = await moduleGraph.ensureEntryFromUrl(url);
+			moduleGraph.registerModule(mod, realId);
+			const transformResult = { code: await bundlePackageAsEsm(realId, config.root) };
+			mod.transformResult = transformResult;
+			return transformResult;
+		}
+	}
+	if (cleanReqUrl.startsWith("/@modules/")) {
+		const virtual = await loadVirtualModule(cleanReqUrl.slice(10), ctx);
+		if (virtual) {
+			const mod = await moduleGraph.ensureEntryFromUrl(url);
+			moduleGraph.setModuleId(mod, virtual.id);
+			mod.transformResult = virtual.result;
+			return virtual.result;
+		}
+	}
+	const rawQuery = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+	if (rawQuery && !/^t=\d+$/.test(rawQuery)) {
+		const mod = await moduleGraph.ensureEntryFromUrl(url);
+		const transformVersion = mod.invalidationVersion;
+		const loaded = await pluginContainer.load(url);
+		if (loaded != null) {
+			let code = typeof loaded === "string" ? loaded : loaded.code;
+			let map = typeof loaded === "string" ? void 0 : loaded.map;
+			const transformed = await pluginContainer.transform(code, url);
+			if (transformed != null) {
+				code = typeof transformed === "string" ? transformed : transformed.code;
+				if (typeof transformed !== "string" && transformed.map != null) map = transformed.map;
+			}
+			const parentFile = resolveUrlToFile(cleanReqUrl, config.root) ?? cleanReqUrl;
+			moduleGraph.registerModule(mod, parentFile);
+			const hotInfo = rewriteHotAcceptDeps(code, config, parentFile);
+			code = injectImportMetaHot(hotInfo.code, url);
+			code = replaceEnvInCode(code, ctx.envDefine ?? buildEnvDefine(loadEnv(config.mode, config.root, config.envPrefix), config.mode, ssrDefineOverrides(ctx.environment?.consumer ?? "client")));
+			const importedUrls = /* @__PURE__ */ new Set();
+			code = rewriteImports(code, config, parentFile, importedUrls, moduleGraph);
+			const pruned = await moduleGraph.updateModuleInfo(mod, importedUrls, hotInfo.acceptedUrls, hotInfo.isSelfAccepting, transformVersion);
+			const transformResult = {
+				code,
+				map
+			};
+			if (pruned) {
+				if (pruned.size > 0) ctx.onPrune?.([...pruned].map((item) => item.url));
+				mod.transformResult = transformResult;
+			}
+			return transformResult;
+		}
+	}
+	const filePath = resolveUrlToFile(url, config.root);
+	if (!filePath || !fs.existsSync(filePath)) return null;
+	const mod = await moduleGraph.ensureEntryFromUrl(url);
+	moduleGraph.registerModule(mod, filePath);
+	const transformVersion = mod.invalidationVersion;
+	if (cleanReqUrl.startsWith("/@modules/")) {
+		const transformResult = { code: await bundlePackageAsEsm(filePath, config.root) };
+		mod.transformResult = transformResult;
+		return transformResult;
+	}
+	const loaded = await pluginContainer.load(filePath);
+	let code = loaded == null ? fs.readFileSync(filePath, "utf-8") : typeof loaded === "string" ? loaded : loaded.code;
+	let map = loaded && typeof loaded !== "string" ? loaded.map : void 0;
+	const pluginResult = await pluginContainer.transform(code, filePath);
+	if (pluginResult) {
+		code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
+		if (typeof pluginResult !== "string") map = pluginResult.map;
+	}
+	const stableUrl = cleanReqUrl;
+	let wrappedWithRefresh = false;
+	if (config.framework === "react") {
+		const useRefresh = (ctx.environment?.consumer ?? "client") === "client" && config.server.hmr !== false && (!!config.react.compiler || /\.[jt]sx$/.test(filePath));
+		const result = await transformReactCode(filePath, code, {
+			react: config.react,
+			consumer: ctx.environment?.consumer ?? "client",
+			development: true,
+			reactRefresh: useRefresh,
+			sourcemap: true,
+			target: ctx.environment?.options.build.target ?? config.build.target,
+			onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+		});
+		if (result) {
+			code = result.code;
+			if (result.map) map = JSON.parse(result.map);
+			if (useRefresh) {
+				code = buildReactRefreshWrapper(stableUrl, code);
+				wrappedWithRefresh = true;
+			}
+		}
+	} else if (shouldTransform(filePath)) {
+		const result = transformCode(filePath, code, {
+			sourcemap: true,
+			jsxRuntime: "automatic",
+			jsxImportSource: "vue",
+			target: ctx.environment?.options.build.target ?? config.build.target
+		});
+		code = result.code;
+		if (result.map) map = JSON.parse(result.map);
+	}
+	const hotInfo = rewriteHotAcceptDeps(code, config, filePath);
+	code = hotInfo.code;
+	if (!wrappedWithRefresh) code = injectImportMetaHot(code, stableUrl);
+	const envDefine = ctx.envDefine ?? buildEnvDefine(loadEnv(config.mode, config.root, config.envPrefix), config.mode, ssrDefineOverrides(ctx.environment?.consumer ?? "client"));
+	code = replaceEnvInCode(code, envDefine);
+	const importedUrls = /* @__PURE__ */ new Set();
+	code = rewriteImports(code, config, filePath, importedUrls, moduleGraph);
+	const pruned = await moduleGraph.updateModuleInfo(mod, importedUrls, hotInfo.acceptedUrls, wrappedWithRefresh || hotInfo.isSelfAccepting, transformVersion);
+	const transformResult = {
+		code,
+		map
+	};
+	if (pruned) {
+		if (pruned.size > 0) ctx.onPrune?.([...pruned].map((item) => item.url));
+		mod.transformResult = transformResult;
+	}
+	return transformResult;
+}
+/**
+* Run the plugin `resolveId` → `load` → `transform` pipeline for a bare specifier
+* that arrived as `/@modules/<spec>`, and return the prepared JS module if (and
+* only if) the result is a virtual module — i.e. its resolved id either uses the
+* Vite-convention `\0` null-byte prefix or does not exist on disk.
+*
+* Real-file resolutions (e.g. an alias plugin remapping a bare specifier onto a
+* source file under the project) are intentionally skipped here so they fall
+* through to the normal `resolveUrlToFile` / `bundlePackageAsEsm` paths; this
+* keeps the npm-package loader and the React Refresh wrapper in charge of those.
+*/
+async function loadVirtualModule(spec, ctx) {
+	const { config, pluginContainer } = ctx;
+	const resolved = await pluginContainer.resolveId(spec);
+	if (resolved == null) return null;
+	const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+	if (!(resolvedId.startsWith("\0") || !fs.existsSync(resolvedId))) return null;
+	const loadResult = await pluginContainer.load(resolvedId);
+	if (loadResult == null) return null;
+	let code = typeof loadResult === "string" ? loadResult : loadResult.code;
+	const transformed = await pluginContainer.transform(code, resolvedId);
+	if (transformed != null) code = typeof transformed === "string" ? transformed : transformed.code;
+	code = replaceEnvInCode(code, ctx.envDefine ?? buildEnvDefine(loadEnv(config.mode, config.root, config.envPrefix), config.mode, ssrDefineOverrides(ctx.environment?.consumer ?? "client")));
+	const anchor = path.join(config.root, "__nasti_virtual__.ts");
+	code = rewriteImports(code, config, anchor);
+	return {
+		id: resolvedId,
+		result: { code }
+	};
+}
+/** 用 rolldown 将 node_modules 包打包为浏览器可用的 ESM（含 CJS→ESM 转换） */
+const esmBundleCache = /* @__PURE__ */ new Map();
+async function bundlePackageAsEsm(entryFile, root) {
+	if (!esmBundleCache.has(entryFile)) esmBundleCache.set(entryFile, doBundlePackage(entryFile, root));
+	return esmBundleCache.get(entryFile);
+}
+async function doBundlePackage(entryFile, root) {
+	const shim = await tryGenerateSubpathShim(entryFile, root);
+	if (shim != null) return shim;
+	const { rolldown } = await import("rolldown");
+	const bundle = await rolldown({
+		input: entryFile,
+		external: (id) => {
+			if (id.startsWith(".") || id.startsWith("/") || /^[A-Za-z]:\\/.test(id)) return false;
+			return true;
+		}
+	});
+	const result = await bundle.generate({
+		format: "esm",
+		exports: "named"
+	});
+	await bundle.close();
+	let code = result.output[0].code;
+	code = code.replace(/process\.env\.NODE_ENV/g, "\"development\"");
+	const externalBaseDir = path.dirname(entryFile);
+	code = code.replace(/^(import\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm, (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`).replace(/^(export\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm, (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`).replace(/^(import\s+)(['"])([^'"./][^'"]*)(\2)/gm, (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`);
+	code = rewriteExternalRequires(code, externalBaseDir, root);
+	if (code.includes("__commonJSMin")) code = await injectCjsNamedExports(code, entryFile);
+	return code;
+}
+/**
+* 当入口是 npm 包的「子路径」（即 `pkg/sub` 形式，对应 `node_modules/pkg/`
+* 内部的某个非主入口文件）时，尝试改用一个薄薄的 re-export shim 替代独立 bundle，
+* shim 通过 `/@modules/<pkgName>` 复用主入口 bundle 的导出。
+*
+* 这样做是为了避免「同一份代码被打到多个 bundle 里」造成的运行时 bug：
+* 例如 `react-aria-components/Select` 与 `react-aria-components` 主入口都内部
+* 依赖 `private/Select.*`，而 rolldown 会把这份相对依赖内联到各自的 bundle 中。
+* 结果是浏览器侧出现两个独立的 `SelectContext = createContext(null)` 实例 ——
+* `<Select>` 写入的 Provider 与下方 `<SelectValue>` 读到的 Consumer 不再指向
+* 同一个 context，`useContext` 返回 null 直接崩。React Aria 的 Tabs / Collection
+* / DialogTrigger 等都属于这一类对 context identity 敏感的设计。
+*
+* 安全前提：shim 仅在主入口 **完整覆盖** 子路径所有具名导出、且各导出值
+* 与主入口下的对应值是 **同一引用**（identity 相等）时生成；否则回退到普通
+* bundling，避免错误改写有副作用的子路径（如真正分裂的入口、wrapped exports）。
+*
+* 仅 dev server 使用：build 模式走单一 rolldown 整图打包，本身不会重复内联。
+*/
+async function tryGenerateSubpathShim(entryFile, root) {
+	const NM = `${path.sep}node_modules${path.sep}`;
+	if (!entryFile.includes(NM)) return null;
+	let pkgDir = null;
+	let pkgName = null;
+	let dir = path.dirname(entryFile);
+	while (true) {
+		const pkgJsonPath = path.join(dir, "package.json");
+		if (fs.existsSync(pkgJsonPath)) try {
+			const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+			if (typeof pkg?.name === "string" && pkg.name) {
+				pkgDir = dir;
+				pkgName = pkg.name;
+				break;
+			}
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+		if (!dir.includes(NM)) return null;
+	}
+	if (!pkgDir || !pkgName) return null;
+	const entryExt = path.extname(entryFile);
+	const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
+	if (!mainEntry) return null;
+	if (path.resolve(mainEntry) === path.resolve(entryFile)) return null;
+	let mainNs;
+	let subNs;
+	try {
+		mainNs = await import(pathToFileURL(mainEntry).href);
+		subNs = await import(pathToFileURL(entryFile).href);
+	} catch {
+		return null;
+	}
+	if (!mainNs || typeof mainNs !== "object") return null;
+	if (!subNs || typeof subNs !== "object") return null;
+	const subKeys = Object.keys(subNs).filter((k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k));
+	if (subKeys.length === 0) return null;
+	for (const k of subKeys) {
+		if (!(k in mainNs)) return null;
+		if (mainNs[k] !== subNs[k]) return null;
+	}
+	if ("default" in subNs) {
+		if (!("default" in mainNs)) return null;
+		if (mainNs["default"] !== subNs["default"]) return null;
+	}
+	const rootMain = resolveNodeModule(root, pkgName);
+	const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + path.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
+	const lines = [`// Nasti subpath shim → ${pkgName} (avoid duplicate bundling)`, `import * as __pkg from "${mainEntryUrl}";`];
+	for (const k of subKeys) lines.push(`export const ${k} = __pkg[${JSON.stringify(k)}];`);
+	if ("default" in subNs) lines.push(`export default ("default" in __pkg ? __pkg["default"] : __pkg);`);
+	return lines.join("\n") + "\n";
+}
+/**
+* 解析包主入口绝对路径，**优先匹配指定扩展名**，再回退到任意可用主入口。
+* 主入口候选来自 `exports[\".\"]`（按 import / module / default / require / node 顺序展开嵌套条件）
+* 以及顶层 `module` / `main` 字段。
+*/
+function pickMainEntryByExtension(pkgDir, preferredExt) {
+	const pkgJsonPath = path.join(pkgDir, "package.json");
+	let pkg;
+	try {
+		pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	const candidates = [];
+	const collectFromExportObject = (obj) => {
+		if (!obj || typeof obj !== "object") return;
+		for (const cond of [
+			"import",
+			"module",
+			"default",
+			"require",
+			"node"
+		]) {
+			const v = obj[cond];
+			if (typeof v === "string") candidates.push(v);
+			else if (v && typeof v === "object") collectFromExportObject(v);
+		}
+	};
+	const dot = pkg?.exports?.["."];
+	if (typeof dot === "string") candidates.push(dot);
+	else if (dot && typeof dot === "object") collectFromExportObject(dot);
+	if (typeof pkg.module === "string") candidates.push(pkg.module);
+	if (typeof pkg.main === "string") candidates.push(pkg.main);
+	for (const cand of candidates) if (path.extname(cand) === preferredExt) {
+		const full = path.resolve(pkgDir, cand);
+		if (fs.existsSync(full)) return full;
+	}
+	for (const cand of candidates) {
+		const full = path.resolve(pkgDir, cand);
+		if (fs.existsSync(full)) return full;
+	}
+	return null;
+}
+/** 将 rolldown 生成的 __require("pkg") 调用转换为顶层 ESM import
+*  使用 namespace import + default 回退，兼容 CJS 和 ESM 模块：
+*  - CJS 包有 default export（__cjsMod）→ 取 .default
+*  - ESM 包只有 named exports → 取 namespace 本身 */
+function rewriteExternalRequires(code, baseDir, root) {
+	const pkgs = /* @__PURE__ */ new Set();
+	const re = /__require\(["']([^"']+)["']\)/g;
+	let m;
+	while ((m = re.exec(code)) !== null) pkgs.add(m[1]);
+	if (pkgs.size === 0) return code;
+	let result = code;
+	const imports = [];
+	for (const pkg of pkgs) {
+		const safe = pkg.replace(/[^a-zA-Z0-9_$]/g, "_");
+		imports.push(`import * as __ns_${safe} from "${externalSpecToModuleUrl(pkg, baseDir, root)}";`);
+		imports.push(`var __req_${safe} = "default" in __ns_${safe} ? __ns_${safe}["default"] : __ns_${safe};`);
+		result = result.replaceAll(`__require("${pkg}")`, `__req_${safe}`);
+		result = result.replaceAll(`__require('${pkg}')`, `__req_${safe}`);
+	}
+	return imports.join("\n") + "\n" + result;
+}
+const VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+async function injectCjsNamedExports(code, entryFile) {
+	try {
+		const { createRequire } = await import("module");
+		const cjsExports = createRequire(entryFile)(entryFile);
+		if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
+		const namedKeys = Object.keys(cjsExports).filter((k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k));
+		const hasEsmInterop = cjsExports.__esModule === true && "default" in cjsExports;
+		if (!hasEsmInterop && namedKeys.length === 0) return code;
+		return code.replace(/^export default (\w+\(\));?\s*$/m, (_, call) => [
+			`const __cjsMod = ${call};`,
+			hasEsmInterop ? `export default __cjsMod.default;` : `export default __cjsMod;`,
+			...namedKeys.map((k) => `export const ${k} = __cjsMod[${JSON.stringify(k)}];`)
+		].join("\n"));
+	} catch {
+		return code;
+	}
+}
+/**
+* 重写 import/export 语句的模块规范：
+*   - alias（如 `@/lib/api`）→ 解析后的项目内绝对 URL（带扩展名）
+*   - 相对路径（`./x`、`../x`）→ 同样解析后回写为绝对 URL
+*   - 项目内绝对路径（`/src/x`）→ 补扩展名
+*   - 其余 bare specifier → `/@modules/<spec>`
+*
+* 浏览器加载无扩展名 URL（如 `/src/i18n`）时，里面的相对路径 `./locales/en`
+* 会按字面拼接得到 `/src/locales/en`，不会自动补 `.ts` 也不知道导入文件原先在
+* `/src/i18n/`。直接按 alias / fs 解析、回写绝对 URL，浏览器就能命中正确文件。
+*/
+function rewriteImports(code, config, filePath, importedUrls, moduleGraph) {
+	const resolveSpec = createModuleSpecifierResolver(config, filePath);
+	const transformSpec = (spec) => {
+		const resolved = removeTimestampQuery(resolveSpec(spec));
+		importedUrls?.add(resolved);
+		const timestamp = moduleGraph?.getModuleByUrl(resolved)?.lastHMRTimestamp ?? 0;
+		return timestamp > 0 ? appendTimestampQuery(resolved, timestamp) : resolved;
+	};
+	return code.replace(/\bfrom\s+(['"])([^'"]+)\1/g, (_m, q, s) => `from ${q}${transformSpec(s)}${q}`).replace(/\bimport\s+(['"])([^'"]+)\1/g, (_m, q, s) => `import ${q}${transformSpec(s)}${q}`).replace(/\bimport\s*\(\s*(['"])([^'"]+)\1\s*\)/g, (_m, q, s) => `import(${q}${transformSpec(s)}${q})`);
+}
+function createModuleSpecifierResolver(config, filePath) {
+	const root = config.root;
+	const fileDir = path.dirname(filePath);
+	const aliasEntries = Object.entries(config.resolve.alias).sort(([a], [b]) => b.length - a.length);
+	const toServableUrl = (abs) => {
+		if (isUnderRoot(abs, root)) return "/" + path.relative(root, abs).replace(/\\/g, "/");
+		for (const pkgRoot of getLinkedPackageRoots(root)) if (abs === pkgRoot || abs.startsWith(pkgRoot + path.sep)) {
+			const normalized = abs.replace(/\\/g, "/");
+			return "/@fs/" + (normalized.startsWith("/") ? normalized.slice(1) : normalized);
+		}
+		return null;
+	};
+	return (specifier) => {
+		const suffixMatch = specifier.match(/[?#].*$/);
+		const suffix = suffixMatch ? suffixMatch[0] : "";
+		const baseSpec = suffix ? specifier.slice(0, -suffix.length) : specifier;
+		for (const [key, value] of aliasEntries) if (baseSpec === key || baseSpec.startsWith(key + "/")) {
+			const aliasBase = resolveAliasTarget(value, root);
+			const sub = baseSpec.slice(key.length).replace(/^\//, "");
+			const resolved = tryResolveDiskPath(sub ? path.join(aliasBase, sub) : aliasBase);
+			const url = resolved ? toServableUrl(resolved) : null;
+			return url ? url + suffix : specifier;
+		}
+		if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
+			const resolved = tryResolveDiskPath(path.resolve(fileDir, baseSpec));
+			const url = resolved ? toServableUrl(resolved) : null;
+			return url ? url + suffix : specifier;
+		}
+		if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
+			const resolved = tryResolveDiskPath(path.join(root, baseSpec.replace(/^\//, "")));
+			const url = resolved ? toServableUrl(resolved) : null;
+			return url ? url + suffix : specifier;
+		}
+		if (baseSpec.startsWith("/")) return specifier;
+		return `/@modules/${specifier}`;
+	};
+}
+/**
+* 解析并规范化 import.meta.hot.accept() 的第一参数。
+* HMR API 只允许字符串字面量或字面量数组，因此无需引入完整 AST。
+*/
+function rewriteHotAcceptDeps(code, config, filePath) {
+	const acceptedUrls = /* @__PURE__ */ new Set();
+	const edits = [];
+	const resolveSpec = createModuleSpecifierResolver(config, filePath);
+	const acceptRE = /(?:\bimport\.meta\.hot|\b__nasti_hot__)(?:(?:\?\.)|\.)accept\s*\(/g;
+	const searchableCode = maskStringsAndComments(code);
+	let isSelfAccepting = false;
+	let match;
+	while (match = acceptRE.exec(searchableCode)) {
+		let cursor = match.index + match[0].length;
+		const skipTrivia = () => {
+			while (cursor < code.length) {
+				if (/\s/.test(code[cursor])) {
+					cursor++;
+					continue;
+				}
+				if (code[cursor] === "/" && code[cursor + 1] === "/") {
+					cursor += 2;
+					while (cursor < code.length && code[cursor] !== "\n") cursor++;
+					continue;
+				}
+				if (code[cursor] === "/" && code[cursor + 1] === "*") {
+					cursor += 2;
+					while (cursor < code.length && !(code[cursor] === "*" && code[cursor + 1] === "/")) cursor++;
+					cursor += 2;
+					continue;
+				}
+				break;
+			}
+		};
+		skipTrivia();
+		const first = code[cursor];
+		if (!first || first === ")" || first !== "[" && first !== "'" && first !== "\"" && first !== "`") {
+			isSelfAccepting = true;
+			continue;
+		}
+		const readLiteral = () => {
+			const quote = code[cursor];
+			if (quote !== "'" && quote !== "\"" && quote !== "`") return;
+			const start = cursor;
+			cursor++;
+			let raw = "";
+			while (cursor < code.length) {
+				const char = code[cursor];
+				if (char === "\\") {
+					raw += code[cursor + 1] ?? "";
+					cursor += 2;
+					continue;
+				}
+				if (char === quote) {
+					cursor++;
+					const resolved = removeTimestampQuery(resolveSpec(raw));
+					acceptedUrls.add(resolved);
+					edits.push({
+						start,
+						end: cursor,
+						value: JSON.stringify(resolved)
+					});
+					return;
+				}
+				if (quote === "`" && char === "$" && code[cursor + 1] === "{") return;
+				raw += char;
+				cursor++;
+			}
+		};
+		if (first === "[") {
+			cursor++;
+			while (cursor < code.length) {
+				skipTrivia();
+				if (code[cursor] === ",") {
+					cursor++;
+					skipTrivia();
+				}
+				if (code[cursor] === "]") break;
+				const before = cursor;
+				readLiteral();
+				if (cursor === before) break;
+			}
+		} else readLiteral();
+	}
+	for (const edit of edits.sort((a, b) => b.start - a.start)) code = code.slice(0, edit.start) + edit.value + code.slice(edit.end);
+	return {
+		code,
+		acceptedUrls,
+		isSelfAccepting
+	};
+}
+/** 用等长空格遮蔽字符串、模板字面量和注释，避免把文档文本误识别为 HMR 调用。 */
+function maskStringsAndComments(code) {
+	const masked = code.split("");
+	let state = "code";
+	const isRegexStart = (index) => {
+		let previous = index - 1;
+		while (previous >= 0 && /\s/.test(code[previous])) previous--;
+		return previous < 0 || "=(:,!&|?{};[]+-*%^~<>".includes(code[previous]);
+	};
+	for (let i = 0; i < code.length; i++) {
+		const char = code[i];
+		const next = code[i + 1];
+		if (state === "code") {
+			if (char === "'") state = "single";
+			else if (char === "\"") state = "double";
+			else if (char === "`") state = "template";
+			else if (char === "/" && next === "/") state = "line-comment";
+			else if (char === "/" && next === "*") state = "block-comment";
+			else if (char === "/" && isRegexStart(i)) state = "regex";
+			else continue;
+			masked[i] = " ";
+			continue;
+		}
+		if (state === "line-comment") {
+			if (char === "\n") state = "code";
+			else masked[i] = " ";
+			continue;
+		}
+		if (state === "block-comment") {
+			masked[i] = char === "\n" ? "\n" : " ";
+			if (char === "*" && next === "/") {
+				masked[i + 1] = " ";
+				i++;
+				state = "code";
+			}
+			continue;
+		}
+		if (state === "regex" || state === "regex-class") {
+			masked[i] = char === "\n" ? "\n" : " ";
+			if (char === "\\") {
+				if (i + 1 < code.length) masked[++i] = " ";
+			} else if (state === "regex" && char === "[") state = "regex-class";
+			else if (state === "regex-class" && char === "]") state = "regex";
+			else if (state === "regex" && char === "/") state = "code";
+			continue;
+		}
+		masked[i] = char === "\n" ? "\n" : " ";
+		if (char === "\\") {
+			if (i + 1 < code.length) masked[++i] = " ";
+			continue;
+		}
+		if (state === "single" && char === "'" || state === "double" && char === "\"" || state === "template" && char === "`") state = "code";
+	}
+	return masked.join("");
+}
+/**
+* 把 alias 值统一成磁盘绝对路径。
+*   - `/Users/.../src` 这类绝对路径直接用
+*   - `/src` 这类用户写的「项目根相对」路径按 `<root>/src` 处理
+*   - 其余字符串相对 root 解析
+*/
+function resolveAliasTarget(value, root) {
+	if (path.isAbsolute(value) && fs.existsSync(value)) return value;
+	if (value.startsWith("/")) return path.join(root, value.slice(1));
+	return path.resolve(root, value);
+}
+/** 把磁盘上的目标路径补全为存在的文件（扩展名 / index 兜底）。 */
+function tryResolveDiskPath(target) {
+	if (fs.existsSync(target) && fs.statSync(target).isFile()) return target;
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const withExt = target + ext;
+		if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) return withExt;
+	}
+	if (fs.existsSync(target) && fs.statSync(target).isDirectory()) for (const ext of RESOLVE_EXTENSIONS) {
+		const idx = path.join(target, "index" + ext);
+		if (fs.existsSync(idx) && fs.statSync(idx).isFile()) return idx;
+	}
+	return null;
+}
+function appendTimestampQuery(url, timestamp) {
+	const hashIndex = url.indexOf("#");
+	const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+	const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+	return `${withoutHash}${withoutHash.includes("?") ? "&" : "?"}t=${timestamp}${hash}`;
+}
+const RESOLVE_EXTENSIONS = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js",
+	".mjs",
+	".json",
+	".vue"
+];
+const ESM_CONDITIONS = [
+	"import",
+	"browser",
+	"module",
+	"default"
+];
+/**
+* 把 bundle 中被 external 化的 bare specifier 解析为浏览器可加载的 URL。
+*
+* 关键：相对「正在打包的包自身的真实目录」解析（而非项目根）。pnpm 严格布局下，
+* 传递依赖不会被提升到顶层 node_modules（只有直接依赖以 symlink 形式出现在那里），
+* 真实文件在 `.pnpm/<pkg>@<ver>/node_modules/` 内，其依赖是同目录下的兄弟包。
+* 从项目根向上走只能找到直接依赖 → 传递依赖（如 react-router 的 @tanstack/router-core）
+* 必然 404。改为从 importer 包的真实目录向上走即可命中。
+*
+* URL 去重（关键，关系到 React 等对实例唯一性敏感的库能否工作）：用户源码里的裸 import
+* 被 rewriteImports 改写成裸 `/@modules/<spec>`，并由 dev server 从项目根解析。若从 importer
+* 真实目录解析与从项目根解析命中**同一真实文件**（npm/yarn 扁平布局，或依赖已被提升到顶层
+* node_modules），就必须同样发裸 URL —— 浏览器按 URL 字符串去重，带 `?id=` 会被当成另一个
+* 模块重复实例化。否则 app 的 `/@modules/react` 与 react-dom 外部化得到的
+* `/@modules/react?id=...` 会变成两份 React → 二者 dispatcher 不互通 → useEffect 读到 null →
+* "Invalid hook call. Hooks can only be called inside of the body of a function component"。
+*
+* 仅当项目根解析不到、或解析到的是**不同文件**（pnpm 未提升的传递依赖、多版本并存）时，
+* 才把 importer 相对解析到的绝对路径编码进 `?id=`，dev server 据此直接打包该文件，无需再次
+* 从 root 解析（见 transformRequest 中的 `/@modules/...?id=` 分支）。
+*/
+function externalSpecToModuleUrl(spec, baseDir, root) {
+	const resolved = resolveNodeModule(baseDir, spec);
+	if (!resolved) return `/@modules/${spec}`;
+	const rootResolved = resolveNodeModule(root, spec);
+	if (rootResolved && rootResolved === resolved) return `/@modules/${spec}`;
+	return `/@modules/${spec}?id=${encodeURIComponent(resolved)}`;
+}
+/**
+* ESM-aware node_modules 解析：支持 package.json exports 字段的 import/browser/module/default 条件，
+* 兼容 ESM-only 包（如只有 "import" 条件而无 "require" 的包）。
+* createRequire 使用 CJS 解析逻辑，遇到 ESM-only exports 会抛异常，因此不能用于此场景。
+*
+* **返回真实路径**（解析 symlink）：pnpm 把直接依赖以 symlink 放在顶层 node_modules，
+* 真实文件在 `.pnpm/.../node_modules/` 下。后续打包阶段用 `dirname(entryFile)` 向上找
+* 传递依赖，只有从真实路径出发才能命中那些未被提升的兄弟包。
+*/
+function resolveNodeModule(baseDir, moduleName) {
+	const resolved = resolveNodeModuleEntry(baseDir, moduleName);
+	if (!resolved) return null;
+	try {
+		return fs.realpathSync(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function resolveNodeModuleEntry(root, moduleName) {
+	let pkgName;
+	let subpath;
+	if (moduleName.startsWith("@")) {
+		const parts = moduleName.split("/");
+		pkgName = parts.slice(0, 2).join("/");
+		subpath = parts.slice(2).join("/");
+	} else {
+		const slash = moduleName.indexOf("/");
+		pkgName = slash === -1 ? moduleName : moduleName.slice(0, slash);
+		subpath = slash === -1 ? "" : moduleName.slice(slash + 1);
+	}
+	let pkgDir = null;
+	let dir = root;
+	for (;;) {
+		const candidate = path.join(dir, "node_modules", pkgName);
+		if (fs.existsSync(candidate)) {
+			pkgDir = candidate;
+			break;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	if (!pkgDir) return null;
+	const pkgJsonPath = path.join(pkgDir, "package.json");
+	if (!fs.existsSync(pkgJsonPath)) return null;
+	let pkg;
+	try {
+		pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	if (pkg.exports) {
+		const exportKey = subpath ? `./${subpath}` : ".";
+		const resolved = resolvePackageExports(pkg.exports, exportKey, pkgDir);
+		if (resolved) return resolved;
+	}
+	if (subpath) {
+		const subDirs = [""];
+		for (const field of ["module", "main"]) if (typeof pkg[field] === "string") {
+			const dir = path.dirname(pkg[field]);
+			if (dir && dir !== "." && !subDirs.includes(dir)) subDirs.push(dir);
+		}
+		for (const dir of subDirs) {
+			const direct = path.join(pkgDir, dir, subpath);
+			if (fs.existsSync(direct) && fs.statSync(direct).isFile()) return direct;
+			for (const ext of RESOLVE_EXTENSIONS) if (fs.existsSync(direct + ext)) return direct + ext;
+		}
+		return null;
+	}
+	for (const field of [
+		"module",
+		"jsnext:main",
+		"jsnext",
+		"main"
+	]) if (typeof pkg[field] === "string") {
+		const entry = path.join(pkgDir, pkg[field]);
+		if (fs.existsSync(entry)) return entry;
+	}
+	const indexFallback = path.join(pkgDir, "index.js");
+	if (fs.existsSync(indexFallback)) return indexFallback;
+	return null;
+}
+function resolvePackageExports(exports, key, pkgDir) {
+	if (typeof exports === "string") return key === "." ? path.join(pkgDir, exports) : null;
+	const entry = exports[key];
+	if (entry === void 0) {
+		if (key === "." && typeof exports === "object" && !Object.keys(exports).some((k) => k.startsWith("."))) return resolveExportValue(exports, pkgDir);
+		return null;
+	}
+	return resolveExportValue(entry, pkgDir);
+}
+function resolveExportValue(value, pkgDir) {
+	if (typeof value === "string") return path.join(pkgDir, value);
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const r = resolveExportValue(item, pkgDir);
+			if (r) return r;
+		}
+		return null;
+	}
+	if (value && typeof value === "object") {
+		for (const cond of ESM_CONDITIONS) if (cond in value) {
+			const r = resolveExportValue(value[cond], pkgDir);
+			if (r) return r;
+		}
+	}
+	return null;
+}
+function resolveUrlToFile(url, root) {
+	const cleanUrl = url.split(/[?#]/)[0];
+	if (cleanUrl.startsWith("/@modules/")) return resolveNodeModule(root, cleanUrl.slice(10));
+	if (cleanUrl.startsWith("/@fs/")) {
+		let abs = cleanUrl.slice(5);
+		if (process.platform === "win32") abs = abs.replace(/\//g, path.sep);
+		else if (!abs.startsWith("/")) abs = "/" + abs;
+		try {
+			const real = fs.realpathSync(abs);
+			if (fs.statSync(real).isFile() && isAllowedDevModulePath(real, root)) return real;
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	const filePath = path.resolve(root, cleanUrl.replace(/^\//, ""));
+	if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) return filePath;
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const withExt = filePath + ext;
+		if (fs.existsSync(withExt)) return withExt;
+	}
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const indexFile = path.join(filePath, "index" + ext);
+		if (fs.existsSync(indexFile)) return indexFile;
+	}
+	return null;
+}
+function isModuleRequest(url, destination) {
+	const cleanUrl = url.split(/[?#]/)[0];
+	if (/\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl)) return true;
+	if (cleanUrl.startsWith("/@modules/")) return true;
+	if (cleanUrl.startsWith("/@fs/")) return true;
+	if (isAssetFile(cleanUrl)) {
+		const qIdx = url.indexOf("?");
+		const hIdx = url.indexOf("#");
+		const queryEnd = hIdx === -1 ? url.length : hIdx;
+		const query = qIdx === -1 || qIdx > queryEnd ? "" : url.slice(qIdx + 1, queryEnd);
+		return /(?:^|&)(?:url|raw)(?:&|$)/.test(query) || destination === "script";
+	}
+	if (!path.extname(cleanUrl)) return true;
+	return false;
+}
+function getHmrClientCode() {
+	return `
+// Nasti HMR Client
+const socketProtocol = location.protocol === 'https:' ? 'wss' : 'ws';
+const socket = new WebSocket(socketProtocol + '://' + location.host, 'nasti-hmr');
+const hotModulesMap = new Map();
+const disposeMap = new Map();
+const pruneMap = new Map();
+const dataMap = new Map();
+const customListenersMap = new Map();
+let updateQueue = [];
+let pendingUpdateQueue = false;
+
+socket.addEventListener('message', async ({ data }) => {
+  const payload = JSON.parse(data);
+  // 默认浏览器 client 只消费自己的 HMR 消息；native/worker 环境通过各自的
+  // HotChannel 或 app-level HMR 协调器处理同一 transport 上的命名消息。
+  if (payload.environment && payload.environment !== 'client') return;
+  switch (payload.type) {
+    case 'connected':
+      console.debug('[nasti] connected.');
+      clearErrorOverlay();
+      break;
+    case 'update':
+      try {
+        // CSS 在 unbundled 模式下也是会注入 <style> 的 JS 模块，和普通 JS
+        // 一样重新 import 才能执行 dispose/accept 并保持页面状态。
+        await Promise.all(payload.updates.map(queueUpdate));
+        clearErrorOverlay();
+        console.debug('[nasti] HMR update complete.');
+      } catch (err) {
+        console.error('[nasti] HMR update failed:', err);
+        showErrorOverlay(err);
+      }
+      break;
+    case 'full-reload':
+      console.log('[nasti] full reload');
+      location.reload();
+      break;
+    case 'prune':
+      await Promise.all(payload.paths.map(async (path) => {
+        const data = dataMap.get(path);
+        const dispose = disposeMap.get(path);
+        const prune = pruneMap.get(path);
+        if (dispose) await dispose(data);
+        if (prune) await prune(data);
+        hotModulesMap.delete(path);
+        disposeMap.delete(path);
+        pruneMap.delete(path);
+        dataMap.delete(path);
+        clearCustomListeners(path);
+      }));
+      break;
+    case 'custom': {
+      const listenersByOwner = customListenersMap.get(payload.event);
+      if (!listenersByOwner) break;
+      const results = await Promise.allSettled(
+        [...listenersByOwner.values()]
+          .flatMap((listeners) => [...listeners])
+          .map((listener) => Promise.resolve().then(() => listener(payload.data)))
+      );
+      for (const result of results) {
+        if (result.status === 'rejected') {
+          console.error('[nasti] custom HMR event listener failed:', result.reason);
+        }
+      }
+      break;
+    }
+    case 'error':
+      console.error('[nasti] error:', payload.err.message);
+      showErrorOverlay(payload.err);
+      break;
+  }
+});
+
+// 服务重启后旧模块图已失效，重连时整页刷新是必要兜底；正常 update 不再刷新。
+let reconnectTimer = 0;
+socket.addEventListener('close', () => {
+  clearTimeout(reconnectTimer);
+  reconnectTimer = setTimeout(() => location.reload(), 1000);
+});
+
+/**
+ * 同一批更新先全部拉取，再按服务端消息顺序执行 accept 回调，避免 HTTP 往返速度
+ * 改变模块应用顺序。这与 Vite HMRClient 的 fetch/apply 两阶段一致。
+ */
+async function queueUpdate(update) {
+  updateQueue.push(fetchUpdate(update));
+  if (pendingUpdateQueue) return;
+
+  pendingUpdateQueue = true;
+  await Promise.resolve();
+  pendingUpdateQueue = false;
+  const loading = updateQueue;
+  updateQueue = [];
+  const applyUpdates = await Promise.all(loading);
+  for (const apply of applyUpdates) {
+    if (apply) apply();
+  }
+}
+
+async function fetchUpdate(update) {
+  const mod = hotModulesMap.get(update.path);
+  // 尚未在当前页面加载的动态模块不需要更新。
+  if (!mod) return;
+
+  // 必须在重新 import 前确定旧回调；新模块执行 createHotContext 时会清空并注册新回调。
+  const qualifiedCallbacks = mod.callbacks.filter(({ deps }) =>
+    deps.includes(update.acceptedPath)
+  );
+  const isSelfUpdate = update.path === update.acceptedPath;
+  if (!isSelfUpdate && qualifiedCallbacks.length === 0) return;
+
+  const dispose = disposeMap.get(update.acceptedPath);
+  if (dispose) await dispose(dataMap.get(update.acceptedPath));
+  const newMod = await import(appendTimestampQuery(update.acceptedPath, update.timestamp));
+
+  return () => {
+    for (const { deps, fn } of qualifiedCallbacks) {
+      fn(deps.map((dep) => dep === update.acceptedPath ? newMod : undefined));
+    }
+    const detail = isSelfUpdate
+      ? update.path
+      : update.acceptedPath + ' via ' + update.path;
+    console.debug('[nasti] hot updated:', detail);
+  };
+}
+
+function appendTimestampQuery(url, timestamp) {
+  const hashIndex = url.indexOf('#');
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : '';
+  const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  return withoutHash + (withoutHash.includes('?') ? '&' : '?') + 't=' + timestamp + hash;
+}
+
+function clearErrorOverlay() {
+  const el = document.getElementById('nasti-error-overlay');
+  if (el) el.remove();
+}
+
+function showErrorOverlay(err) {
+  clearErrorOverlay();
+  const overlay = document.createElement('div');
+  overlay.id = 'nasti-error-overlay';
+  overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
+  const title = document.createElement('h2');
+  title.style.color = '#ff5555';
+  title.textContent = 'Build Error';
+  const pre = document.createElement('pre');
+  pre.textContent = err.message + '\\n' + (err.stack || '');
+  const btn = document.createElement('button');
+  btn.style.cssText = 'margin-top:1rem;padding:0.5rem 1rem;cursor:pointer';
+  btn.textContent = 'Close';
+  btn.onclick = () => overlay.remove();
+  overlay.appendChild(title);
+  overlay.appendChild(pre);
+  overlay.appendChild(btn);
+  document.body.appendChild(overlay);
+}
+
+export function createHotContext(ownerPath) {
+  if (!dataMap.has(ownerPath)) dataMap.set(ownerPath, {});
+
+  // 模块重新执行时丢弃旧 accept 回调，但保留同一个 hot.data 对象。
+  const existing = hotModulesMap.get(ownerPath);
+  if (existing) existing.callbacks = [];
+  clearCustomListeners(ownerPath);
+
+  const acceptDeps = (deps, callback = () => {}) => {
+    const mod = hotModulesMap.get(ownerPath) || { id: ownerPath, callbacks: [] };
+    mod.callbacks.push({ deps, fn: callback });
+    hotModulesMap.set(ownerPath, mod);
+  };
+
+  return {
+    accept(deps, callback) {
+      if (typeof deps === 'function' || deps === undefined) {
+        acceptDeps([ownerPath], ([mod]) => deps?.(mod));
+      } else if (typeof deps === 'string') {
+        acceptDeps([deps], ([mod]) => callback?.(mod));
+      } else if (Array.isArray(deps)) {
+        acceptDeps(deps, callback);
+      } else {
+        throw new Error('invalid hot.accept() usage');
+      }
+    },
+    prune(callback) {
+      pruneMap.set(ownerPath, callback);
+    },
+    dispose(callback) {
+      disposeMap.set(ownerPath, callback);
+    },
+    on(event, callback) {
+      let listenersByOwner = customListenersMap.get(event);
+      if (!listenersByOwner) {
+        listenersByOwner = new Map();
+        customListenersMap.set(event, listenersByOwner);
+      }
+      let listeners = listenersByOwner.get(ownerPath);
+      if (!listeners) {
+        listeners = new Set();
+        listenersByOwner.set(ownerPath, listeners);
+      }
+      listeners.add(callback);
+    },
+    off(event, callback) {
+      const listenersByOwner = customListenersMap.get(event);
+      const listeners = listenersByOwner?.get(ownerPath);
+      listeners?.delete(callback);
+      if (listeners?.size === 0) listenersByOwner.delete(ownerPath);
+      if (listenersByOwner?.size === 0) customListenersMap.delete(event);
+    },
+    invalidate() {
+      location.reload();
+    },
+    data: dataMap.get(ownerPath),
+  };
+}
+
+function clearCustomListeners(ownerPath) {
+  for (const [event, listenersByOwner] of customListenersMap) {
+    listenersByOwner.delete(ownerPath);
+    if (listenersByOwner.size === 0) customListenersMap.delete(event);
+  }
+}
+`;
+}
+//#endregion
+//#region src/server/hmr.ts
+async function handleFileChange(file, server, environmentName = "client", timestamp = Date.now()) {
+	const { config } = server;
+	const environment = server.environments[environmentName];
+	if (!environment) throw new Error(`[nasti] unknown dev environment "${environmentName}"`);
+	const moduleGraph = environment.moduleGraph;
+	const logger = config.logger;
+	const relativePath = "/" + path.relative(config.root, file);
+	const shortFile = path.relative(config.root, file);
+	let mods = moduleGraph.getModulesByFile(file);
+	if (!mods || mods.size === 0) try {
+		const real = fs.realpathSync(file);
+		if (real !== file) mods = moduleGraph.getModulesByFile(real);
+		if (mods && mods.size > 0) file = real;
+	} catch {}
+	if (!mods || mods.size === 0) {
+		const packageRoot = findNearestPackageRoot(file);
+		if (packageRoot && getLinkedPackageRoots(config.root).some((r) => packageRoot === r || packageRoot.startsWith(r + path.sep))) {
+			const under = moduleGraph.getModulesWithFileUnder(packageRoot);
+			if (under.size > 0) mods = under;
+		}
+	}
+	if (!mods || mods.size === 0) return null;
+	const updates = [];
+	const graph = moduleGraph;
+	const invalidatedModules = /* @__PURE__ */ new Set();
+	const affectedSet = /* @__PURE__ */ new Set();
+	let fullReload = false;
+	for (const mod of mods) {
+		graph.invalidateModuleAndImporters(mod, timestamp, invalidatedModules);
+		const ctx = {
+			file,
+			timestamp,
+			modules: [mod],
+			read: () => fs.readFileSync(file, "utf-8"),
+			server,
+			environment
+		};
+		let affectedModules = [mod];
+		for (const plugin of environment.plugins) if (plugin.handleHotUpdate) {
+			const result = await plugin.handleHotUpdate(ctx);
+			if (result) affectedModules = result;
+		}
+		for (const affected of affectedModules) {
+			affectedSet.add(affected);
+			graph.invalidateModuleAndImporters(affected, timestamp, invalidatedModules);
+			const boundaries = graph.getHmrBoundaries(affected);
+			if (boundaries.length === 0) {
+				fullReload = true;
+				continue;
+			}
+			for (const { boundary, acceptedVia } of boundaries) {
+				const update = {
+					type: boundary.type === "css" ? "css-update" : "js-update",
+					path: boundary.url,
+					acceptedPath: acceptedVia.url,
+					timestamp
+				};
+				if (!updates.some((existing) => existing.type === update.type && existing.path === update.path && existing.acceptedPath === update.acceptedPath)) updates.push(update);
+			}
+		}
+	}
+	const transformed = await Promise.all([...affectedSet].map(async (module) => ({
+		module,
+		result: await environment.transformRequest(module.url)
+	})));
+	const logPrefix = environmentName === "client" ? "" : `[${environmentName}] `;
+	if (fullReload) {
+		logger.info(pc.green(`${logPrefix}reload `) + pc.dim(shortFile), { timestamp: true });
+		environment.hot.send({
+			type: "full-reload",
+			path: relativePath
+		});
+	} else if (updates.length > 0) {
+		logger.info(updates.map((u) => pc.green(`${logPrefix}hmr update `) + pc.dim(u.path)).join("\n"), { timestamp: true });
+		environment.hot.send({
+			type: "update",
+			updates
+		});
+	}
+	return {
+		environment,
+		modules: [...affectedSet],
+		updates,
+		transformed,
+		fullReload
+	};
+}
+//#endregion
+//#region src/server/index.ts
+var server_exports = /* @__PURE__ */ __exportAll({ createServer: () => createServer });
+async function createServer(inlineConfig = {}) {
+	const startTime = performance.now();
+	const config = await resolveConfig(inlineConfig, "serve");
+	const logger = config.logger;
+	const allPlugins = resolvePluginList(config, config.plugins, { environmentName: "client" });
+	const configWithPlugins = {
+		...config,
+		plugins: allPlugins
+	};
+	const app = connect();
+	const httpServer = http.createServer(app);
+	const ws = createWebSocketServer(httpServer);
+	const pluginApi = getPluginApi(config);
+	const clientEnv = new NastiEnvironment("client", config, {
+		hot: createWsHotChannel(ws, "client"),
+		mode: "dev",
+		plugins: allPlugins,
+		pluginApi
+	});
+	await clientEnv.init();
+	const environments = { client: clientEnv };
+	for (const name of Object.keys(config.environments)) {
+		if (name === "client") continue;
+		const consumer = config.environments[name].consumer;
+		const envPlugins = resolvePluginList(config, config.plugins, {
+			consumer,
+			environmentName: name
+		});
+		environments[name] = new NastiEnvironment(name, config, {
+			hot: consumer === "client" ? createWsHotChannel(ws, name) : void 0,
+			mode: "dev",
+			plugins: envPlugins,
+			pluginApi
+		});
+	}
+	for (const [name, environment] of Object.entries(environments)) if (name === "client" || environment.consumer === "client" || environment.options.driver) await environment.init();
+	const transformContexts = /* @__PURE__ */ new Map();
+	for (const environment of Object.values(environments)) {
+		if (environment.consumer !== "client" || environment.driver) continue;
+		const environmentConfig = {
+			...configWithPlugins,
+			resolve: environment.options.resolve,
+			build: environment.options.build,
+			plugins: environment.plugins
+		};
+		const context = {
+			config: environmentConfig,
+			pluginContainer: environment.pluginContainer,
+			moduleGraph: environment.moduleGraph,
+			environment,
+			envDefine: buildEnvDefine(loadEnv(environmentConfig.mode, environmentConfig.root, environmentConfig.envPrefix), environmentConfig.mode, ssrDefineOverrides(environment.consumer)),
+			onPrune: (paths) => environment.hot.send({
+				type: "prune",
+				paths
+			})
+		};
+		transformContexts.set(environment.name, context);
+		environment.configureDevPipeline((url) => transformRequest(url, context));
+	}
+	let ssrRunner = null;
+	async function getSsrRunner() {
+		if (ssrRunner) return ssrRunner;
+		const ssrEnv = environments.ssr;
+		if (!ssrEnv) throw new Error("[nasti] no \"ssr\" environment configured (config.environments.ssr)");
+		await ssrEnv.init();
+		const { createModuleRunner } = await import("./runnable-environment-BjoOvdDa.js");
+		ssrRunner = createModuleRunner(ssrEnv);
+		return ssrRunner;
+	}
+	const moduleGraph = clientEnv.moduleGraph;
+	let bundledServer = null;
+	if (config.experimental.bundledDev) {
+		const { createBundledDevServer } = await import("./dev-engine-DapuTPIz.js");
+		bundledServer = await createBundledDevServer({
+			config: configWithPlugins,
+			clientEnv,
+			httpServer
+		});
+		app.use(bundledServer.middleware);
+	}
+	const ignoredSegments = /* @__PURE__ */ new Set([
+		"node_modules",
+		".git",
+		".nasti"
+	]);
+	const outDirAbs = path.resolve(config.root, config.build.outDir);
+	const linkedPackageRoots = getLinkedPackageRoots(config.root).filter((r) => r !== config.root && !isUnderRoot(config.root, r));
+	const watchTargets = [config.root, ...linkedPackageRoots];
+	const watcher = watch(watchTargets, {
+		ignored: (filePath) => {
+			if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path.sep)) return true;
+			for (const watchRoot of watchTargets) {
+				if (filePath === watchRoot) return false;
+				const rel = path.relative(watchRoot, filePath);
+				if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
+				for (const seg of rel.split(path.sep)) if (ignoredSegments.has(seg)) return true;
+				return false;
+			}
+			return false;
+		},
+		ignoreInitial: true
+	});
+	await new Promise((resolve, reject) => {
+		const onReady = () => {
+			watcher.off("error", onError);
+			resolve();
+		};
+		const onError = (err) => {
+			watcher.off("ready", onReady);
+			reject(err);
+		};
+		watcher.once("ready", onReady);
+		watcher.once("error", onError);
+	});
+	let server;
+	const environmentServices = {};
+	let environmentDriversStarted = false;
+	let devPipelinesStarted = false;
+	const startDevPipelines = async () => {
+		if (devPipelinesStarted) return;
+		devPipelinesStarted = true;
+		for (const environment of Object.values(environments)) {
+			if (!transformContexts.has(environment.name)) continue;
+			await environment.pluginContainer.buildStart();
+		}
+	};
+	const logCloseError = (target, error) => {
+		const normalized = error instanceof Error ? error : new Error(String(error));
+		logger.error(`[nasti] failed to close ${target}`, { error: normalized });
+	};
+	const startEnvironmentDrivers = async () => {
+		if (environmentDriversStarted) return;
+		environmentDriversStarted = true;
+		const started = [];
+		const attempted = [];
+		try {
+			for (const [name, environment] of Object.entries(environments)) {
+				if (!environment.driver?.serve) continue;
+				attempted.push(environment);
+				const result = await environment.driver.serve({
+					...environment.getDriverContext(),
+					server
+				});
+				started.push({
+					name,
+					environment,
+					service: result ?? {}
+				});
+			}
+			for (const { name, service } of started) {
+				environmentServices[name] = service;
+				if (service.middleware) app.use(service.middleware);
+			}
+		} catch (error) {
+			environmentDriversStarted = false;
+			for (const { name } of started) delete environmentServices[name];
+			for (const environment of attempted.reverse()) try {
+				await environment.driver?.close?.(environment.getDriverContext());
+			} catch (closeError) {
+				logCloseError(`environment driver "${environment.driver.name}"`, closeError);
+			}
+			throw error;
+		}
+	};
+	const notifyEnvironmentDrivers = (file, event) => {
+		for (const environment of Object.values(environments)) {
+			if (!environment.driver?.watchChange) continue;
+			Promise.resolve(environment.driver.watchChange(file, event, environment.getDriverContext())).catch((error) => {
+				logger.error(`[nasti] environment driver "${environment.driver.name}" watchChange failed`, { error });
+			});
+		}
+	};
+	const updateClientEnvironments = async (file) => {
+		const timestamp = Date.now();
+		const results = {};
+		for (const environment of Object.values(environments)) {
+			if (environment.consumer !== "client" || environment.driver) continue;
+			try {
+				const result = await handleFileChange(file, server, environment.name, timestamp);
+				if (result) results[environment.name] = result;
+			} catch (error) {
+				const normalized = error instanceof Error ? error : new Error(String(error));
+				logger.error(`[nasti] HMR failed for environment "${environment.name}": ${normalized.message}`, { error: normalized });
+				try {
+					environment.hot.send({
+						type: "error",
+						err: {
+							message: normalized.message,
+							stack: normalized.stack
+						}
+					});
+				} catch (channelError) {
+					const channelFailure = channelError instanceof Error ? channelError : new Error(String(channelError));
+					logger.error(`[nasti] failed to deliver HMR error to environment "${environment.name}"`, { error: channelFailure });
+				}
+			}
+		}
+		if (Object.keys(results).length === 0) return;
+		const context = {
+			file,
+			timestamp,
+			environments: Object.freeze({ ...results }),
+			server
+		};
+		for (const plugin of config.plugins) await plugin.handleHotUpdateApp?.(context);
+	};
+	const queueClientEnvironmentUpdate = (file) => {
+		updateClientEnvironments(file).catch((error) => {
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			logger.error(`[nasti] multi-environment HMR failed: ${normalized.message}`, { error: normalized });
+		});
+	};
+	watcher.on("change", (file) => {
+		if (file.includes(`${path.sep}node_modules${path.sep}`) || file.endsWith(`${path.sep}node_modules`)) clearLinkedPackageRootsCache();
+		ssrRunner?.invalidateFile(file);
+		queueClientEnvironmentUpdate(file);
+		notifyEnvironmentDrivers(file, "change");
+	});
+	watcher.on("add", (file) => {
+		if (file.includes(`${path.sep}node_modules${path.sep}`) || file.endsWith(`${path.sep}node_modules`)) clearLinkedPackageRootsCache();
+		ssrRunner?.invalidateFile(file);
+		queueClientEnvironmentUpdate(file);
+		notifyEnvironmentDrivers(file, "add");
+	});
+	watcher.on("unlink", (file) => {
+		if (file.includes(`${path.sep}node_modules${path.sep}`) || file.endsWith(`${path.sep}node_modules`)) clearLinkedPackageRootsCache();
+		ssrRunner?.invalidateFile(file);
+		notifyEnvironmentDrivers(file, "unlink");
+	});
+	server = {
+		config: configWithPlugins,
+		middlewares: app,
+		moduleGraph,
+		watcher,
+		ws,
+		environments,
+		environmentServices,
+		async listen(port) {
+			const finalPort = port ?? config.server.port;
+			const host = config.server.host === true ? "0.0.0.0" : config.server.host;
+			await startDevPipelines();
+			await startEnvironmentDrivers();
+			return new Promise((resolve, reject) => {
+				let currentPort = finalPort;
+				const onListening = () => {
+					const actualPort = httpServer.address()?.port ?? currentPort;
+					config.server.port = actualPort;
+					const localUrl = `http://localhost:${actualPort}/`;
+					const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}/` : null;
+					const driverLocalUrls = Object.values(environmentServices).flatMap((service) => service.localUrls ?? []);
+					const driverNetworkUrls = Object.values(environmentServices).flatMap((service) => service.networkUrls ?? []);
+					logger.clearScreen("info");
+					const readyIn = Math.ceil(performance.now() - startTime);
+					logger.info(`\n  ${pc.cyan(pc.bold("NASTI"))} ${pc.cyan(`v2.5.2`)}  ${pc.dim("ready in")} ${pc.bold(readyIn)} ${pc.dim("ms")}\n`);
+					printServerUrls({
+						local: [localUrl, ...driverLocalUrls],
+						network: [...networkUrl ? [networkUrl] : [], ...driverNetworkUrls]
+					}, logger.info);
+					logger.info("");
+					resolve(server);
+				};
+				httpServer.on("listening", onListening);
+				httpServer.on("error", (err) => {
+					if (err.code === "EADDRINUSE") {
+						currentPort++;
+						logger.info(pc.yellow(`Port ${currentPort - 1} is in use, trying ${currentPort}...`));
+						httpServer.listen(currentPort, host);
+					} else reject(err);
+				});
+				httpServer.listen(currentPort, host);
+			});
+		},
+		async transformRequest(url) {
+			return clientEnv.transformRequest(url);
+		},
+		async transformEnvironmentRequest(environmentName, url) {
+			const environment = environments[environmentName];
+			if (!environment) throw new Error(`[nasti] unknown dev environment "${environmentName}"`);
+			return environment.transformRequest(url);
+		},
+		async ssrLoadModule(url) {
+			return (await getSsrRunner()).import(url);
+		},
+		async close() {
+			if (devPipelinesStarted) for (const environment of Object.values(environments).reverse()) {
+				if (!transformContexts.has(environment.name)) continue;
+				await environment.pluginContainer.buildEnd();
+			}
+			await bundledServer?.close();
+			let environmentCloseFailed = false;
+			let firstEnvironmentCloseError;
+			for (const environment of Object.values(environments).reverse()) try {
+				await environment.close();
+			} catch (error) {
+				if (!environmentCloseFailed) {
+					environmentCloseFailed = true;
+					firstEnvironmentCloseError = error;
+				}
+				logCloseError(`environment "${environment.name}"`, error);
+			}
+			await watcher.close();
+			ws.close();
+			httpServer.close();
+			if (environmentCloseFailed) throw firstEnvironmentCloseError;
+		}
+	};
+	try {
+		await startEnvironmentDrivers();
+	} catch (error) {
+		if (bundledServer) try {
+			await bundledServer.close();
+		} catch (closeError) {
+			logCloseError("bundled dev server after driver startup failure", closeError);
+		}
+		try {
+			await watcher.close();
+		} catch (closeError) {
+			logCloseError("file watcher after driver startup failure", closeError);
+		}
+		try {
+			ws.close();
+		} catch (closeError) {
+			logCloseError("WebSocket server after driver startup failure", closeError);
+		}
+		try {
+			httpServer.close();
+		} catch (closeError) {
+			logCloseError("HTTP server after driver startup failure", closeError);
+		}
+		throw error;
+	}
+	app.use(transformMiddleware(transformContexts.get("client")));
+	const publicDir = path.resolve(config.root, "public");
+	app.use(sirv(publicDir, {
+		dev: true,
+		etag: true
+	}));
+	app.use(sirv(config.root, {
+		dev: true,
+		etag: true
+	}));
+	const postMiddlewares = [];
+	for (const plugin of allPlugins) if (plugin.configureServer) {
+		const result = await plugin.configureServer(server);
+		if (typeof result === "function") postMiddlewares.push(result);
+	}
+	for (const run of postMiddlewares) run();
+	return server;
+}
+function getNetworkAddress() {
+	const interfaces = os.networkInterfaces();
+	for (const name of Object.keys(interfaces)) for (const iface of interfaces[name] ?? []) if (iface.family === "IPv4" && !iface.internal) return iface.address;
+	return "localhost";
+}
+//#endregion
+export { server_exports as n, getReactRefreshRuntimeEsm as r, createServer as t };
+
+//# sourceMappingURL=server-Bqgl25z0.js.map