@nasti-toolchain/nasti 2.5.0 → 2.5.2

package/dist/build-CENae4VM.js

@@ -0,0 +1,748 @@
+import { a as __exportAll } from "./logger-BVZwdqqT.js";
+import { a as matchesReactFilter, c as transformReactCode, f as resolveConfig, h as resolveMinifyOption, i as ssrDefineOverrides, n as loadEnv, o as shouldTransform, p as getPluginApi, s as transformCode, t as buildEnvDefine } from "./env-GY7K1zPK.js";
+import { c as processHtml, d as createCssEngine, f as getCssMetadata, l as readHtmlFile, o as resolvePluginList, p as createDebugger, s as htmlPlugin, t as NastiEnvironment } from "./environment-B2jCrhY2.js";
+import { builtinModules } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import pc from "picocolors";
+import { rolldown } from "rolldown";
+import { gzipSync } from "node:zlib";
+//#region src/plugins/react.ts
+const REACT_FILE_RE = /\.[jt]sx(?:[?#].*)?$/;
+function reactPlugin(config, environment) {
+	return {
+		name: "nasti:oxc-transform",
+		async transform(code, id) {
+			const result = await transformReactCode(id, code, {
+				react: config.react,
+				consumer: environment.consumer,
+				development: config.mode === "development",
+				sourcemap: !!environment.options.build.sourcemap,
+				target: environment.options.build.target,
+				onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+			});
+			if (!result) return null;
+			return {
+				code: result.code,
+				map: result.map ? JSON.parse(result.map) : void 0
+			};
+		},
+		handleHotUpdate(ctx) {
+			for (const mod of ctx.modules) if (REACT_FILE_RE.test(mod.url) && matchesReactFilter(mod.url, config.react.include, config.react.exclude)) mod.isSelfAccepting = true;
+			return ctx.modules;
+		}
+	};
+}
+//#endregion
+//#region src/build/reporter.ts
+const debug$1 = createDebugger("nasti:reporter");
+/**
+* 尝试创建原生体积报告插件（Rust 实现，gzip 并行计算）。
+* 返回 null 表示当前 rolldown 版本不提供该实验导出，调用方应改用
+* {@link reportBuildOutput} 的 JS 表格。
+*/
+async function tryNativeReporterPlugin(config, logger) {
+	try {
+		const { viteReporterPlugin } = await import("rolldown/experimental");
+		if (typeof viteReporterPlugin !== "function") return null;
+		return viteReporterPlugin({
+			root: config.root,
+			isTty: process.stdout.isTTY ?? false,
+			isLib: false,
+			assetsDir: config.build.assetsDir,
+			chunkLimit: config.build.chunkSizeWarningLimit,
+			warnLargeChunks: false,
+			reportCompressedSize: config.build.reportCompressedSize,
+			logInfo: (msg) => logger.info(msg)
+		});
+	} catch (err) {
+		debug$1?.(`native viteReporterPlugin unavailable, falling back to JS table: ${err}`);
+		return null;
+	}
+}
+const numberFormatter = new Intl.NumberFormat("en", {
+	maximumFractionDigits: 2,
+	minimumFractionDigits: 2
+});
+function displaySize(bytes) {
+	return `${numberFormatter.format(bytes / 1e3)} kB`;
+}
+function byteLength(content) {
+	if (content == null) return 0;
+	return typeof content === "string" ? Buffer.byteLength(content) : content.byteLength;
+}
+/** JS fallback：打印 Vite 形态的产物体积表（gzip 可经 reportCompressedSize 关闭） */
+function reportBuildOutput(output, config, logger) {
+	const entries = [];
+	const compressed = config.build.reportCompressedSize;
+	for (const file of output) {
+		const content = file.type === "chunk" ? file.code : file.source;
+		const size = byteLength(content);
+		let gzip = null;
+		if (compressed && content != null) gzip = gzipSync(typeof content === "string" ? Buffer.from(content) : content).byteLength;
+		const ext = path.extname(file.fileName);
+		const group = file.type === "chunk" ? "js" : ext === ".css" ? "css" : "assets";
+		entries.push({
+			name: file.fileName,
+			size,
+			gzip,
+			group
+		});
+	}
+	const groupOrder = {
+		assets: 0,
+		css: 1,
+		js: 2
+	};
+	entries.sort((a, b) => groupOrder[a.group] - groupOrder[b.group] || a.size - b.size);
+	const outDirPrefix = `${config.build.outDir.replace(/\/$/, "")}/`;
+	const maxNameLen = Math.max(...entries.map((e) => (outDirPrefix + e.name).length), 0);
+	const maxSizeLen = Math.max(...entries.map((e) => displaySize(e.size).length), 0);
+	const groupColor = {
+		assets: pc.green,
+		css: pc.magenta,
+		js: pc.cyan
+	};
+	for (const e of entries) {
+		const color = groupColor[e.group];
+		const namePart = pc.dim(outDirPrefix) + color(e.name.padEnd(maxNameLen - outDirPrefix.length));
+		const sizePart = pc.dim(pc.bold(displaySize(e.size).padStart(maxSizeLen)));
+		const gzipPart = e.gzip != null ? pc.dim(` │ gzip: ${displaySize(e.gzip)}`) : "";
+		logger.info(`${namePart} ${sizePart}${gzipPart}`);
+	}
+}
+/** 大 chunk 警告（独立于表格渲染路径，始终经 logger.warn 输出） */
+function warnLargeChunks(output, config, logger) {
+	const limit = config.build.chunkSizeWarningLimit;
+	if (output.filter((f) => f.type === "chunk" && byteLength(f.code) / 1e3 > limit).length === 0) return;
+	logger.warn(pc.yellow(`\n(!) Some chunks are larger than ${limit} kB after minification. Consider:\n- Using dynamic import() to code-split the application\n- Configuring build.rolldownOptions.output.advancedChunks to isolate large dependencies\n- Adjusting build.chunkSizeWarningLimit to silence this warning`));
+}
+//#endregion
+//#region src/core/build-app-context.ts
+function createBuildAppContext(config, results) {
+	const output = [];
+	const emitted = /* @__PURE__ */ new Set();
+	const outDir = path.resolve(config.root, config.build.outDir);
+	let environmentArtifacts;
+	return {
+		config,
+		results,
+		get output() {
+			return Object.freeze([...output]);
+		},
+		getResult(environmentName) {
+			return results[environmentName];
+		},
+		getArtifact(environmentName, fileName) {
+			const normalized = normalizeEnvironmentFileName(fileName);
+			return results[environmentName]?.output.find((artifact) => normalizeEnvironmentFileName(artifact.fileName) === normalized);
+		},
+		getEntry(environmentName, entryName) {
+			const result = results[environmentName];
+			const fileName = result?.entries?.[entryName];
+			if (!fileName) return void 0;
+			return result.output.find((artifact) => normalizeEnvironmentFileName(artifact.fileName) === normalizeEnvironmentFileName(fileName));
+		},
+		getManifest(environmentName) {
+			return results[environmentName]?.manifest;
+		},
+		getChunk(environmentName, fileName) {
+			const normalized = normalizeEnvironmentFileName(fileName);
+			return results[environmentName]?.chunks?.[normalized];
+		},
+		getCss(environmentName) {
+			return results[environmentName]?.css;
+		},
+		getSourceMap(environmentName, fileName) {
+			const normalized = normalizeEnvironmentFileName(fileName);
+			return results[environmentName]?.sourceMaps?.[normalized];
+		},
+		resolvePublicPath(environmentName, fileName) {
+			const result = results[environmentName];
+			if (!result) return void 0;
+			const normalized = normalizeEnvironmentFileName(fileName);
+			return joinPublicPath(result.publicPath ?? config.base, normalized);
+		},
+		emitFile(file) {
+			const fileName = normalizeAppFileName(file.fileName);
+			const collisionKey = artifactCollisionKey(fileName);
+			if (emitted.has(collisionKey)) throw new Error(`[nasti] app artifact already emitted: ${fileName}`);
+			environmentArtifacts ??= collectEnvironmentArtifacts(config, results, outDir);
+			if (environmentArtifacts.has(collisionKey)) throw new Error(`[nasti] app artifact conflicts with environment output: ${fileName}`);
+			const target = path.resolve(outDir, ...fileName.split("/"));
+			const relative = path.relative(outDir, target);
+			if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`[nasti] app artifact must stay inside build.outDir: ${file.fileName}`);
+			assertNoSymlinkComponents(outDir, fileName);
+			fs.mkdirSync(path.dirname(target), { recursive: true });
+			fs.writeFileSync(target, file.source);
+			const artifact = {
+				...file,
+				fileName,
+				type: "asset"
+			};
+			emitted.add(collisionKey);
+			output.push(artifact);
+			return fileName;
+		}
+	};
+}
+function joinPublicPath(base, fileName) {
+	return `${base.endsWith("/") ? base : `${base}/`}${fileName.replace(/^\//, "")}`;
+}
+function normalizeEnvironmentFileName(fileName) {
+	return path.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
+}
+function isInvalidEnvironmentFileName(fileName) {
+	return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || path.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
+}
+function normalizeAppFileName(fileName) {
+	const normalized = normalizeEnvironmentFileName(fileName);
+	if (isInvalidEnvironmentFileName(normalized)) throw new Error(`[nasti] invalid app artifact fileName: ${fileName}`);
+	return normalized;
+}
+function artifactCollisionKey(fileName) {
+	return normalizeEnvironmentFileName(fileName).toLowerCase();
+}
+function collectEnvironmentArtifacts(config, results, appOutDir) {
+	const occupied = /* @__PURE__ */ new Set();
+	for (const [environmentName, result] of Object.entries(results)) {
+		const environment = config.environments[environmentName];
+		if (!environment) continue;
+		const environmentOutDir = path.resolve(config.root, environment.build.outDir);
+		for (const artifact of result.output) {
+			const artifactPath = path.resolve(environmentOutDir, ...normalizeEnvironmentFileName(artifact.fileName).split("/"));
+			const relative = path.relative(appOutDir, artifactPath);
+			if (!relative.startsWith("..") && !path.isAbsolute(relative)) occupied.add(artifactCollisionKey(relative));
+		}
+	}
+	return occupied;
+}
+function assertNoSymlinkComponents(outDir, fileName) {
+	let current = outDir;
+	for (const segment of fileName.split("/")) {
+		current = path.join(current, segment);
+		let stats;
+		try {
+			stats = fs.lstatSync(current);
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		if (stats.isSymbolicLink()) throw new Error(`[nasti] app artifact path cannot traverse a symlink: ${fileName}`);
+	}
+}
+function inferEnvironmentEntries(output) {
+	const entries = {};
+	for (const artifact of output) {
+		if (artifact.type !== "chunk" || !artifact.isEntry || !artifact.name) continue;
+		entries[artifact.name] = normalizeEnvironmentFileName(artifact.fileName);
+	}
+	return Object.keys(entries).length > 0 ? entries : void 0;
+}
+//#endregion
+//#region src/build/index.ts
+var build_exports = /* @__PURE__ */ __exportAll({
+	build: () => build,
+	getRolldownOptions: () => getRolldownOptions,
+	replaceEntryScript: () => replaceEntryScript,
+	resolveClientEntries: () => resolveClientEntries,
+	toRolldownPlugins: () => toRolldownPlugins
+});
+const debug = createDebugger("nasti:build");
+const NODE_BUILTINS = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
+/**
+* 把单个环境的 rolldown input/output 选项收敛到一处（Phase 3 DevEngine 复用）。
+* - input：user rolldownOptions 透传 + per-env platform/resolve/external/define
+* - output：默认命名 + user output 覆盖 + dir 由 Nasti 强制
+*/
+function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
+	const config = environment.config;
+	const envOptions = environment.options;
+	const isServer = environment.consumer === "server";
+	const outDir = path.resolve(config.root, envOptions.build.outDir);
+	const assetsDir = envOptions.build.assetsDir;
+	const { output: userOutput, transform: userTransform, resolve: userResolve, ...restInputOptions } = envOptions.build.rolldownOptions;
+	const vueDefine = config.framework === "vue" ? {
+		__VUE_OPTIONS_API__: "true",
+		__VUE_PROD_DEVTOOLS__: "false",
+		__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false"
+	} : {};
+	const env = loadEnv(config.mode, config.root, config.envPrefix);
+	const envDefine = buildEnvDefine(env, config.mode, ssrDefineOverrides(environment.consumer));
+	const mergedDefine = {
+		...vueDefine,
+		...userTransform?.define ?? {},
+		...envDefine
+	};
+	return {
+		inputOptions: {
+			...restInputOptions,
+			input: entryPoints,
+			transform: {
+				...userTransform,
+				target: userTransform?.target ?? envOptions.build.target,
+				define: mergedDefine
+			},
+			plugins: rolldownPlugins,
+			resolve: {
+				...userResolve ?? {},
+				conditionNames: envOptions.resolve.conditions,
+				mainFields: envOptions.resolve.mainFields
+			},
+			...isServer ? {
+				platform: restInputOptions.platform ?? "node",
+				external: restInputOptions.external ?? ((id) => {
+					if (NODE_BUILTINS.has(id)) return true;
+					return !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("\0") && !id.startsWith("virtual:");
+				})
+			} : {}
+		},
+		outputOptions: isServer ? {
+			format: "esm",
+			sourcemap: envOptions.build.sourcemap,
+			minify: resolveMinifyOption(envOptions.build.minify),
+			entryFileNames: "[name].js",
+			chunkFileNames: "chunks/[name]-[hash].js",
+			assetFileNames: `${assetsDir}/[name].[hash][extname]`,
+			...userOutput,
+			dir: outDir
+		} : {
+			format: "esm",
+			sourcemap: envOptions.build.sourcemap,
+			minify: resolveMinifyOption(envOptions.build.minify),
+			entryFileNames: `${assetsDir}/[name].[hash].js`,
+			chunkFileNames: `${assetsDir}/[name].[hash].js`,
+			assetFileNames: `${assetsDir}/[name].[hash][extname]`,
+			...userOutput,
+			dir: outDir
+		},
+		outDir
+	};
+}
+/**
+* Nasti 插件 → Rolldown 插件转发表。包装器保留 Rolldown 的真实插件上下文，
+* 同时注入当前 Nasti environment，供同为 client consumer 的 BG/MT 管线区分彼此。
+*/
+function toRolldownPlugins(plugins, environment) {
+	const wrap = (hook) => {
+		if (!hook) return hook;
+		return function(...args) {
+			return hook.apply(attachEnvironment(this, environment), args);
+		};
+	};
+	return plugins.map((p) => ({
+		name: p.name,
+		resolveId: wrap(p.resolveId),
+		load: wrap(p.load),
+		transform: wrap(p.transform),
+		buildStart: wrap(p.buildStart),
+		buildEnd: wrap(p.buildEnd),
+		closeBundle: wrap(p.closeBundle),
+		renderChunk: wrap(p.renderChunk),
+		augmentChunkHash: wrap(p.augmentChunkHash),
+		generateBundle: wrap(p.generateBundle)
+	}));
+}
+function attachEnvironment(context, environment) {
+	if (context?.environment === environment) return context;
+	try {
+		Object.defineProperty(context, "environment", {
+			configurable: true,
+			enumerable: false,
+			writable: false,
+			value: environment
+		});
+		return context;
+	} catch {
+		return new Proxy(context, {
+			get(target, property) {
+				if (property === "environment") return environment;
+				const value = Reflect.get(target, property, target);
+				return typeof value === "function" ? value.bind(target) : value;
+			},
+			set(target, property, value) {
+				return Reflect.set(target, property, value, target);
+			}
+		});
+	}
+}
+function finalizeEnvironmentResult(environment, result) {
+	const metadata = environment.getBuildMetadata();
+	const entries = {
+		...inferEnvironmentEntries(result.output),
+		...metadata.entries,
+		...result.entries
+	};
+	const normalizedEntries = Object.fromEntries(Object.entries(entries).map(([name, fileName]) => {
+		const normalized = normalizeEnvironmentFileName(fileName);
+		if (isInvalidEnvironmentFileName(normalized)) throw new Error(`[nasti] environment "${environment.name}" returned invalid entry "${name}": ${fileName}`);
+		return [name, normalized];
+	}));
+	const inferredMetadata = inferOutputMetadata(environment, result.output);
+	return {
+		publicPath: environment.config.base,
+		...inferredMetadata,
+		...metadata,
+		...result,
+		output: result.output,
+		chunks: {
+			...inferredMetadata.chunks,
+			...metadata.chunks,
+			...result.chunks
+		},
+		assets: {
+			...inferredMetadata.assets,
+			...metadata.assets,
+			...result.assets
+		},
+		sourceMaps: {
+			...inferredMetadata.sourceMaps,
+			...metadata.sourceMaps,
+			...result.sourceMaps
+		},
+		...Object.keys(normalizedEntries).length > 0 ? { entries: normalizedEntries } : {}
+	};
+}
+function inferOutputMetadata(environment, output) {
+	const chunks = {};
+	const assets = {};
+	const sourceMaps = {};
+	const cssChunks = environment.getBuildMetadata().css?.chunks ?? {};
+	const assetModules = environment.getAssetModules();
+	const publicPath = environment.config.base;
+	for (const artifact of output) {
+		const fileName = normalizeEnvironmentFileName(artifact.fileName);
+		if (artifact.map != null) sourceMaps[fileName] = artifact.map;
+		if (artifact.type === "chunk") {
+			const moduleIds = [...artifact.moduleIds ?? []];
+			chunks[fileName] = {
+				fileName,
+				name: artifact.name ?? fileName,
+				isEntry: !!artifact.isEntry,
+				isDynamicEntry: !!artifact.isDynamicEntry,
+				imports: [...artifact.imports ?? []],
+				dynamicImports: [...artifact.dynamicImports ?? []],
+				moduleIds,
+				css: [...cssChunks[fileName]?.cssFileNames ?? []],
+				assets: [...new Set(moduleIds.map((id) => assetModules[id]).filter((asset) => !!asset))]
+			};
+		} else if (artifact.type === "asset") assets[fileName] = {
+			fileName,
+			names: [...artifact.names ?? (artifact.name ? [artifact.name] : [])],
+			publicPath: joinPublicPath(publicPath, fileName)
+		};
+	}
+	return {
+		chunks,
+		assets,
+		sourceMaps
+	};
+}
+function prepareBuildOutputDirectories(config, buildableNames) {
+	const directories = /* @__PURE__ */ new Set();
+	const protectedPaths = /* @__PURE__ */ new Set();
+	if (!buildableNames.includes("client") && config.build.emptyOutDir) directories.add(path.resolve(config.root, config.build.outDir));
+	for (const name of buildableNames) {
+		const environment = config.environments[name];
+		const outDir = path.resolve(config.root, environment.build.outDir);
+		if (!environment.build.emptyOutDir) {
+			protectedPaths.add(outDir);
+			continue;
+		}
+		if (!environment.driver) directories.add(outDir);
+	}
+	const containsPath = (parent, child) => {
+		const relative = path.relative(parent, child);
+		return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+	};
+	const roots = [...directories].filter((directory) => ![...protectedPaths].some((protectedPath) => containsPath(directory, protectedPath))).sort((a, b) => a.length - b.length).filter((directory, index, all) => !all.slice(0, index).some((parent) => containsPath(parent, directory)));
+	for (const directory of roots) if (fs.existsSync(directory)) fs.rmSync(directory, {
+		recursive: true,
+		force: true
+	});
+}
+function assertDriverBuildResult(environment, result) {
+	const output = result != null && typeof result === "object" ? result.output : void 0;
+	if (!(Array.isArray(output) && output.every((artifact) => artifact != null && typeof artifact === "object" && typeof artifact.fileName === "string" && typeof artifact.type === "string"))) throw new Error(`[nasti] environment "${environment.name}" driver "${environment.driver?.name}" returned an invalid build result; expected { output: EnvironmentBuildOutput[] }`);
+}
+/** 从 index.html 提取 client 入口（含常见路径回退） */
+function resolveClientEntries(config, html) {
+	const configuredEntries = config.environments.client?.entry ?? [];
+	if (configuredEntries.length > 0) return configuredEntries;
+	const entryPoints = [];
+	const htmlFile = config.environments.client?.html;
+	const htmlDir = htmlFile ? path.dirname(htmlFile) : config.root;
+	if (html) {
+		const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
+		for (const match of scriptMatches) {
+			const src = match[1];
+			if (src && !src.startsWith("http")) {
+				const cleanSrc = src.split(/[?#]/, 1)[0];
+				entryPoints.push(cleanSrc.startsWith("/") ? path.resolve(config.root, cleanSrc.replace(/^\//, "")) : path.resolve(htmlDir, cleanSrc));
+			}
+		}
+	}
+	if (entryPoints.length === 0) for (const entry of [
+		"src/main.ts",
+		"src/main.tsx",
+		"src/main.js",
+		"src/index.ts",
+		"src/index.tsx",
+		"src/index.js"
+	]) {
+		const fullPath = path.resolve(config.root, entry);
+		if (fs.existsSync(fullPath)) {
+			entryPoints.push(fullPath);
+			break;
+		}
+	}
+	return entryPoints;
+}
+/** 单个环境的 oxc 转译插件（TS/JSX，consumer 无关） */
+function createOxcTransformPlugin(config, environment) {
+	if (config.framework === "react") return reactPlugin(config, environment);
+	return {
+		name: "nasti:oxc-transform",
+		transform(code, id) {
+			if (!shouldTransform(id)) return null;
+			const result = transformCode(id, code, {
+				sourcemap: !!environment.options.build.sourcemap,
+				target: environment.options.build.target,
+				jsxRuntime: "automatic",
+				jsxImportSource: config.framework === "vue" ? "vue" : "react"
+			});
+			return {
+				code: result.code,
+				map: result.map ? JSON.parse(result.map) : void 0
+			};
+		}
+	};
+}
+async function build(inlineConfig = {}) {
+	const config = await resolveConfig(inlineConfig, "build");
+	const logger = config.logger;
+	const startTime = performance.now();
+	logger.info(pc.cyan(`\nnasti v2.5.2 `) + pc.green(`building for ${config.mode}...`));
+	debug?.(`root: ${config.root}`);
+	const buildableNames = Object.keys(config.environments).filter((name) => {
+		const environment = config.environments[name];
+		if (!environment.buildEnabled) return false;
+		return name === "client" || environment.entry.length > 0 || !!environment.driver;
+	});
+	buildableNames.sort((a, b) => a === "client" ? -1 : b === "client" ? 1 : 0);
+	prepareBuildOutputDirectories(config, buildableNames);
+	const environments = {};
+	const environmentResults = {};
+	const initializedEnvironments = [];
+	const buildAppContext = createBuildAppContext(config, environmentResults);
+	let clientOutput = [];
+	let buildFailed = false;
+	try {
+		for (const name of buildableNames) {
+			const built = name === "client" ? await buildClientEnvironment(config) : await buildServerEnvironment(config, name);
+			initializedEnvironments.push(built.environment);
+			environments[name] = built.result.output;
+			environmentResults[name] = built.result;
+			if (name === "client") clientOutput = built.result.output;
+			if (buildableNames.length > 1) debug?.(`environment "${name}" built (${built.result.output.length} files)`);
+		}
+		const pluginApi = getPluginApi(config);
+		for (const plugin of config.plugins) await plugin.afterBuildApp?.(environmentResults, pluginApi, buildAppContext);
+	} catch (error) {
+		buildFailed = true;
+		throw error;
+	} finally {
+		let closeFailed = false;
+		let firstCloseError;
+		for (const environment of [...initializedEnvironments].reverse()) try {
+			await environment.close();
+		} catch (error) {
+			if (!closeFailed) {
+				closeFailed = true;
+				firstCloseError = error;
+			}
+			const closeError = error instanceof Error ? error : new Error(String(error));
+			logger.error(`[nasti] failed to close environment "${environment.name}"`, { error: closeError });
+		}
+		if (closeFailed && !buildFailed) throw firstCloseError;
+	}
+	const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
+	const allOutput = [...Object.values(environments).flat(), ...buildAppContext.output];
+	const totalSize = allOutput.reduce((sum, chunk) => {
+		const content = chunk.type === "chunk" ? chunk.code : chunk.source;
+		if (content == null) return sum;
+		return sum + (typeof content === "string" ? Buffer.byteLength(content) : content.byteLength);
+	}, 0);
+	const fileCount = allOutput.length;
+	const envSuffix = buildableNames.length > 1 ? ` (${buildableNames.join(" + ")})` : "";
+	logger.info(pc.green(`✓ built in ${elapsed}s`) + pc.dim(envSuffix));
+	logger.info(pc.dim(`  ${fileCount} files, ${displaySize(totalSize)} total → ${config.build.outDir}/`));
+	return {
+		output: clientOutput,
+		environments,
+		environmentResults,
+		appOutput: [...buildAppContext.output]
+	};
+}
+/** client 环境构建：HTML 入口 + CSS 抽取 + 体积表 + index.html 改写 */
+async function buildClientEnvironment(config) {
+	const logger = config.logger;
+	const outDir = path.resolve(config.root, config.build.outDir);
+	const cssEngine = createCssEngine();
+	const pluginList = resolvePluginList(config, config.plugins, {
+		cssEngine,
+		environmentName: "client"
+	});
+	const clientEnv = new NastiEnvironment("client", config, {
+		mode: "build",
+		plugins: pluginList,
+		pluginApi: getPluginApi(config)
+	});
+	await clientEnv.init();
+	try {
+		if (clientEnv.driver) {
+			if (!clientEnv.driver.build) throw new Error(`[nasti] environment "client" driver "${clientEnv.driver.name}" does not implement build()`);
+			const result = await clientEnv.driver.build(clientEnv.getDriverContext());
+			assertDriverBuildResult(clientEnv, result);
+			return {
+				environment: clientEnv,
+				result: finalizeEnvironmentResult(clientEnv, result)
+			};
+		}
+		fs.mkdirSync(outDir, { recursive: true });
+		const htmlFile = config.environments.client.html ?? path.resolve(config.root, "index.html");
+		const html = await readHtmlFile(config.root, htmlFile);
+		const entryPoints = resolveClientEntries(config, html);
+		if (entryPoints.length === 0) throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
+		const allPlugins = clientEnv.plugins;
+		const nativeReporter = config.logLevel === "silent" ? null : await tryNativeReporterPlugin(config, logger);
+		const { inputOptions, outputOptions } = getRolldownOptions(clientEnv, entryPoints, [
+			createOxcTransformPlugin(config, clientEnv),
+			...toRolldownPlugins(allPlugins, clientEnv),
+			...nativeReporter ? [nativeReporter] : []
+		]);
+		const bundle = await rolldown(inputOptions);
+		const { output } = await bundle.write(outputOptions);
+		await bundle.close();
+		clientEnv.setBuildMetadata({ css: getCssMetadata(cssEngine) });
+		if (html) {
+			let processedHtml = html;
+			const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
+			for (const p of htmlPlugins) {
+				const result = await p.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);
+			}
+			if (clientEnv.options.build.css.inject !== false) processedHtml = injectCssLinks(processedHtml, cssEngine, config);
+			for (const chunk of output) if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) processedHtml = replaceEntryScript(processedHtml, chunk.facadeModuleId, chunk.fileName, config, htmlFile, config.base);
+			fs.writeFileSync(path.resolve(outDir, "index.html"), processedHtml);
+		}
+		if (!nativeReporter && config.logLevel !== "silent") reportBuildOutput(output, config, logger);
+		warnLargeChunks(output, config, logger);
+		return {
+			environment: clientEnv,
+			result: finalizeEnvironmentResult(clientEnv, { output })
+		};
+	} catch (error) {
+		try {
+			await clientEnv.close();
+		} catch (closeError) {
+			const normalized = closeError instanceof Error ? closeError : new Error(String(closeError));
+			logger.error("[nasti] failed to close client environment after build failure", { error: normalized });
+		}
+		throw error;
+	}
+}
+/** 非 client 环境构建（SSR / worker / main / preload …）：entry 显式声明 */
+async function buildServerEnvironment(config, name) {
+	const envOptions = config.environments[name];
+	const logger = config.logger;
+	const cssEngine = envOptions.consumer === "client" ? createCssEngine() : void 0;
+	const pluginList = resolvePluginList(config, config.plugins, {
+		consumer: envOptions.consumer,
+		environmentName: name,
+		cssEngine
+	});
+	const environment = new NastiEnvironment(name, config, {
+		mode: "build",
+		plugins: pluginList,
+		pluginApi: getPluginApi(config)
+	});
+	await environment.init();
+	if (environment.driver) {
+		if (!environment.driver.build) {
+			await environment.close();
+			throw new Error(`[nasti] environment "${name}" driver "${environment.driver.name}" does not implement build()`);
+		}
+		try {
+			const result = await environment.driver.build(environment.getDriverContext());
+			assertDriverBuildResult(environment, result);
+			return {
+				environment,
+				result: finalizeEnvironmentResult(environment, result)
+			};
+		} catch (error) {
+			await environment.close();
+			throw error;
+		}
+	}
+	for (const entry of envOptions.entry) if (!fs.existsSync(entry)) {
+		await environment.close();
+		throw new Error(`[nasti] environment "${name}" entry not found: ${entry}`);
+	}
+	const rolldownPlugins = [createOxcTransformPlugin(config, environment), ...toRolldownPlugins(environment.plugins, environment)];
+	const { inputOptions, outputOptions, outDir } = getRolldownOptions(environment, envOptions.entry, rolldownPlugins);
+	fs.mkdirSync(outDir, { recursive: true });
+	const bundle = await rolldown(inputOptions);
+	const { output } = await bundle.write(outputOptions);
+	await bundle.close();
+	if (cssEngine) environment.setBuildMetadata({ css: getCssMetadata(cssEngine) });
+	logger.info(pc.dim(`  [${name}] `) + output.map((o) => path.join(envOptions.build.outDir, o.fileName)).join(pc.dim(", ")));
+	return {
+		environment,
+		result: finalizeEnvironmentResult(environment, { output })
+	};
+}
+/** 注入抽取出的 CSS link 标签（entry css 或单文件模式） */
+function injectCssLinks(html, cssEngine, config) {
+	const cssLinkTags = [];
+	if (cssEngine.singleFileName) cssLinkTags.push({
+		tag: "link",
+		attrs: {
+			rel: "stylesheet",
+			href: config.base + cssEngine.singleFileName
+		},
+		injectTo: "head"
+	});
+	else for (const files of cssEngine.entryCss.values()) for (const file of files) cssLinkTags.push({
+		tag: "link",
+		attrs: {
+			rel: "stylesheet",
+			href: config.base + file
+		},
+		injectTo: "head"
+	});
+	return cssLinkTags.length > 0 ? processHtml(html, cssLinkTags) : html;
+}
+function escapeRegExp(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, urlPrefix) {
+	const rootRelative = path.relative(config.root, facadeModuleId).split(path.sep).join("/");
+	const resolvedHtmlFile = path.resolve(config.root, htmlFile);
+	const htmlRelative = path.relative(path.dirname(resolvedHtmlFile), facadeModuleId).split(path.sep).join("/");
+	const candidates = /* @__PURE__ */ new Set([
+		rootRelative,
+		`/${rootRelative}`,
+		htmlRelative,
+		`./${htmlRelative}`
+	]);
+	let processed = html;
+	for (const candidate of candidates) processed = processed.replace(new RegExp(`(src=["'])${escapeRegExp(candidate)}([?#][^"']*)?(["'])`, "g"), `$1${urlPrefix}${fileName}$3`);
+	return processed;
+}
+//#endregion
+export { resolveClientEntries as a, replaceEntryScript as i, build_exports as n, toRolldownPlugins as o, getRolldownOptions as r, build as t };
+
+//# sourceMappingURL=build-CENae4VM.js.map