@nasti-toolchain/nasti 2.5.0 → 2.5.2

package/dist/environment-CjmvoHIG.cjs

@@ -0,0 +1,1443 @@
+const require_logger = require("./logger-M7AuVVTV.cjs");
+const require_env = require("./env-lOj3yw8v.cjs");
+let node_url = require("node:url");
+let node_path = require("node:path");
+node_path = require_logger.__toESM(node_path, 1);
+let node_fs = require("node:fs");
+node_fs = require_logger.__toESM(node_fs, 1);
+let picocolors = require("picocolors");
+picocolors = require_logger.__toESM(picocolors, 1);
+let node_module = require("node:module");
+let source_map_js = require("source-map-js");
+let node_crypto = require("node:crypto");
+node_crypto = require_logger.__toESM(node_crypto, 1);
+//#region src/core/debug.ts
+const DEBUG = process.env.DEBUG;
+const filter = process.env.NASTI_DEBUG_FILTER || process.env.VITE_DEBUG_FILTER;
+function createDebugger(namespace, options = {}) {
+	if (!DEBUG) return void 0;
+	const patterns = DEBUG.split(",").map((p) => p.trim());
+	if (!patterns.some((p) => {
+		if (p === "*" || p === "nasti:*" || p === "vite:*") return true;
+		return (p.startsWith("vite:") ? `nasti:${p.slice(5)}` : p) === namespace;
+	})) return void 0;
+	if (options.onlyWhenFocused) {
+		const focus = typeof options.onlyWhenFocused === "string" ? options.onlyWhenFocused : namespace;
+		if (!patterns.includes(focus)) return void 0;
+	}
+	let lastTime = performance.now();
+	return (...args) => {
+		const now = performance.now();
+		const elapsed = now - lastTime;
+		lastTime = now;
+		const msg = args.map((a) => {
+			if (typeof a === "string") return a;
+			try {
+				return JSON.stringify(a);
+			} catch {
+				return String(a);
+			}
+		}).join(" ");
+		if (filter && !msg.includes(filter)) return;
+		console.debug(`${picocolors.default.magenta(namespace)} ${msg} ${picocolors.default.dim(`+${Math.round(elapsed)}ms`)}`);
+	};
+}
+//#endregion
+//#region src/core/css-engine.ts
+const debug$2 = createDebugger("nasti:css");
+function createCssEngine() {
+	return {
+		styles: /* @__PURE__ */ new Map(),
+		modules: /* @__PURE__ */ new Map(),
+		chunks: /* @__PURE__ */ new Map(),
+		entryCss: /* @__PURE__ */ new Map(),
+		allCss: [],
+		pendingSingle: [],
+		singleFileName: null
+	};
+}
+function getCssMetadata(engine) {
+	return {
+		modules: Object.fromEntries([...engine.modules].map(([id, module]) => [id, { ...module }])),
+		chunks: Object.fromEntries([...engine.chunks].map(([fileName, chunk]) => [fileName, {
+			fileName,
+			moduleIds: [...chunk.moduleIds],
+			cssFileNames: [...chunk.cssFileNames]
+		}]))
+	};
+}
+/**
+* 规范化模块 id：去掉 Rolldown 虚拟模块的 null-byte 前缀。
+* **保留 query** —— Vue style 子块（`App.vue?vue&type=style&...&lang.css`）与
+* 父模块 `App.vue` 是不同模块，剥 query 会让二者 key 撞车导致 CSS 重复输出。
+* chunk.moduleIds 里的 id 必须与 transform 期注册的 key 一致 —— 两侧都过这个函数。
+*/
+function normalizeCssModuleId(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+let lightningCss;
+/**
+* 压缩 CSS：优先 Lightning CSS（守卫导入），不可用时回退正则压缩。
+* Tailwind v4 的输出已自行 flatten @import，这里不做 @import 解析。
+*/
+async function minifyCss(css, config) {
+	if (lightningCss === void 0) try {
+		lightningCss = await import("lightningcss");
+	} catch {
+		lightningCss = null;
+		debug$2?.("lightningcss unavailable, falling back to regex minifier");
+	}
+	if (lightningCss) try {
+		const result = lightningCss.transform({
+			filename: "bundle.css",
+			code: Buffer.from(css),
+			minify: true,
+			errorRecovery: true
+		});
+		for (const w of result.warnings ?? []) config.logger.warnOnce(`[nasti:css] ${w.message}`);
+		return result.code.toString();
+	} catch (err) {
+		config.logger.warnOnce(`[nasti:css] Lightning CSS minify failed (${err.message}), emitting unminified CSS`);
+		return css;
+	}
+	return fallbackMinify(css);
+}
+/** 保守的正则压缩：去注释、压空白。不做任何结构性变换。 */
+function fallbackMinify(css) {
+	return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s*([{}:;,])\s*/g, "$1").replace(/;}/g, "}").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/plugins/tailwind.ts
+const TAILWIND_DIRECTIVE_RE = /@(?:import\s+["']tailwindcss(?:\b|\/)|tailwind\b|theme\b|apply\b|plugin\b|source\b|utility\b|variant\b|custom-variant\b|reference\b)/;
+function hasTailwindDirectives(css) {
+	const withoutLineComments = css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+	return TAILWIND_DIRECTIVE_RE.test(withoutLineComments);
+}
+let cached = null;
+let cachedRoot = null;
+async function loadTailwind(projectRoot) {
+	if (cached && cachedRoot === projectRoot) return cached;
+	const req = (0, node_module.createRequire)(node_path.default.join(projectRoot, "package.json"));
+	let nodePath;
+	let oxidePath;
+	try {
+		nodePath = req.resolve("@tailwindcss/node");
+		oxidePath = req.resolve("@tailwindcss/oxide");
+	} catch {
+		throw new Error("[nasti] CSS contains Tailwind v4 directives but `@tailwindcss/node` and/or `@tailwindcss/oxide` are not installed in this project. Install them with:  npm i -D tailwindcss @tailwindcss/node @tailwindcss/oxide");
+	}
+	cached = {
+		node: await import((0, node_url.pathToFileURL)(nodePath).href),
+		oxide: await import((0, node_url.pathToFileURL)(oxidePath).href)
+	};
+	cachedRoot = projectRoot;
+	return cached;
+}
+async function compileTailwind(css, fromFile, projectRoot) {
+	const { node, oxide } = await loadTailwind(projectRoot);
+	const dependencies = [];
+	const compiler = await node.compile(css, {
+		base: node_path.default.dirname(fromFile),
+		from: fromFile,
+		onDependency: (p) => dependencies.push(p)
+	});
+	const scanner = new oxide.Scanner({ sources: compiler.sources });
+	const candidates = scanner.scan();
+	return {
+		css: compiler.build(candidates),
+		dependencies: [...dependencies, ...scanner.files]
+	};
+}
+//#endregion
+//#region src/plugins/css.ts
+function cssPlugin(config, engine, consumer = "client") {
+	return {
+		name: "nasti:css",
+		resolveId(source) {
+			if (source.endsWith(".css")) return null;
+			return null;
+		},
+		async transform(code, id) {
+			const [file, query = ""] = id.split("?", 2);
+			if (!(file.endsWith(".css") || /\.css$/.test(id))) return null;
+			if (query === "raw" || query === "url") return null;
+			let cssSource = code;
+			if (hasTailwindDirectives(code)) cssSource = (await compileTailwind(code, id, config.root)).css;
+			const rewritten = rewriteCssUrls(cssSource, file, config.root);
+			const escaped = JSON.stringify(rewritten);
+			const normalizedId = normalizeCssModuleId(id);
+			const cssModule = {
+				id: normalizedId,
+				source: code,
+				code: rewritten
+			};
+			const map = config.build.sourcemap ? createIdentitySourceMap(code, id) : void 0;
+			engine?.modules.set(normalizedId, cssModule);
+			this.environment?.setCssModule?.(cssModule);
+			if (query === "inline") return {
+				code: `export default ${escaped};\n`,
+				map,
+				moduleType: "js"
+			};
+			if (consumer === "server") return {
+				code: `export default ${escaped};\n`,
+				map,
+				moduleType: "js"
+			};
+			if (config.command === "serve") {
+				if (config.build.css.inject === false) return {
+					code: `export default ${escaped};\n`,
+					map,
+					moduleType: "js",
+					moduleSideEffects: "no-treeshake"
+				};
+				return {
+					code: `
+const css = ${escaped};
+const __nasti_css_id__ = ${JSON.stringify(id)};
+const __nasti_existing__ = document.querySelector('style[data-nasti-css=' + JSON.stringify(__nasti_css_id__) + ']');
+if (__nasti_existing__) __nasti_existing__.remove();
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', __nasti_css_id__);
+style.textContent = css;
+document.head.appendChild(style);
+
+// HMR（prune 在 bundled 模式的 rolldown hot context 上不存在，须守卫）
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  if (import.meta.hot.prune) {
+    import.meta.hot.prune(() => {
+      style.remove();
+    });
+  }
+}
+
+export default css;
+`,
+					map,
+					moduleType: "js"
+				};
+			}
+			if (engine) {
+				engine.styles.set(normalizedId, rewritten);
+				return {
+					code: `export default '';\n`,
+					map,
+					moduleType: "js",
+					moduleSideEffects: "no-treeshake"
+				};
+			}
+			const nonce = (config.build.css || {}).nonce;
+			const nonceAttr = nonce ? `style.setAttribute('nonce', ${JSON.stringify(nonce)});` : "";
+			return {
+				code: `
+const css = ${escaped};
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+${nonceAttr}
+style.textContent = css;
+document.head.appendChild(style);
+
+export default css;
+`,
+				map,
+				moduleType: "js"
+			};
+		}
+	};
+}
+function createIdentitySourceMap(code, id) {
+	const map = new source_map_js.SourceMapGenerator({ file: id });
+	const lines = code.split("\n");
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) for (let column = 0; column <= lines[lineIndex].length; column++) map.addMapping({
+		generated: {
+			line: lineIndex + 1,
+			column
+		},
+		original: {
+			line: lineIndex + 1,
+			column
+		},
+		source: id
+	});
+	map.setSourceContent(id, code);
+	return map.toJSON();
+}
+/** CSS URL 重写（将相对路径转为绝对路径） */
+function rewriteCssUrls(css, from, root) {
+	return css.replace(/url\(\s*['"]?([^'")\s]+)['"]?\s*\)/g, (match, url) => {
+		if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) return match;
+		const resolved = node_path.default.resolve(node_path.default.dirname(from), url);
+		return `url(${"/" + node_path.default.relative(root, resolved).replace(/\\/g, "/")})`;
+	});
+}
+//#endregion
+//#region src/plugins/css-post.ts
+/** 按 chunk 模块执行顺序聚合该 chunk 的 CSS（id 两侧都已规范化） */
+function collectChunkCss(chunk, engine) {
+	const ids = chunk.moduleIds ?? Object.keys(chunk.modules);
+	let css = "";
+	const moduleIds = [];
+	for (const id of ids) {
+		const normalizedId = normalizeCssModuleId(id);
+		const styles = engine.styles.get(normalizedId);
+		if (styles) {
+			css += styles + "\n";
+			moduleIds.push(normalizedId);
+		}
+	}
+	return {
+		css,
+		moduleIds
+	};
+}
+function cssPostPlugin(config, engine) {
+	return {
+		name: "nasti:css-post",
+		enforce: "post",
+		async renderChunk(code, chunk) {
+			const { css, moduleIds } = collectChunkCss(chunk, engine);
+			if (!css) return null;
+			const ownership = {
+				moduleIds,
+				cssFileNames: []
+			};
+			engine.chunks.set(chunk.fileName, ownership);
+			if (config.build.css.emit === false) return null;
+			if (!config.build.cssCodeSplit) {
+				engine.pendingSingle.push(css);
+				return null;
+			}
+			const finalCss = config.build.cssMinify ? await minifyCss(css, config) : css;
+			const ref = this.emitFile({
+				type: "asset",
+				name: `${chunk.name}.css`,
+				source: finalCss
+			});
+			const fileName = this.getFileName(ref);
+			engine.allCss.push(fileName);
+			ownership.cssFileNames.push(fileName);
+			if (chunk.isEntry) {
+				const key = chunk.facadeModuleId ?? chunk.name;
+				const existing = engine.entryCss.get(key) ?? [];
+				existing.push(fileName);
+				engine.entryCss.set(key, existing);
+				return null;
+			}
+			if (config.build.css.inject === false) return null;
+			return {
+				code: code + `\n;(function(){try{var d=document,h=${JSON.stringify(config.base + fileName)};if(!d.querySelector('link[data-nasti-css="'+h+'"]')){var l=d.createElement('link');l.rel='stylesheet';l.href=h;l.setAttribute('data-nasti-css',h);d.head.appendChild(l);}}catch(e){}})();`,
+				map: null
+			};
+		},
+		augmentChunkHash(chunk) {
+			const { css } = collectChunkCss(chunk, engine);
+			return css || void 0;
+		},
+		async generateBundle() {
+			if (config.build.cssCodeSplit || engine.pendingSingle.length === 0) return;
+			const merged = engine.pendingSingle.join("\n");
+			const finalCss = config.build.cssMinify ? await minifyCss(merged, config) : merged;
+			const ref = this.emitFile({
+				type: "asset",
+				name: "style.css",
+				source: finalCss
+			});
+			const fileName = this.getFileName(ref);
+			engine.singleFileName = fileName;
+			engine.allCss.push(fileName);
+			for (const ownership of engine.chunks.values()) if (ownership.moduleIds.length > 0) ownership.cssFileNames.push(fileName);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/assets.ts
+const ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".ico",
+	".webp",
+	".avif",
+	".mp4",
+	".webm",
+	".ogg",
+	".mp3",
+	".wav",
+	".flac",
+	".aac",
+	".woff",
+	".woff2",
+	".eot",
+	".ttf",
+	".otf",
+	".pdf",
+	".txt"
+]);
+function assetsPlugin(config) {
+	const emittedAssets = /* @__PURE__ */ new Set();
+	return {
+		name: "nasti:assets",
+		resolveId(source) {
+			if (source.endsWith("?url") || source.endsWith("?raw")) return source;
+			return null;
+		},
+		load(id) {
+			const ext = node_path.default.extname(id.replace(/\?.*$/, ""));
+			if (id.endsWith("?raw")) {
+				const file = id.slice(0, -4);
+				if (node_fs.default.existsSync(file)) {
+					const content = node_fs.default.readFileSync(file, "utf-8");
+					return `export default ${JSON.stringify(content)}`;
+				}
+			}
+			if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
+				const file = id.replace(/\?.*$/, "");
+				if (!node_fs.default.existsSync(file)) return null;
+				if (config.command === "serve") {
+					const url = "/" + node_path.default.relative(config.root, file);
+					return `export default ${JSON.stringify(url)}`;
+				}
+				const content = node_fs.default.readFileSync(file);
+				const hash = node_crypto.default.createHash("sha256").update(content).digest("hex").slice(0, 8);
+				const basename = node_path.default.basename(file, ext);
+				const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
+				const environment = this.environment;
+				if (!environment) throw new Error("[nasti:assets] build environment is not initialized");
+				if (!emittedAssets.has(hashedName)) {
+					this.emitFile({
+						type: "asset",
+						fileName: hashedName,
+						source: content
+					});
+					emittedAssets.add(hashedName);
+				}
+				environment.setAssetModule(file, hashedName);
+				return `export default ${JSON.stringify(config.base + hashedName)}`;
+			}
+			return null;
+		}
+	};
+}
+function isAssetFile(id) {
+	const ext = node_path.default.extname(id.replace(/\?.*$/, ""));
+	return ASSET_EXTENSIONS.has(ext);
+}
+//#endregion
+//#region src/plugins/vue.ts
+const VUE_FILE_RE = /\.vue$/;
+const VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang[.=]\w+)?/;
+const debug$1 = createDebugger("nasti:vue");
+/** Vapor Mode 测试版免责声明：终端与浏览器控制台共用同一文案 */
+const VAPOR_BETA_WARNING = "Vapor Mode is a beta feature; Zixiao Labs and the Vue team do not provide guarantees against crashes in production environments, and it is not suitable for server-side rendering environments.";
+let compiler = null;
+async function loadVueCompiler() {
+	if (compiler) return compiler;
+	try {
+		compiler = await import("@vue/compiler-sfc");
+		return compiler;
+	} catch {
+		return null;
+	}
+}
+function vuePlugin(config, environmentName = "client") {
+	const isDev = config.command === "serve";
+	const descriptorCache = /* @__PURE__ */ new Map();
+	const vueOptions = config.environments[environmentName]?.vue ?? {};
+	return {
+		name: "nasti:vue",
+		enforce: "pre",
+		async resolveId(source) {
+			if (VUE_QUERY_RE.test(source)) return source;
+			return null;
+		},
+		async load(id) {
+			const match = id.match(/(.+\.vue)\?vue&type=style(?:&index=(\d+))?/);
+			if (!match) return null;
+			const sfc = await loadVueCompiler();
+			if (!sfc) return null;
+			const [, filePath, indexStr] = match;
+			let cached = descriptorCache.get(filePath);
+			if (!cached) try {
+				const rawSource = (await import("node:fs")).readFileSync(filePath, "utf-8");
+				const transformedSfc = await applySourceTransform(vueOptions.transformSfc, rawSource, {
+					filename: filePath,
+					environmentName,
+					type: "sfc"
+				});
+				const parsed = sfc.parse(transformedSfc.code, {
+					...vueOptions.parse,
+					filename: filePath,
+					sourceMap: true
+				});
+				if (parsed.errors.length) return null;
+				cached = {
+					descriptor: parsed.descriptor,
+					sourceMap: transformedSfc.map
+				};
+				descriptorCache.set(filePath, cached);
+			} catch {
+				return null;
+			}
+			const { descriptor, sourceMap: sfcSourceMap } = cached;
+			const index = parseInt(indexStr ?? "0", 10);
+			const style = descriptor.styles[index];
+			if (!style) return null;
+			const scopeId = hashId(filePath);
+			const transformedStyle = await applySourceTransform(vueOptions.transformStyle, style.content, {
+				filename: filePath,
+				environmentName,
+				type: "style",
+				index
+			});
+			const wantsStyleSourceMap = !!config.build.sourcemap || transformedStyle.map != null || sfcSourceMap != null;
+			const styleInputMap = wantsStyleSourceMap ? composeSourceMapChain([
+				transformedStyle.map,
+				style.map,
+				sfcSourceMap
+			], {
+				filename: filePath,
+				environmentName,
+				type: "style",
+				index
+			}) : void 0;
+			const result = await sfc.compileStyleAsync({
+				...vueOptions.style,
+				source: transformedStyle.code,
+				filename: filePath,
+				id: `data-v-${scopeId}`,
+				scoped: style.scoped ?? false,
+				inMap: styleInputMap,
+				preprocessLang: style.lang
+			});
+			if (transformedStyle.map != null && result.map == null) warnUnchainableMap({
+				filename: filePath,
+				environmentName,
+				type: "style",
+				index
+			}, "compiler-sfc did not return a style map");
+			return wantsStyleSourceMap ? {
+				code: result.code,
+				map: result.map
+			} : result.code;
+		},
+		async transform(code, id) {
+			if (!VUE_FILE_RE.test(id) && !VUE_QUERY_RE.test(id)) return null;
+			const sfc = await loadVueCompiler();
+			if (!sfc) {
+				console.warn("[nasti:vue] @vue/compiler-sfc not found. Install it: npm install @vue/compiler-sfc");
+				return null;
+			}
+			if (VUE_QUERY_RE.test(id)) return null;
+			const transformedSfc = await applySourceTransform(vueOptions.transformSfc, code, {
+				filename: id,
+				environmentName,
+				type: "sfc"
+			});
+			code = transformedSfc.code;
+			const { descriptor, errors } = sfc.parse(code, {
+				...vueOptions.parse,
+				filename: id,
+				sourceMap: true
+			});
+			if (errors.length) {
+				const firstError = errors[0];
+				console.error(`[nasti:vue] Parse error in ${id}:`, typeof firstError === "string" ? firstError : firstError.message);
+				return null;
+			}
+			descriptorCache.set(id, {
+				descriptor,
+				sourceMap: transformedSfc.map
+			});
+			const scopeId = hashId(id);
+			const wantsSourceMap = !!config.build.sourcemap || transformedSfc.map != null;
+			const vapor = resolveVaporMode(descriptor, vueOptions, sfc, config);
+			let scriptCode = "";
+			let scriptMap;
+			let scriptBindings;
+			if (descriptor.script || descriptor.scriptSetup) {
+				const inlineTemplate = vueOptions.script?.inlineTemplate !== false;
+				const compiled = sfc.compileScript(descriptor, {
+					...vueOptions.script,
+					id: scopeId,
+					isProd: !isDev,
+					inlineTemplate,
+					sourceMap: wantsSourceMap,
+					genDefaultAs: "__sfc__",
+					vapor
+				});
+				scriptCode = compiled.content;
+				scriptBindings = compiled.bindings;
+				scriptMap = composeSourceMapChain([compiled.map, transformedSfc.map], {
+					filename: id,
+					environmentName,
+					type: "sfc"
+				});
+				if (transformedSfc.map != null && scriptMap == null) warnUnchainableMap({
+					filename: id,
+					environmentName,
+					type: "sfc"
+				}, "compiler-sfc did not return a script map");
+			}
+			let templateCode = "";
+			let templateMap;
+			let templateMultiRoot;
+			const scriptSetupIsInline = !!descriptor.scriptSetup && vueOptions.script?.inlineTemplate !== false;
+			const isTemplateOnlyVapor = vapor && !descriptor.script && !descriptor.scriptSetup;
+			if (descriptor.template && !scriptSetupIsInline) {
+				const transformedTemplate = await applySourceTransform(vueOptions.transformTemplate, descriptor.template.content, {
+					filename: id,
+					environmentName,
+					type: "template"
+				});
+				const templateInputMap = composeSourceMapChain([
+					transformedTemplate.map,
+					descriptor.template.map,
+					transformedSfc.map
+				], {
+					filename: id,
+					environmentName,
+					type: "template"
+				});
+				const customCompilerOptions = vueOptions.template?.compilerOptions ?? {};
+				const compiled = sfc.compileTemplate({
+					...vueOptions.template,
+					source: transformedTemplate.code,
+					filename: id,
+					id: scopeId,
+					inMap: templateInputMap,
+					vapor,
+					compilerOptions: {
+						...customCompilerOptions,
+						bindingMetadata: customCompilerOptions.bindingMetadata ?? scriptBindings ?? (vapor ? {} : void 0),
+						scopeId: `data-v-${scopeId}`
+					}
+				});
+				templateCode = compiled.code;
+				templateMultiRoot = compiled.multiRoot;
+				if (wantsSourceMap || transformedTemplate.map != null) templateMap = compiled.map;
+				if (transformedTemplate.map != null && templateMap == null) warnUnchainableMap({
+					filename: id,
+					environmentName,
+					type: "template"
+				}, "compiler-sfc did not return a template map");
+			}
+			const outputNode = new source_map_js.SourceNode();
+			let hasMappedOutput = false;
+			const append = (fragment, map) => {
+				const normalizedMap = normalizeSourceMap(map, {
+					filename: id,
+					environmentName,
+					type: "sfc"
+				});
+				if (!normalizedMap) {
+					outputNode.add(fragment);
+					return;
+				}
+				try {
+					outputNode.add(source_map_js.SourceNode.fromStringWithSourceMap(fragment, new source_map_js.SourceMapConsumer(normalizedMap)));
+					hasMappedOutput = true;
+				} catch (error) {
+					warnUnchainableMap({
+						filename: id,
+						environmentName,
+						type: "sfc"
+					}, `source-map assembly failed: ${error instanceof Error ? error.message : String(error)}`);
+					outputNode.add(fragment);
+				}
+			};
+			append(scriptCode || (vapor ? "const __sfc__ = { __vapor: true }" : "const __sfc__ = {}"), scriptMap);
+			if (templateCode) {
+				append("\n");
+				append(templateCode, templateMap);
+				append("\n");
+				append("\n__sfc__.render = render\n");
+				if (isTemplateOnlyVapor && templateMultiRoot !== void 0) append(`\n__sfc__.__multiRoot = ${JSON.stringify(templateMultiRoot)}\n`);
+			}
+			if (descriptor.styles.length > 0) for (let i = 0; i < descriptor.styles.length; i++) append(`\nimport "${id}?vue&type=style&index=${i}&lang.css"\n`);
+			if (vapor) append(`
+if (!globalThis.__NASTI_VAPOR_BETA_WARNED__) {
+  globalThis.__NASTI_VAPOR_BETA_WARNED__ = true
+  console.warn(${JSON.stringify(VAPOR_BETA_WARNING)})\n}\n`);
+			append(`\n__sfc__.__scopeId = "data-v-${scopeId}"\n`);
+			if (isDev) append(`
+__sfc__.__hmrId = ${JSON.stringify(scopeId)}
+if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+  __VUE_HMR_RUNTIME__.createRecord(__sfc__.__hmrId, __sfc__)
+}
+if (import.meta.hot) {
+  import.meta.hot.accept((mod) => {
+    if (!mod) return
+    const { default: updated } = mod
+    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+      __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render)
+    }
+  })
+}
+`);
+			append("\nexport default __sfc__\n");
+			const renderedOutput = outputNode.toStringWithSourceMap({ file: id });
+			const output = renderedOutput.code;
+			const outputMap = hasMappedOutput ? renderedOutput.map.toJSON() : void 0;
+			if (transformedSfc.map != null && outputMap == null) warnUnchainableMap({
+				filename: id,
+				environmentName,
+				type: "sfc"
+			}, "the compiled SFC output contained no chainable mappings");
+			if ((descriptor.scriptSetup?.lang ?? descriptor.script?.lang) === "ts") {
+				const transpiled = require_env.transformCode(`${id}.ts`, output, {
+					sourcemap: wantsSourceMap,
+					target: config.build.target
+				});
+				const transpiledMap = transpiled.map ? JSON.parse(transpiled.map) : void 0;
+				return {
+					code: transpiled.code,
+					map: composeSourceMapChain([transpiledMap, outputMap], {
+						filename: id,
+						environmentName,
+						type: "sfc"
+					})
+				};
+			}
+			return {
+				code: output,
+				map: outputMap
+			};
+		},
+		handleHotUpdate(ctx) {
+			const { file, modules } = ctx;
+			if (VUE_FILE_RE.test(file)) {
+				for (const mod of modules) mod.isSelfAccepting = true;
+				descriptorCache.delete(file);
+			}
+			return modules;
+		}
+	};
+}
+/**
+* 解析当前 SFC 是否启用 Vapor Mode。
+* - 单文件 opt-in：`descriptor.vapor`（`<script setup vapor>` / `<template vapor>`）
+* - 环境级强制：`vue.features.vapor`（仅对可强制的 SFC 生效）
+* 首次启用时在终端打印测试版免责声明。
+*/
+function resolveVaporMode(descriptor, vueOptions, sfc, config) {
+	if (!(!!descriptor.vapor || !!vueOptions.features?.vapor && canForceVaporMode(descriptor))) return false;
+	if (!supportsVaporCompiler(sfc)) {
+		config.logger.warnOnce("[nasti:vue] Vapor Mode requires @vue/compiler-sfc >= 3.6. Install it: npm install @vue/compiler-sfc@^3.6.0-0");
+		return false;
+	}
+	config.logger.warnOnce(VAPOR_BETA_WARNING);
+	return true;
+}
+/**
+* `features.vapor` 可强制：纯 template SFC、`<script setup>` SFC。
+* 不可强制仅含普通 `<script>`（无 setup）的 `.vue`，因为 Vapor 不支持 Options API。
+*/
+function canForceVaporMode(descriptor) {
+	if (typeof descriptor.filename === "string" && descriptor.filename.endsWith(".vue")) {
+		if (descriptor.script && !descriptor.scriptSetup) return false;
+		return !!(descriptor.scriptSetup || descriptor.template);
+	}
+	return true;
+}
+/** `@vue/compiler-sfc` 主版本 ≥ 3.6 才具备 Vapor 编译器。 */
+function supportsVaporCompiler(sfc) {
+	const version = sfc.version;
+	if (!version) return false;
+	const [major, minor] = version.split(".").map((part) => Number.parseInt(part, 10));
+	if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
+	return major > 3 || major === 3 && minor >= 6;
+}
+async function applySourceTransform(transform, source, context) {
+	if (!transform) return { code: source };
+	const result = await transform(source, context);
+	return typeof result === "string" ? { code: result } : result;
+}
+function normalizeSourceMap(map, context) {
+	if (map == null) return void 0;
+	try {
+		const value = typeof map === "string" ? JSON.parse(map) : map;
+		if (value && typeof value === "object" && Array.isArray(value.sources) && Array.isArray(value.names) && typeof value.mappings === "string") return value;
+	} catch {}
+	warnUnchainableMap(context, "the provided map is not a valid source map");
+}
+function composeSourceMapChain(maps, context) {
+	const pending = maps.filter((map) => map != null);
+	if (pending.length === 0) return void 0;
+	let composed = normalizeSourceMap(pending.shift(), context);
+	for (const map of pending) {
+		const input = normalizeSourceMap(map, context);
+		if (!input) continue;
+		if (!composed) {
+			composed = input;
+			continue;
+		}
+		try {
+			const consumer = new source_map_js.SourceMapConsumer(composed);
+			if (consumer.sources.length !== 1) {
+				warnUnchainableMap(context, "a generated map has multiple sources and cannot be chained safely");
+				continue;
+			}
+			const generator = source_map_js.SourceMapGenerator.fromSourceMap(consumer);
+			generator.applySourceMap(new source_map_js.SourceMapConsumer(input), consumer.sources[0]);
+			composed = generator.toJSON();
+		} catch (error) {
+			warnUnchainableMap(context, `source-map composition failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return composed;
+}
+function warnUnchainableMap(context, reason) {
+	debug$1?.(`source map warning for ${context.filename} (${context.type}, ${context.environmentName}): ${reason}`);
+}
+function hashId(filename) {
+	return node_crypto.default.createHash("sha256").update(filename).digest("hex").slice(0, 8);
+}
+//#endregion
+//#region src/plugins/html.ts
+/** 运行在用户脚本之前、安装 React Fast Refresh 全局钩子的 preamble。 */
+const REACT_REFRESH_HTML_PREAMBLE = `
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
+function htmlPlugin(config) {
+	return {
+		name: "nasti:html",
+		enforce: "post",
+		transformIndexHtml(html) {
+			const tags = [];
+			if (config.command === "serve") {
+				if (config.framework === "react") tags.push({
+					tag: "script",
+					attrs: { type: "module" },
+					children: REACT_REFRESH_HTML_PREAMBLE,
+					injectTo: "head-prepend"
+				});
+				tags.push({
+					tag: "script",
+					attrs: {
+						type: "module",
+						src: "/@nasti/client"
+					},
+					injectTo: "head-prepend"
+				});
+			}
+			return {
+				html,
+				tags
+			};
+		}
+	};
+}
+/** 处理 HTML，注入标签并重写 script src */
+function processHtml(html, tags) {
+	const headPrepend = tags.filter((t) => t.injectTo === "head-prepend");
+	const head = tags.filter((t) => t.injectTo === "head" || !t.injectTo);
+	const bodyPrepend = tags.filter((t) => t.injectTo === "body-prepend");
+	const body = tags.filter((t) => t.injectTo === "body");
+	if (headPrepend.length) html = html.replace(/<head([^>]*)>/i, `<head$1>\n${serializeTags(headPrepend)}`);
+	if (head.length) html = html.replace(/<\/head>/i, `${serializeTags(head)}\n</head>`);
+	if (bodyPrepend.length) html = html.replace(/<body([^>]*)>/i, `<body$1>\n${serializeTags(bodyPrepend)}`);
+	if (body.length) html = html.replace(/<\/body>/i, `${serializeTags(body)}\n</body>`);
+	return html;
+}
+function serializeTags(tags) {
+	return tags.map(serializeTag).join("\n");
+}
+function serializeTag(tag) {
+	const attrs = tag.attrs ? " " + Object.entries(tag.attrs).map(([k, v]) => v === true ? k : `${k}="${v}"`).join(" ") : "";
+	const children = typeof tag.children === "string" ? tag.children : tag.children ? serializeTags(tag.children) : "";
+	if ([
+		"link",
+		"meta",
+		"br",
+		"hr",
+		"img",
+		"input"
+	].includes(tag.tag) && !children) return `  <${tag.tag}${attrs} />`;
+	return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
+}
+/** 读取 HTML 入口文件；htmlFile 可为相对 root 或绝对路径。 */
+async function readHtmlFile(root, htmlFile = "index.html") {
+	const htmlPath = node_path.default.isAbsolute(htmlFile) ? htmlFile : node_path.default.resolve(root, htmlFile);
+	if (!node_fs.default.existsSync(htmlPath)) return null;
+	return node_fs.default.readFileSync(htmlPath, "utf-8");
+}
+//#endregion
+//#region src/plugins/builtins.ts
+/**
+* 拼装某一环境的完整插件列表（顺序与 1.x 完全一致）：
+*   [vue?] → resolve → css → assets → [html(serve)] → 用户插件 → [css-post(build)]
+*/
+function resolvePluginList(config, userPlugins, opts = {}) {
+	const isServe = config.command === "serve";
+	let environmentOptions;
+	if (opts.environmentName) {
+		environmentOptions = config.environments[opts.environmentName];
+		if (!environmentOptions) throw new Error(`[nasti] unknown environment "${opts.environmentName}" — declare it in config.environments`);
+	}
+	const pluginConfig = environmentOptions ? {
+		...config,
+		resolve: environmentOptions.resolve,
+		build: environmentOptions.build
+	} : config;
+	const consumer = opts.consumer ?? environmentOptions?.consumer;
+	return [
+		...config.framework === "vue" ? [vuePlugin(pluginConfig, opts.environmentName ?? "client")] : [],
+		require_env.resolvePlugin(pluginConfig),
+		cssPlugin(pluginConfig, opts.cssEngine, consumer),
+		assetsPlugin(pluginConfig),
+		...isServe ? [htmlPlugin(pluginConfig)] : [],
+		...userPlugins,
+		...!isServe && opts.cssEngine ? [cssPostPlugin(pluginConfig, opts.cssEngine)] : []
+	];
+}
+//#endregion
+//#region src/core/plugin-container.ts
+var PluginContainer = class {
+	plugins;
+	config;
+	ctx;
+	emittedFiles = /* @__PURE__ */ new Map();
+	/** Environment API：容器所属环境（未传时为 undefined，行为同 1.x client） */
+	environment;
+	constructor(config, environment) {
+		this.config = config;
+		this.environment = environment;
+		this.plugins = require_env.orderPlugins(config.plugins);
+		this.ctx = this.createContext();
+	}
+	createContext() {
+		const container = this;
+		return {
+			async resolve(source, importer) {
+				return container.resolveId(source, importer);
+			},
+			emitFile(file) {
+				const fileName = file.fileName ?? file.name ?? `asset-${container.emittedFiles.size}`;
+				const id = `emitted:${fileName}`;
+				container.emittedFiles.set(id, {
+					fileName,
+					source: file.source ?? ""
+				});
+				return id;
+			},
+			getModuleInfo(_id) {
+				return null;
+			},
+			environment: container.environment
+		};
+	}
+	/** 返回所有通过 emitFile() 输出的文件 */
+	getEmittedFiles() {
+		return Array.from(this.emittedFiles.values());
+	}
+	async buildStart() {
+		for (const plugin of this.plugins) if (plugin.buildStart) await plugin.buildStart.call(this.ctx);
+	}
+	async buildEnd(error) {
+		for (const plugin of this.plugins) if (plugin.buildEnd) await plugin.buildEnd.call(this.ctx, error);
+	}
+	async resolveId(source, importer, options = {}) {
+		const ssr = this.environment?.consumer === "server";
+		for (const plugin of this.plugins) {
+			if (!plugin.resolveId) continue;
+			const result = await plugin.resolveId.call(this.ctx, source, importer ?? void 0, {
+				isEntry: options.isEntry ?? false,
+				ssr
+			});
+			if (result != null) return result;
+		}
+		return null;
+	}
+	async load(id) {
+		for (const plugin of this.plugins) {
+			if (!plugin.load) continue;
+			const result = await plugin.load.call(this.ctx, id);
+			if (result != null) return result;
+		}
+		return null;
+	}
+	async transform(code, id) {
+		let currentCode = code;
+		let lastResult;
+		for (const plugin of this.plugins) {
+			if (!plugin.transform) continue;
+			const result = await plugin.transform.call(this.ctx, currentCode, id);
+			if (result == null) continue;
+			if (typeof result === "string") {
+				currentCode = result;
+				lastResult = void 0;
+			} else {
+				currentCode = result.code;
+				lastResult = result;
+			}
+		}
+		return currentCode === code ? null : {
+			...lastResult,
+			code: currentCode
+		};
+	}
+	/** 完整的模块处理管道: resolveId → load → transform */
+	async processModule(source, importer) {
+		const resolveResult = await this.resolveId(source, importer, { isEntry: !importer });
+		if (resolveResult == null) return null;
+		const id = typeof resolveResult === "string" ? resolveResult : resolveResult.id;
+		const loadResult = await this.load(id);
+		if (loadResult == null) return null;
+		const loadedCode = typeof loadResult === "string" ? loadResult : loadResult.code;
+		const transformResult = await this.transform(loadedCode, id);
+		return {
+			id,
+			code: transformResult == null ? loadedCode : typeof transformResult === "string" ? transformResult : transformResult.code
+		};
+	}
+	getPlugins() {
+		return this.plugins;
+	}
+};
+//#endregion
+//#region src/core/url.ts
+/** 保留语义 query，仅移除浏览器为 HMR 缓存失效附加的 `t` 参数。 */
+function removeTimestampQuery(url) {
+	const hashIndex = url.indexOf("#");
+	const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+	const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+	const queryIndex = withoutHash.indexOf("?");
+	if (queryIndex < 0) return url;
+	const pathname = withoutHash.slice(0, queryIndex);
+	const query = withoutHash.slice(queryIndex + 1).split("&").filter((part) => !/^t=\d+$/.test(part)).join("&");
+	return pathname + (query ? `?${query}` : "") + hash;
+}
+//#endregion
+//#region src/core/module-graph.ts
+var ModuleGraph = class {
+	environmentName;
+	urlToModuleMap = /* @__PURE__ */ new Map();
+	idToModuleMap = /* @__PURE__ */ new Map();
+	fileToModulesMap = /* @__PURE__ */ new Map();
+	constructor(environmentName = "client") {
+		this.environmentName = environmentName;
+	}
+	getModuleByUrl(url) {
+		return this.urlToModuleMap.get(removeTimestampQuery(url));
+	}
+	getModuleById(id) {
+		return this.idToModuleMap.get(id);
+	}
+	getModulesByFile(file) {
+		return this.fileToModulesMap.get(file);
+	}
+	/**
+	* Modules whose registered entry file lives under `dir` (inclusive).
+	* Used when a non-entry source inside a prebundled workspace package changes:
+	* only the package entry was registered, so getModulesByFile(changedFile)
+	* misses — we invalidate every /@modules entry rooted in that package.
+	*/
+	getModulesWithFileUnder(dir) {
+		const result = /* @__PURE__ */ new Set();
+		const normDir = dir.replace(/\\/g, "/");
+		const normPrefix = normDir.endsWith("/") ? normDir : normDir + "/";
+		for (const [file, mods] of this.fileToModulesMap) {
+			const normFile = file.replace(/\\/g, "/");
+			if (normFile === normDir || normFile.startsWith(normPrefix)) for (const m of mods) result.add(m);
+		}
+		return result;
+	}
+	async ensureEntryFromUrl(url) {
+		const normalizedUrl = removeTimestampQuery(url);
+		let mod = this.urlToModuleMap.get(normalizedUrl);
+		if (mod) return mod;
+		mod = this.createModule(normalizedUrl);
+		this.urlToModuleMap.set(normalizedUrl, mod);
+		return mod;
+	}
+	createModule(url, id) {
+		const mod = {
+			id: id ?? url,
+			file: null,
+			url,
+			type: url.endsWith(".css") ? "css" : "js",
+			importers: /* @__PURE__ */ new Set(),
+			importedModules: /* @__PURE__ */ new Set(),
+			acceptedHmrDeps: /* @__PURE__ */ new Set(),
+			transformResult: null,
+			lastHMRTimestamp: 0,
+			invalidationVersion: 0,
+			isSelfAccepting: false,
+			environment: this.environmentName
+		};
+		this.idToModuleMap.set(mod.id, mod);
+		return mod;
+	}
+	/** 注册文件路径到模块的映射 */
+	registerModule(mod, file) {
+		mod.file = file;
+		let mods = this.fileToModulesMap.get(file);
+		if (!mods) {
+			mods = /* @__PURE__ */ new Set();
+			this.fileToModulesMap.set(file, mods);
+		}
+		mods.add(mod);
+	}
+	/**
+	* Reindex a module under a plugin-provided canonical id (e.g. a `\0virtual:foo`
+	* id returned from `resolveId`). Plugins look up their own virtual modules via
+	* `getModuleById(RESOLVED_ID)` to invalidate them on watcher events; without
+	* this remap they'd never find the node because `ensureEntryFromUrl` keys by
+	* the public URL only.
+	*/
+	setModuleId(mod, id) {
+		if (mod.id === id) return;
+		this.idToModuleMap.delete(mod.id);
+		mod.id = id;
+		this.idToModuleMap.set(id, mod);
+	}
+	/** 更新模块依赖关系 */
+	updateModuleImports(mod, importedIds) {
+		for (const imported of mod.importedModules) imported.importers.delete(mod);
+		mod.importedModules.clear();
+		for (const id of importedIds) {
+			const importedMod = this.idToModuleMap.get(id);
+			if (importedMod) {
+				mod.importedModules.add(importedMod);
+				importedMod.importers.add(mod);
+			}
+		}
+	}
+	/**
+	* 用一次转换得到的信息原子更新 import 与 HMR accept 关系。
+	* 依赖节点会在真正被浏览器请求前预先创建，这样入口模块先转换时也能建立完整图。
+	*/
+	async updateModuleInfo(mod, importedUrls, acceptedUrls, isSelfAccepting, expectedInvalidationVersion) {
+		const importedModules = await Promise.all([...importedUrls].map((url) => this.ensureEntryFromUrl(url)));
+		const acceptedModules = await Promise.all([...acceptedUrls].map((url) => this.ensureEntryFromUrl(url)));
+		if (expectedInvalidationVersion !== void 0 && mod.invalidationVersion !== expectedInvalidationVersion) return null;
+		const previousImports = new Set(mod.importedModules);
+		for (const imported of previousImports) imported.importers.delete(mod);
+		mod.importedModules.clear();
+		mod.acceptedHmrDeps.clear();
+		for (const imported of importedModules) {
+			mod.importedModules.add(imported);
+			imported.importers.add(mod);
+		}
+		for (const accepted of acceptedModules) mod.acceptedHmrDeps.add(accepted);
+		mod.isSelfAccepting = isSelfAccepting;
+		const pruned = /* @__PURE__ */ new Set();
+		for (const imported of previousImports) if (!mod.importedModules.has(imported) && imported.importers.size === 0) pruned.add(imported);
+		return pruned;
+	}
+	/** 使模块的转换缓存失效 */
+	invalidateModule(mod, timestamp = Date.now()) {
+		mod.transformResult = null;
+		mod.lastHMRTimestamp = timestamp;
+		mod.invalidationVersion++;
+	}
+	/**
+	* 仅失效到 HMR 边界：显式接受依赖的模块本身不会重执行；自接受模块需要失效，
+	* 但不再继续影响其 importer。这样既能传播依赖时间戳，也不会隐式重复副作用。
+	*/
+	invalidateModuleAndImporters(mod, timestamp = Date.now(), seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(mod)) return;
+		seen.add(mod);
+		this.invalidateModule(mod, timestamp);
+		for (const importer of mod.importers) {
+			if (importer.acceptedHmrDeps.has(mod)) continue;
+			if (importer.isSelfAccepting) {
+				this.invalidateModule(importer, timestamp);
+				continue;
+			}
+			this.invalidateModuleAndImporters(importer, timestamp, seen);
+		}
+	}
+	/** 使所有模块缓存失效 */
+	invalidateAll() {
+		for (const mod of this.idToModuleMap.values()) this.invalidateModule(mod);
+	}
+	/** 获取 HMR 传播边界 - 从变更模块向上遍历找到接受更新的边界 */
+	getHmrBoundaries(mod) {
+		const boundaries = [];
+		const traversed = /* @__PURE__ */ new Set();
+		const addBoundary = (boundary, acceptedVia) => {
+			if (!boundaries.some((item) => item.boundary === boundary && item.acceptedVia === acceptedVia)) boundaries.push({
+				boundary,
+				acceptedVia
+			});
+		};
+		const propagate = (node) => {
+			if (traversed.has(node)) return true;
+			traversed.add(node);
+			if (node.isSelfAccepting) {
+				addBoundary(node, node);
+				return true;
+			}
+			if (node.importers.size === 0) return false;
+			for (const importer of node.importers) {
+				if (importer.acceptedHmrDeps.has(node)) {
+					addBoundary(importer, node);
+					continue;
+				}
+				if (!propagate(importer)) return false;
+			}
+			return true;
+		};
+		return propagate(mod) ? boundaries : [];
+	}
+};
+//#endregion
+//#region src/core/hot-channel.ts
+/** 非 client 环境的占位通道（SSR/edge 可由 runner/driver 接上真实 transport） */
+function createNoopHotChannel() {
+	return {
+		send() {},
+		on() {},
+		off() {},
+		listen() {},
+		close() {},
+		setInvokeHandler() {}
+	};
+}
+/**
+* client-consumer 环境的 ws 通道：包装 server/ws.ts 的 WebSocketServer。
+* 事件监听与 invoke 在现有 ws 协议上预留，payload 以 environment 字段分流。
+*/
+function createWsHotChannel(ws, environmentName = "client") {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		send(payload) {
+			ws.send({
+				...payload,
+				environment: payload.environment ?? environmentName
+			});
+		},
+		on(event, listener) {
+			let set = listeners.get(event);
+			if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+			set.add(listener);
+		},
+		off(event, listener) {
+			listeners.get(event)?.delete(listener);
+		},
+		listen() {},
+		close() {},
+		setInvokeHandler(handlers) {}
+	};
+}
+//#endregion
+//#region src/core/environment.ts
+const debug = createDebugger("nasti:environment");
+var NastiEnvironment = class {
+	name;
+	consumer;
+	mode;
+	config;
+	options;
+	hot;
+	driver;
+	/** applyToEnvironment 过滤后的插件（init() 后可用） */
+	plugins = [];
+	/** per-env 插件容器（init() 后可用；dev 管线使用） */
+	pluginContainer = null;
+	/** per-env 模块图（dev 管线使用） */
+	moduleGraph;
+	candidatePlugins;
+	pluginApi;
+	buildMetadata = {};
+	cssModules = /* @__PURE__ */ new Map();
+	assetModules = /* @__PURE__ */ new Map();
+	transformRequestHandler;
+	initialized = false;
+	constructor(name, config, init = {}) {
+		const options = config.environments[name];
+		if (!options) throw new Error(`[nasti] unknown environment "${name}" — declare it in config.environments`);
+		this.name = name;
+		this.consumer = options.consumer;
+		this.mode = init.mode ?? (config.command === "build" ? "build" : "dev");
+		this.config = config;
+		this.options = options;
+		this.hot = init.hot ?? createNoopHotChannel();
+		this.moduleGraph = new ModuleGraph(name);
+		this.candidatePlugins = init.plugins ?? config.plugins;
+		this.pluginApi = init.pluginApi ?? require_env.getPluginApi(config);
+	}
+	/** 过滤插件并建 per-env PluginContainer */
+	async init() {
+		if (this.initialized) return;
+		this.initialized = true;
+		this.plugins = resolveEnvironmentPlugins(this, this.candidatePlugins);
+		this.pluginContainer = new PluginContainer({
+			...this.config,
+			plugins: this.plugins
+		}, this);
+		if (this.options.driver) {
+			const claimed = [];
+			for (const plugin of this.plugins) {
+				const driver = await plugin.createEnvironmentDriver?.(this, this.pluginApi);
+				if (driver) claimed.push({
+					plugin,
+					driver
+				});
+			}
+			if (claimed.length === 0) throw new Error(`[nasti] environment "${this.name}" requested driver "${this.options.driver}", but no plugin provided it`);
+			if (claimed.length > 1) throw new Error(`[nasti] environment "${this.name}" was claimed by multiple drivers: ` + claimed.map(({ plugin, driver }) => `${plugin.name} (${driver.name})`).join(", "));
+			this.driver = claimed[0].driver;
+			debug?.(`env "${this.name}" uses driver "${this.driver.name}"`);
+		}
+		debug?.(`env "${this.name}" initialized (${this.plugins.length} plugins)`);
+	}
+	getDriverContext() {
+		return {
+			environment: this,
+			config: this.config,
+			api: this.pluginApi,
+			logger: this.config.logger
+		};
+	}
+	configureDevPipeline(transformRequest) {
+		this.transformRequestHandler = transformRequest;
+	}
+	async transformRequest(url) {
+		if (!this.transformRequestHandler) throw new Error(`[nasti] environment "${this.name}" does not have an initialized dev transform pipeline`);
+		return this.transformRequestHandler(url);
+	}
+	setCssModule(module) {
+		this.cssModules.set(module.id, { ...module });
+	}
+	getCssModule(id) {
+		const module = this.cssModules.get(id);
+		return module ? { ...module } : void 0;
+	}
+	getCssModules() {
+		return Object.freeze(Object.fromEntries([...this.cssModules].map(([id, module]) => [id, { ...module }])));
+	}
+	setAssetModule(id, fileName) {
+		this.assetModules.set(id, fileName);
+	}
+	getAssetModules() {
+		return Object.freeze(Object.fromEntries(this.assetModules));
+	}
+	setBuildMetadata(metadata) {
+		const { entries: currentEntries, ...currentMetadata } = this.buildMetadata;
+		const { entries, ...nextMetadata } = metadata;
+		this.buildMetadata = {
+			...currentMetadata,
+			...nextMetadata,
+			...currentEntries || entries ? { entries: {
+				...currentEntries,
+				...entries
+			} } : {}
+		};
+	}
+	getBuildMetadata() {
+		const { entries, ...metadata } = this.buildMetadata;
+		return {
+			...metadata,
+			...entries ? { entries: { ...entries } } : {}
+		};
+	}
+	async close() {
+		try {
+			await this.driver?.close?.(this.getDriverContext());
+		} finally {
+			await this.hot.close?.();
+		}
+	}
+};
+/** 按 applyToEnvironment 过滤环境插件（未声明 = 应用于所有环境） */
+function resolveEnvironmentPlugins(environment, plugins) {
+	return plugins.filter((p) => {
+		if (!p.applyToEnvironment) return true;
+		try {
+			return p.applyToEnvironment(environment);
+		} catch (err) {
+			environment.config.logger.error(`[nasti] plugin "${p.name}" applyToEnvironment threw: ${err.message}`, { error: err });
+			return false;
+		}
+	});
+}
+//#endregion
+Object.defineProperty(exports, "NastiEnvironment", {
+	enumerable: true,
+	get: function() {
+		return NastiEnvironment;
+	}
+});
+Object.defineProperty(exports, "createCssEngine", {
+	enumerable: true,
+	get: function() {
+		return createCssEngine;
+	}
+});
+Object.defineProperty(exports, "createDebugger", {
+	enumerable: true,
+	get: function() {
+		return createDebugger;
+	}
+});
+Object.defineProperty(exports, "createNoopHotChannel", {
+	enumerable: true,
+	get: function() {
+		return createNoopHotChannel;
+	}
+});
+Object.defineProperty(exports, "createWsHotChannel", {
+	enumerable: true,
+	get: function() {
+		return createWsHotChannel;
+	}
+});
+Object.defineProperty(exports, "getCssMetadata", {
+	enumerable: true,
+	get: function() {
+		return getCssMetadata;
+	}
+});
+Object.defineProperty(exports, "htmlPlugin", {
+	enumerable: true,
+	get: function() {
+		return htmlPlugin;
+	}
+});
+Object.defineProperty(exports, "isAssetFile", {
+	enumerable: true,
+	get: function() {
+		return isAssetFile;
+	}
+});
+Object.defineProperty(exports, "processHtml", {
+	enumerable: true,
+	get: function() {
+		return processHtml;
+	}
+});
+Object.defineProperty(exports, "readHtmlFile", {
+	enumerable: true,
+	get: function() {
+		return readHtmlFile;
+	}
+});
+Object.defineProperty(exports, "removeTimestampQuery", {
+	enumerable: true,
+	get: function() {
+		return removeTimestampQuery;
+	}
+});
+Object.defineProperty(exports, "resolveEnvironmentPlugins", {
+	enumerable: true,
+	get: function() {
+		return resolveEnvironmentPlugins;
+	}
+});
+Object.defineProperty(exports, "resolvePluginList", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginList;
+	}
+});
+
+//# sourceMappingURL=environment-CjmvoHIG.cjs.map