@nasti-toolchain/nasti 2.5.0 → 2.5.2

package/dist/env-lOj3yw8v.cjs

@@ -0,0 +1,924 @@
+const require_logger = require("./logger-M7AuVVTV.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 node_module = require("node:module");
+let oxc_transform = require("oxc-transform");
+//#region src/config/defaults.ts
+const defaultResolve = {
+	alias: {},
+	extensions: [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".json",
+		".vue"
+	],
+	conditions: [
+		"import",
+		"module",
+		"browser",
+		"default"
+	],
+	mainFields: [
+		"module",
+		"jsnext:main",
+		"jsnext",
+		"main"
+	]
+};
+const defaultServer = {
+	port: 3e3,
+	host: "localhost",
+	https: false,
+	open: false,
+	proxy: {},
+	cors: true,
+	hmr: true
+};
+const defaultBuild = {
+	outDir: "dist",
+	assetsDir: "assets",
+	minify: true,
+	sourcemap: false,
+	target: "es2022",
+	rolldownOptions: {},
+	emptyOutDir: true,
+	css: {
+		inject: true,
+		emit: true
+	},
+	reportCompressedSize: true,
+	chunkSizeWarningLimit: 500,
+	cssCodeSplit: true,
+	cssMinify: true
+};
+const defaultElectron = {
+	main: "src/electron/main.ts",
+	preload: "src/electron/preload.ts",
+	renderer: "index.html",
+	nodeTarget: "node22",
+	mainFormat: "cjs",
+	preloadFormat: "cjs",
+	electronPath: "",
+	electronArgs: [],
+	autoRestart: true,
+	minVersion: 41,
+	external: ["electron"]
+};
+const defaultExperimental = { bundledDev: false };
+const defaultReact = {
+	include: /\.[tj]sx?$/,
+	exclude: /node_modules/,
+	jsxImportSource: "react",
+	jsxRuntime: "automatic",
+	compiler: false
+};
+const defaults = {
+	root: ".",
+	base: "/",
+	mode: "development",
+	target: "web",
+	framework: "auto",
+	react: defaultReact,
+	resolve: defaultResolve,
+	server: defaultServer,
+	build: defaultBuild,
+	electron: defaultElectron,
+	plugins: [],
+	envPrefix: ["NASTI_", "VITE_"],
+	logLevel: "info",
+	clearScreen: true,
+	experimental: defaultExperimental
+};
+//#endregion
+//#region src/core/minify.ts
+/**
+* 压缩是否开启 —— 供 `cssMinify` 跟随、体积报告等只关心开关的场合使用。
+*
+* 注意不能简单用 `!!`：`'dce-only'` 与空对象 `{}` 都是真值，但前者只做
+* 死代码消除、后者是「按 OXC 默认项压缩」，二者都算开启；只有 `false`
+* 才是关闭。
+*/
+function isMinifyEnabled(minify) {
+	return minify !== false && minify !== void 0;
+}
+/**
+* 归一化为 Rolldown `OutputOptions.minify` 接受的值。
+*
+* - `'oxc'`：2.x 之前的历史写法，语义等同 `true`（Rolldown 本来就只有
+*   OXC 一个 minifier），归一为 `true` 保持向后兼容；
+* - 对象：原样透传，交给 OXC minifier（`compress` / `mangle` / `codegen`）。
+*   其中 `mangle.keepNames.class` 控制类名是否参与最小化，
+*   `mangle.mangleProps` 是 Rolldown 1.2.6 / OXC 0.147 新增的属性名最小化。
+*/
+function resolveMinifyOption(minify) {
+	if (minify === void 0) return false;
+	if (minify === "oxc") return true;
+	return minify;
+}
+//#endregion
+//#region src/core/plugin-api.ts
+const apiByConfig = /* @__PURE__ */ new WeakMap();
+/**
+* 按 enforce 与显式插件依赖稳定排序。
+*
+* `pre` 表示列出的插件必须先于当前插件，`post` 表示列出的插件必须后于
+* 当前插件。未安装的可选依赖会被忽略；依赖环会在配置阶段直接报错。
+*/
+function orderPlugins(plugins) {
+	const baseline = plugins.map((plugin, index) => ({
+		plugin,
+		index
+	})).sort((a, b) => enforceRank(a.plugin) - enforceRank(b.plugin) || a.index - b.index).map(({ plugin }) => plugin);
+	const indexesByName = /* @__PURE__ */ new Map();
+	baseline.forEach((plugin, index) => {
+		const indexes = indexesByName.get(plugin.name) ?? [];
+		indexes.push(index);
+		indexesByName.set(plugin.name, indexes);
+	});
+	const edges = baseline.map(() => /* @__PURE__ */ new Set());
+	const indegree = baseline.map(() => 0);
+	const addEdge = (from, to) => {
+		if (from === to || edges[from].has(to)) return;
+		edges[from].add(to);
+		indegree[to]++;
+	};
+	baseline.forEach((plugin, current) => {
+		for (const dependency of plugin.pre ?? []) for (const before of indexesByName.get(dependency) ?? []) addEdge(before, current);
+		for (const dependency of plugin.post ?? []) for (const after of indexesByName.get(dependency) ?? []) addEdge(current, after);
+	});
+	const ready = indegree.map((degree, index) => ({
+		degree,
+		index
+	})).filter(({ degree }) => degree === 0).map(({ index }) => index);
+	const ordered = [];
+	while (ready.length > 0) {
+		ready.sort((a, b) => a - b);
+		const current = ready.shift();
+		ordered.push(baseline[current]);
+		for (const next of edges[current]) {
+			indegree[next]--;
+			if (indegree[next] === 0) ready.push(next);
+		}
+	}
+	if (ordered.length !== baseline.length) {
+		const cyclic = baseline.filter((_, index) => indegree[index] > 0).map((plugin) => plugin.name);
+		throw new Error(`[nasti] circular plugin setup dependency: ${[...new Set(cyclic)].join(", ")}`);
+	}
+	return ordered;
+}
+/** 创建并注册一次配置解析周期内共享的插件 API。 */
+async function setupPluginApi(config, plugins) {
+	const exposed = /* @__PURE__ */ new Map();
+	const api = {
+		config,
+		logger: config.logger,
+		expose(key, value) {
+			if (exposed.has(key) && exposed.get(key) !== value) throw new Error(`[nasti] plugin API key already exposed: ${String(key)}`);
+			exposed.set(key, value);
+		},
+		useExposed(key) {
+			return exposed.get(key);
+		}
+	};
+	apiByConfig.set(config, api);
+	for (const plugin of plugins) await plugin.setup?.(api);
+	return api;
+}
+function getPluginApi(config) {
+	const api = apiByConfig.get(config);
+	if (!api) throw new Error("[nasti] internal: plugin API requested before setup; getPluginApi requires the original ResolvedConfig reference registered by setupPluginApi, not a shallow copy");
+	return api;
+}
+function enforceRank(plugin) {
+	if (plugin.enforce === "pre") return 0;
+	if (plugin.enforce === "post") return 2;
+	return 1;
+}
+//#endregion
+//#region src/config/index.ts
+/** 读取 tsconfig.json 中的 paths，转换为 Nasti alias 格式 */
+function loadTsconfigPaths(root) {
+	const tsconfigPath = node_path.default.resolve(root, "tsconfig.json");
+	if (!node_fs.default.existsSync(tsconfigPath)) return {};
+	try {
+		const stripped = node_fs.default.readFileSync(tsconfigPath, "utf-8").replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		const tsconfig = JSON.parse(stripped);
+		const paths = tsconfig?.compilerOptions?.paths ?? {};
+		const baseUrl = tsconfig?.compilerOptions?.baseUrl ?? ".";
+		const alias = {};
+		for (const [pattern, targets] of Object.entries(paths)) {
+			if (!targets.length) continue;
+			const cleanKey = pattern.replace(/\/\*$/, "");
+			const cleanTarget = targets[0].replace(/\/\*$/, "");
+			alias[cleanKey] = node_path.default.resolve(root, baseUrl, cleanTarget);
+		}
+		return alias;
+	} catch {
+		return {};
+	}
+}
+function defineConfig(config) {
+	return config;
+}
+const CONFIG_FILES = [
+	"nasti.config.ts",
+	"nasti.config.js",
+	"nasti.config.mjs",
+	"nasti.config.mts"
+];
+async function loadConfigFromFile(root) {
+	for (const file of CONFIG_FILES) {
+		const filePath = node_path.default.resolve(root, file);
+		if (!node_fs.default.existsSync(filePath)) continue;
+		if (file.endsWith(".ts") || file.endsWith(".mts")) return await loadTsConfig(filePath);
+		const mod = await import((0, node_url.pathToFileURL)(filePath).href);
+		return mod.default ?? mod;
+	}
+	return {};
+}
+/**
+* 将 framework:auto 收敛为具体框架。
+*
+* 优先使用源码中的 .vue 文件消除同时安装 React/Vue 时的歧义，其次读取
+* package.json dependencies，最后回退 React 以保持 1.x 默认行为。
+*/
+function detectFramework(root) {
+	if (containsVueFile(node_path.default.resolve(root, "src"))) return "vue";
+	const packagePath = node_path.default.resolve(root, "package.json");
+	if (node_fs.default.existsSync(packagePath)) try {
+		const pkg = JSON.parse(node_fs.default.readFileSync(packagePath, "utf-8"));
+		const dependencies = {
+			...pkg.dependencies ?? {},
+			...pkg.devDependencies ?? {},
+			...pkg.peerDependencies ?? {},
+			...pkg.optionalDependencies ?? {}
+		};
+		const hasVue = "vue" in dependencies || "@vue/runtime-dom" in dependencies;
+		const hasReact = "react" in dependencies || "react-dom" in dependencies;
+		if (hasVue && !hasReact) return "vue";
+		if (hasReact) return "react";
+		if (hasVue) return "vue";
+	} catch {}
+	return "react";
+}
+function containsVueFile(dir, depth = 0) {
+	if (depth > 5 || !node_fs.default.existsSync(dir)) return false;
+	try {
+		for (const entry of node_fs.default.readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isFile() && entry.name.endsWith(".vue")) return true;
+			if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && containsVueFile(node_path.default.join(dir, entry.name), depth + 1)) return true;
+		}
+	} catch {
+		return false;
+	}
+	return false;
+}
+async function loadTsConfig(filePath) {
+	const { transformSync } = await import("oxc-transform");
+	const result = transformSync(filePath, node_fs.default.readFileSync(filePath, "utf-8"), { typescript: {} });
+	const tmpFile = filePath + ".timestamp-" + Date.now() + ".mjs";
+	try {
+		node_fs.default.writeFileSync(tmpFile, result.code);
+		const mod = await import((0, node_url.pathToFileURL)(tmpFile).href);
+		return mod.default ?? mod;
+	} finally {
+		node_fs.default.unlinkSync(tmpFile);
+	}
+}
+/**
+* Resolve the final configuration by loading file-based config, merging with inline config, and applying plugin hooks.
+*
+* Loads configuration from the project root (derived from `inlineConfig.root` or defaults), deep-merges file config with `inlineConfig` (inline takes precedence), runs each plugin's `config` hook and incorporates any returned partial config, constructs the complete `ResolvedConfig` (filling defaults for missing values and resolving tsconfig paths), filters plugins according to their `apply` field, and then invokes each included plugin's `configResolved` hook.
+*
+* @param inlineConfig - User-provided configuration that overrides file config and defaults
+* @param command - The current command, either `"build"` or `"serve"`, which influences mode and plugin filtering
+* @returns The fully resolved configuration with defaults applied, plugins filtered, and plugin hooks executed
+*/
+async function resolveConfig(inlineConfig = {}, command) {
+	const root = node_path.default.resolve(inlineConfig.root ?? defaults.root);
+	const fileConfig = await loadConfigFromFile(root);
+	const merged = deepMerge(deepMerge({}, fileConfig), inlineConfig);
+	const rawPlugins = [...fileConfig.plugins ?? [], ...inlineConfig.plugins ?? []];
+	const mode = merged.mode ?? (command === "build" ? "production" : "development");
+	const env = {
+		mode,
+		command
+	};
+	for (const plugin of rawPlugins) if (plugin.config) {
+		const result = await plugin.config(merged, env);
+		if (result) Object.assign(merged, result);
+	}
+	const logLevel = merged.logLevel ?? defaults.logLevel;
+	const clearScreen = merged.clearScreen ?? defaults.clearScreen;
+	const logger = require_logger.createLogger(logLevel, {
+		allowClearScreen: clearScreen,
+		customLogger: merged.customLogger
+	});
+	const mergedBuild = {
+		...defaults.build,
+		...merged.build,
+		css: {
+			...defaults.build.css,
+			...merged.build?.css
+		}
+	};
+	if (merged.build?.cssMinify === void 0) mergedBuild.cssMinify = isMinifyEnabled(mergedBuild.minify);
+	const resolved = {
+		root,
+		base: merged.base ?? defaults.base,
+		mode,
+		target: merged.target ?? defaults.target,
+		framework: (merged.framework ?? defaults.framework) === "auto" ? detectFramework(root) : merged.framework,
+		react: {
+			include: merged.react?.include ?? defaultReact.include,
+			exclude: merged.react?.exclude ?? defaultReact.exclude,
+			jsxImportSource: merged.react?.jsxImportSource ?? defaultReact.jsxImportSource,
+			jsxRuntime: merged.react?.jsxRuntime ?? defaultReact.jsxRuntime,
+			compiler: merged.react?.compiler === true ? {} : merged.react?.compiler ?? defaultReact.compiler
+		},
+		command,
+		resolve: {
+			alias: {
+				...loadTsconfigPaths(root),
+				...defaults.resolve.alias,
+				...merged.resolve?.alias
+			},
+			extensions: merged.resolve?.extensions ?? defaults.resolve.extensions,
+			conditions: merged.resolve?.conditions ?? defaults.resolve.conditions,
+			mainFields: merged.resolve?.mainFields ?? defaults.resolve.mainFields
+		},
+		plugins: [],
+		server: {
+			...defaults.server,
+			...merged.server
+		},
+		build: mergedBuild,
+		electron: {
+			...defaults.electron,
+			...merged.electron
+		},
+		envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
+		logLevel,
+		clearScreen,
+		logger,
+		environments: {},
+		experimental: { bundledDev: merged.experimental?.bundledDev ?? defaults.experimental.bundledDev }
+	};
+	const rawUserEnvironments = {
+		client: {},
+		ssr: {},
+		...merged.environments ?? {}
+	};
+	const userEnvironments = Object.fromEntries(Object.entries(rawUserEnvironments).map(([name, options]) => [name, deepMerge({}, options)]));
+	for (const [name, envOptions] of Object.entries(userEnvironments)) for (const plugin of rawPlugins) if (plugin.configEnvironment) {
+		const result = await plugin.configEnvironment(name, envOptions, env);
+		if (result) Object.assign(envOptions, deepMerge(envOptions, result));
+	}
+	for (const [name, envOptions] of Object.entries(userEnvironments)) {
+		const consumer = envOptions.consumer ?? (name === "client" ? "client" : "server");
+		const vueOptions = deepMerge({}, envOptions.vue ?? {});
+		if (name === "client") {
+			if (envOptions.resolve) Object.assign(resolved.resolve, {
+				...envOptions.resolve,
+				alias: {
+					...resolved.resolve.alias,
+					...envOptions.resolve.alias
+				}
+			});
+			if (envOptions.build) {
+				const { css, ...environmentBuild } = envOptions.build;
+				Object.assign(resolved.build, environmentBuild);
+				if (css) resolved.build.css = {
+					...resolved.build.css,
+					...css
+				};
+			}
+			resolved.environments.client = {
+				consumer,
+				buildEnabled: envOptions.buildEnabled ?? true,
+				entry: normalizeEnvironmentEntries(envOptions.entry, root),
+				html: node_path.default.resolve(root, envOptions.html ?? (resolved.target === "electron" ? resolved.electron.renderer : "index.html")),
+				driver: envOptions.driver,
+				resolve: resolved.resolve,
+				build: resolved.build,
+				vue: vueOptions
+			};
+			continue;
+		}
+		resolved.environments[name] = {
+			consumer,
+			buildEnabled: envOptions.buildEnabled ?? true,
+			entry: normalizeEnvironmentEntries(envOptions.entry, root),
+			html: envOptions.consumer === "client" && envOptions.html ? node_path.default.resolve(root, envOptions.html) : void 0,
+			driver: envOptions.driver,
+			vue: vueOptions,
+			resolve: {
+				alias: {
+					...resolved.resolve.alias,
+					...envOptions.resolve?.alias
+				},
+				extensions: envOptions.resolve?.extensions ?? [...resolved.resolve.extensions],
+				conditions: envOptions.resolve?.conditions ?? (consumer === "server" ? ["node", ...resolved.resolve.conditions.filter((c) => c !== "browser")] : [...resolved.resolve.conditions]),
+				mainFields: envOptions.resolve?.mainFields ?? (consumer === "server" ? ["module", "main"] : [...resolved.resolve.mainFields])
+			},
+			build: {
+				...resolved.build,
+				...envOptions.build,
+				css: {
+					...resolved.build.css,
+					...envOptions.build?.css
+				},
+				outDir: envOptions.build?.outDir ?? node_path.default.join(resolved.build.outDir, name),
+				minify: envOptions.build?.minify ?? (consumer === "server" ? false : resolved.build.minify)
+			}
+		};
+	}
+	assertClientEnvironmentMirror(resolved);
+	const filteredPlugins = orderPlugins(rawPlugins.filter((p) => {
+		if (!p.apply) return true;
+		if (typeof p.apply === "function") return p.apply(resolved, env);
+		return p.apply === command;
+	}));
+	resolved.plugins = filteredPlugins;
+	await setupPluginApi(resolved, filteredPlugins);
+	if (resolved.target === "electron") {
+		const autoExternal = detectNativeDeps(root);
+		if (autoExternal.length > 0) {
+			const current = new Set(resolved.electron.external ?? []);
+			for (const dep of autoExternal) current.add(dep);
+			resolved.electron.external = [...current];
+		}
+	}
+	for (const plugin of resolved.plugins) if (plugin.configResolved) await plugin.configResolved(resolved);
+	return resolved;
+}
+function normalizeEnvironmentEntries(entry, root) {
+	return (Array.isArray(entry) ? entry : entry ? [entry] : []).map((item) => node_path.default.resolve(root, item));
+}
+/**
+* 扫描项目 dependencies，返回需要从 Electron 主进程 bundle 中外部化的 native 模块列表。
+*
+* 判定依据（任一满足即视为 native）：
+*   - 包根目录存在 binding.gyp
+*   - package.json 有 gypfile: true
+*   - 包内存在 *.node 预编译产物
+*   - 常见已知 native 包白名单（对付有些包不走 node-gyp 但运行时仍需原生 addon 的场景）
+*/
+function detectNativeDeps(root) {
+	const result = /* @__PURE__ */ new Set();
+	const pkgJsonPath = node_path.default.resolve(root, "package.json");
+	if (!node_fs.default.existsSync(pkgJsonPath)) return [];
+	let pkg;
+	try {
+		pkg = JSON.parse(node_fs.default.readFileSync(pkgJsonPath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const deps = {
+		...pkg.dependencies ?? {},
+		...pkg.optionalDependencies ?? {}
+	};
+	const KNOWN_NATIVE = /* @__PURE__ */ new Set([
+		"node-pty",
+		"better-sqlite3",
+		"sharp",
+		"serialport",
+		"@vscode/tree-sitter-wasm",
+		"keytar",
+		"nodegit",
+		"sqlite3",
+		"fsevents"
+	]);
+	for (const dep of Object.keys(deps)) {
+		if (KNOWN_NATIVE.has(dep)) {
+			result.add(dep);
+			continue;
+		}
+		const depDir = node_path.default.resolve(root, "node_modules", dep);
+		if (!node_fs.default.existsSync(depDir)) continue;
+		if (node_fs.default.existsSync(node_path.default.join(depDir, "binding.gyp"))) {
+			result.add(dep);
+			continue;
+		}
+		const subPkg = node_path.default.join(depDir, "package.json");
+		if (node_fs.default.existsSync(subPkg)) try {
+			const sub = JSON.parse(node_fs.default.readFileSync(subPkg, "utf-8"));
+			if (sub.gypfile === true || sub.binary?.module_name) {
+				result.add(dep);
+				continue;
+			}
+		} catch {}
+		if (hasDotNodeFile(depDir)) result.add(dep);
+	}
+	return [...result];
+}
+function hasDotNodeFile(dir, depth = 0) {
+	if (depth > 3) return false;
+	try {
+		const entries = node_fs.default.readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			if (e.isFile() && e.name.endsWith(".node")) return true;
+			if (e.isDirectory() && (e.name === "build" || e.name === "prebuilds" || e.name === "Release")) {
+				if (hasDotNodeFile(node_path.default.join(dir, e.name), depth + 1)) return true;
+			}
+		}
+	} catch {}
+	return false;
+}
+/**
+* 运行时镜像断言（Phase 1 检查，NASTI_2.0_PLAN.md §1.2）：
+* top-level `resolve`/`build` 与 `environments.client` 必须**精确镜像**，
+* 否则读 flat config 的既有插件与 Environment API 会看到两份配置。
+*
+* 比较规则（文档化）：
+*   - 快路径：引用相等（resolveConfig 保证同引用，正常永远走这里）
+*   - 慢路径：JSON 序列化逐字节比较 resolve{alias,extensions,conditions,
+*     mainFields} 与 build 全字段（含 sourcemap）；函数值（如
+*     rolldownOptions.output.advancedChunks 的 test 回调）会被 JSON 丢弃，
+*     不参与比较 —— 不要在 per-env build 覆盖里只改函数字段
+*   - 设 NASTI_DISABLE_MIRROR_ASSERT=1 可关闭（不建议）
+*/
+function assertClientEnvironmentMirror(config) {
+	if (process.env.NASTI_DISABLE_MIRROR_ASSERT) return;
+	const client = config.environments.client;
+	if (!client) throw new Error("[nasti] internal: environments.client missing after resolveConfig");
+	if (client.resolve === config.resolve && client.build === config.build) return;
+	const pairs = [[
+		"resolve",
+		config.resolve,
+		client.resolve
+	], [
+		"build",
+		config.build,
+		client.build
+	]];
+	for (const [field, top, env] of pairs) {
+		const a = JSON.stringify(top);
+		const b = JSON.stringify(env);
+		if (a !== b) throw new Error(`[nasti] config mirror violation: top-level \`${field}\` and \`environments.client.${field}\` diverged.\n  top-level: ${a}\n  client:    ${b}\ntop-level 与 client 环境必须精确镜像 —— 请通过 top-level 或 environments.client 之一配置，不要在解析后分别修改两者。`);
+	}
+}
+/** 仅普通对象字面量返回 true —— 类实例 / 函数 / Date / Map 等不算，
+*  避免 deepMerge 递归剥掉它们的原型方法（如自定义 customLogger 实例）。 */
+function isPlainObject(val) {
+	if (val === null || typeof val !== "object") return false;
+	const proto = Object.getPrototypeOf(val);
+	return proto === Object.prototype || proto === null;
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const val = source[key];
+		if (isPlainObject(val)) result[key] = deepMerge(result[key] ?? {}, val);
+		else if (val !== void 0) result[key] = val;
+	}
+	return result;
+}
+//#endregion
+//#region src/plugins/resolve.ts
+function resolvePlugin(config) {
+	const { alias, extensions } = config.resolve;
+	const require$1 = (0, node_module.createRequire)(node_path.default.resolve(config.root, "package.json"));
+	const aliasEntries = Object.entries(alias).sort(([a], [b]) => b.length - a.length);
+	let vueRuntimeEntry = null;
+	if (config.framework === "vue") try {
+		const vuePkgJson = require$1.resolve("vue/package.json", { paths: [config.root] });
+		const vueDir = node_path.default.dirname(vuePkgJson);
+		const mod = JSON.parse(node_fs.default.readFileSync(vuePkgJson, "utf-8")).module;
+		const entry = node_path.default.join(vueDir, mod ?? "dist/vue.runtime.esm-bundler.js");
+		if (node_fs.default.existsSync(entry)) vueRuntimeEntry = entry;
+	} catch {}
+	return {
+		name: "nasti:resolve",
+		enforce: "pre",
+		resolveId(source, importer) {
+			for (const [key, value] of aliasEntries) if (source === key || source.startsWith(key + "/")) {
+				const aliasBase = resolveAliasTarget(value, config.root);
+				const sub = source.slice(key.length).replace(/^\//, "");
+				const resolved = tryResolveFile(sub ? node_path.default.join(aliasBase, sub) : aliasBase, extensions);
+				if (resolved) return resolved;
+				break;
+			}
+			if (source.startsWith("/") && !source.startsWith("//")) {
+				const resolved = tryResolveFile(node_path.default.join(config.root, source.slice(1)), extensions);
+				if (resolved) return resolved;
+			}
+			if (node_path.default.isAbsolute(source) && node_fs.default.existsSync(source)) {
+				const resolved = tryResolveFile(source, extensions);
+				if (resolved) return resolved;
+			}
+			if (source.startsWith(".")) {
+				const dir = importer ? node_path.default.dirname(importer) : config.root;
+				const resolved = tryResolveFile(node_path.default.resolve(dir, source), extensions);
+				if (resolved) return resolved;
+			}
+			if (!source.startsWith("/") && !source.startsWith(".")) {
+				if (vueRuntimeEntry && source === "vue") return vueRuntimeEntry;
+				if (config.command === "build") return null;
+				try {
+					return require$1.resolve(source, { paths: [importer ? node_path.default.dirname(importer) : config.root] });
+				} catch {
+					return null;
+				}
+			}
+			return null;
+		},
+		load(id) {
+			if (id.startsWith("\0")) return null;
+			if (!node_fs.default.existsSync(id)) return null;
+			if (id.endsWith(".json")) return `export default ${node_fs.default.readFileSync(id, "utf-8")}`;
+			return null;
+		}
+	};
+}
+/**
+* 把 alias 值统一成磁盘绝对路径，匹配 dev server 的语义：
+*   - `/Users/.../src` 真正的绝对路径 → 直接用
+*   - `/src` 用户写的项目根相对 → 按 `<root>/src` 处理
+*   - 其余字符串相对 root 解析
+*/
+function resolveAliasTarget(value, root) {
+	if (node_path.default.isAbsolute(value) && node_fs.default.existsSync(value)) return value;
+	if (value.startsWith("/")) return node_path.default.join(root, value.slice(1));
+	return node_path.default.resolve(root, value);
+}
+/** 尝试解析文件，带扩展名补全和 index 文件查找 */
+function tryResolveFile(file, extensions) {
+	if (node_fs.default.existsSync(file) && node_fs.default.statSync(file).isFile()) return file;
+	for (const ext of extensions) {
+		const withExt = file + ext;
+		if (node_fs.default.existsSync(withExt) && node_fs.default.statSync(withExt).isFile()) return withExt;
+	}
+	if (node_fs.default.existsSync(file) && node_fs.default.statSync(file).isDirectory()) for (const ext of extensions) {
+		const indexFile = node_path.default.join(file, "index" + ext);
+		if (node_fs.default.existsSync(indexFile)) return indexFile;
+	}
+	return null;
+}
+//#endregion
+//#region src/core/transformer.ts
+const JS_EXTENSIONS = /\.(js|mjs|cjs)$/;
+const TS_EXTENSIONS = /\.(ts|mts|cts)$/;
+const JSX_EXTENSIONS = /\.(jsx|tsx)$/;
+function shouldTransform(id) {
+	return TS_EXTENSIONS.test(id) || JSX_EXTENSIONS.test(id) || JS_EXTENSIONS.test(id) && false;
+}
+function transformCode(filename, code, options = {}) {
+	const isTS = TS_EXTENSIONS.test(filename) || /\.tsx$/.test(filename);
+	const isJSX = JSX_EXTENSIONS.test(filename);
+	const result = (0, oxc_transform.transformSync)(filename, code, {
+		typescript: isTS ? {} : void 0,
+		jsx: isJSX || /\.tsx$/.test(filename) ? {
+			runtime: options.jsxRuntime ?? "automatic",
+			importSource: options.jsxImportSource ?? "react",
+			refresh: options.reactRefresh ?? false
+		} : void 0,
+		sourcemap: options.sourcemap ?? true,
+		target: options.target
+	});
+	if (result.errors && result.errors.length > 0) {
+		const msg = result.errors.map((e) => e.message ?? String(e)).join("\n");
+		throw new Error(`OXC transform failed for ${filename}:\n${msg}`);
+	}
+	return {
+		code: result.code,
+		map: result.map ? JSON.stringify(result.map) : null
+	};
+}
+/** 与 @vitejs/plugin-react 一致的线性预筛选，宁可误报也不漏掉组件或 Hook。 */
+const defaultReactCompilerCodeFilter = /forwardRef|memo|\b(?:[A-Z]|use[A-Z0-9])/;
+let reactCompilerImplementation;
+/**
+* React 专用转换入口。默认仍走既有同步 OXC 管线；仅在显式开启 Compiler 时
+* 加载可选的原生编译器，并且只对 client consumer 启用 memo 编译。
+*/
+async function transformReactCode(filename, code, options) {
+	if (!matchesReactFilter(filename, options.react.include, options.react.exclude)) return null;
+	if (!options.react.compiler) {
+		if (!shouldTransform(filename)) return null;
+		return transformCode(filename, code, {
+			sourcemap: options.sourcemap,
+			jsxRuntime: options.react.jsxRuntime,
+			jsxImportSource: options.react.jsxImportSource,
+			reactRefresh: options.reactRefresh,
+			target: options.target
+		});
+	}
+	if (!shouldTransform(filename)) return null;
+	const compiler = await loadReactCompiler();
+	const compilerOptions = options.react.compiler;
+	const shouldCompile = options.consumer === "client" && (compilerOptions.compilationMode === "annotation" ? /['"]use memo['"]/.test(code) : defaultReactCompilerCodeFilter.test(code));
+	const result = await compiler.transform(cleanTransformId(filename), code, {
+		jsx: {
+			runtime: options.react.jsxRuntime,
+			development: options.development,
+			importSource: options.react.jsxImportSource,
+			refresh: options.consumer === "client" && !!options.reactRefresh
+		},
+		reactCompiler: shouldCompile ? compilerOptions : false,
+		sourcemap: options.sourcemap ?? true
+	});
+	const diagnostics = result.errors.map((error) => `${error.message}${error.codeframe ? `\n${error.codeframe}` : ""}`);
+	if (result.fatal) throw new Error(diagnostics.join("\n\n") || `React Compiler transform failed for ${filename}`);
+	for (const diagnostic of diagnostics) options.onWarning?.(diagnostic);
+	return {
+		code: result.code,
+		map: result.map ? JSON.stringify(result.map) : null
+	};
+}
+function matchesReactFilter(id, include, exclude) {
+	const cleanId = cleanTransformId(id);
+	return matchesFilter(cleanId, include) && !matchesFilter(cleanId, exclude);
+}
+function matchesFilter(id, filter) {
+	return (Array.isArray(filter) ? filter : [filter]).some((pattern) => {
+		if (pattern instanceof RegExp) {
+			pattern.lastIndex = 0;
+			return pattern.test(id);
+		}
+		if (!pattern.includes("*")) return id.includes(pattern);
+		const expression = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*");
+		return new RegExp(`^${expression}$`).test(id);
+	});
+}
+function cleanTransformId(id) {
+	return id.split(/[?#]/, 1)[0];
+}
+async function loadReactCompiler() {
+	if (reactCompilerImplementation) return reactCompilerImplementation;
+	try {
+		reactCompilerImplementation = await import("oxc-transform-react");
+		return reactCompilerImplementation;
+	} catch (error) {
+		throw new Error("[nasti] React Compiler requires the optional \"oxc-transform-react\" package. Install it before setting react.compiler." + (error instanceof Error ? `\n${error.message}` : ""));
+	}
+}
+//#endregion
+//#region src/core/env.ts
+/**
+* 从 .env 文件加载环境变量，按优先级合并：
+*   .env < .env.[mode] < .env.local < .env.[mode].local
+*/
+function loadEnv(mode, root, prefixes) {
+	const envFiles = [
+		".env",
+		`.env.${mode}`,
+		".env.local",
+		`.env.${mode}.local`
+	];
+	const raw = {};
+	for (const file of envFiles) {
+		const filePath = node_path.default.resolve(root, file);
+		if (!node_fs.default.existsSync(filePath)) continue;
+		const content = node_fs.default.readFileSync(filePath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIdx = trimmed.indexOf("=");
+			if (eqIdx === -1) continue;
+			const key = trimmed.slice(0, eqIdx).trim();
+			let value = trimmed.slice(eqIdx + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			raw[key] = value;
+		}
+	}
+	const filtered = {};
+	for (const [key, value] of Object.entries(raw)) if (prefixes.some((prefix) => key.startsWith(prefix))) filtered[key] = value;
+	return filtered;
+}
+/**
+* 将过滤后的 env 转为 Rolldown define 对象
+* 例: { VITE_FOO: 'bar' } → { 'import.meta.env.VITE_FOO': '"bar"' }
+* 同时注入 import.meta.env.MODE / DEV / PROD / SSR
+*
+* per-env define 钩子（Phase1→Phase2 接口契约）：`overrides` 允许调用方按
+* 环境覆盖任意 define —— server 环境传 `ssrDefineOverrides('server')` 注入
+* `import.meta.env.SSR='true'`，不再写死 'false'。
+*/
+function buildEnvDefine(env, mode, overrides = {}) {
+	const define = {};
+	for (const [key, value] of Object.entries(env)) define[`import.meta.env.${key}`] = JSON.stringify(value);
+	define["import.meta.env.MODE"] = JSON.stringify(mode);
+	define["import.meta.env.DEV"] = mode !== "production" ? "true" : "false";
+	define["import.meta.env.PROD"] = mode === "production" ? "true" : "false";
+	define["import.meta.env.SSR"] = "false";
+	return {
+		...define,
+		...overrides
+	};
+}
+/** 按环境 consumer 派生 import.meta.env.SSR 的 define 覆盖 */
+function ssrDefineOverrides(consumer) {
+	return { "import.meta.env.SSR": consumer === "server" ? "true" : "false" };
+}
+/**
+* 在代码字符串中替换 import.meta.env.KEY（用于 dev 服务器按需转换）
+*/
+function replaceEnvInCode(code, define) {
+	let result = code;
+	for (const [key, value] of Object.entries(define)) {
+		const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		result = result.replace(new RegExp(escaped, "g"), value);
+	}
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "buildEnvDefine", {
+	enumerable: true,
+	get: function() {
+		return buildEnvDefine;
+	}
+});
+Object.defineProperty(exports, "defineConfig", {
+	enumerable: true,
+	get: function() {
+		return defineConfig;
+	}
+});
+Object.defineProperty(exports, "detectFramework", {
+	enumerable: true,
+	get: function() {
+		return detectFramework;
+	}
+});
+Object.defineProperty(exports, "getPluginApi", {
+	enumerable: true,
+	get: function() {
+		return getPluginApi;
+	}
+});
+Object.defineProperty(exports, "loadEnv", {
+	enumerable: true,
+	get: function() {
+		return loadEnv;
+	}
+});
+Object.defineProperty(exports, "matchesReactFilter", {
+	enumerable: true,
+	get: function() {
+		return matchesReactFilter;
+	}
+});
+Object.defineProperty(exports, "orderPlugins", {
+	enumerable: true,
+	get: function() {
+		return orderPlugins;
+	}
+});
+Object.defineProperty(exports, "replaceEnvInCode", {
+	enumerable: true,
+	get: function() {
+		return replaceEnvInCode;
+	}
+});
+Object.defineProperty(exports, "resolveConfig", {
+	enumerable: true,
+	get: function() {
+		return resolveConfig;
+	}
+});
+Object.defineProperty(exports, "resolveMinifyOption", {
+	enumerable: true,
+	get: function() {
+		return resolveMinifyOption;
+	}
+});
+Object.defineProperty(exports, "resolvePlugin", {
+	enumerable: true,
+	get: function() {
+		return resolvePlugin;
+	}
+});
+Object.defineProperty(exports, "shouldTransform", {
+	enumerable: true,
+	get: function() {
+		return shouldTransform;
+	}
+});
+Object.defineProperty(exports, "ssrDefineOverrides", {
+	enumerable: true,
+	get: function() {
+		return ssrDefineOverrides;
+	}
+});
+Object.defineProperty(exports, "transformCode", {
+	enumerable: true,
+	get: function() {
+		return transformCode;
+	}
+});
+Object.defineProperty(exports, "transformReactCode", {
+	enumerable: true,
+	get: function() {
+		return transformReactCode;
+	}
+});
+
+//# sourceMappingURL=env-lOj3yw8v.cjs.map