weapp-vite 7.4.0 → 7.5.0

package/dist/session-PskhD-nZ.mjs

@@ -0,0 +1,390 @@
+import { C as attachStatefulHmrHost, D as resolveHmrRuntimeDecision, E as createSharedBuildConfig, T as getStatefulHmrHost, _ as getPackNpmRelationList, b as createOxcRuntimeSupport, g as captureWatchDependencies, h as checkAppWorkersOptions, m as syncManagedTsconfigFiles, u as CompilerSession, v as createPackageBuilder, w as createStatefulHmrHostPlugins, y as settlePackageBuilds } from "./createCompilerContextInstance-DJH_P_nZ.mjs";
+import { c as resolveRealpath } from "./protocol-vg8HGJ4n.mjs";
+import { F as resolveNpmDistDirName, L as resolveTargetDependencies, M as resolveMainBuildDependencyPatterns, N as resolveNpmBuildCandidateDependenciesSync, f as attachDevModuleGraphHost } from "./devProvider-BGBkw28J.mjs";
+import { v as loadHostRolldownBuild, y as pruneOwnedAssetFiles } from "./utils-CJSCgEj6.mjs";
+import path from "pathe";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import { build } from "vite";
+import { createHash } from "node:crypto";
+import { Buffer } from "node:buffer";
+import os from "node:os";
+//#region src/vite/npm/sourcemap.ts
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/i;
+const INLINE_MAP = /(\/\/[#@]\s*sourceMappingURL=data:application\/json(?:;charset=[^;,]*)?;base64,)([a-z\d+/=]+)/gi;
+/** npm 镜像目录深度可能不同，重定位相对源码路径但保持 URL 与绝对来源不变。 */
+function relocateNpmSourcemap(source, from, to) {
+	if (!from.endsWith(".map")) {
+		if (/\.[cm]?js$/.test(from)) return (typeof source === "string" ? source : Buffer.from(source).toString("utf8")).replace(INLINE_MAP, (_match, prefix, encoded) => {
+			const map = relocateNpmSourcemap(Buffer.from(encoded, "base64"), `${from}.map`, `${to}.map`);
+			return `${prefix}${Buffer.from(map).toString("base64")}`;
+		});
+		return source;
+	}
+	let value;
+	try {
+		value = JSON.parse(typeof source === "string" ? source : Buffer.from(source).toString("utf8"));
+	} catch {
+		return source;
+	}
+	if (!value || typeof value !== "object" || !("sources" in value) || !Array.isArray(value.sources) || !value.sources.every((item) => typeof item === "string")) return source;
+	const sourceRoot = "sourceRoot" in value && typeof value.sourceRoot === "string" ? value.sourceRoot : "";
+	if (URL_SCHEME.test(sourceRoot)) return source;
+	const sources = value.sources.map((item) => {
+		if (URL_SCHEME.test(item) || path.isAbsolute(item)) return item;
+		return path.relative(path.dirname(to), path.resolve(path.dirname(from), sourceRoot, item));
+	});
+	return JSON.stringify({
+		...value,
+		sourceRoot: "",
+		sources
+	});
+}
+//#endregion
+//#region src/vite/npm/output.ts
+function relativeOutput(root, target) {
+	const relative = path.relative(root, target);
+	return relative !== ".." && !relative.startsWith("../") && !path.isAbsolute(relative) ? relative : void 0;
+}
+/** 依赖回调只决定逻辑路径，bundle 保持内存，原生包复制只进入本会话的临时目录。 */
+function createNpmOutput(temporaryRoot, targetRoots) {
+	const directories = /* @__PURE__ */ new Map();
+	const roots = new Set(targetRoots);
+	const files = /* @__PURE__ */ new Map();
+	const watchFiles = /* @__PURE__ */ new Set();
+	function addFile(fileName, source) {
+		const existing = files.get(fileName);
+		if (existing !== void 0 && !Buffer.from(existing).equals(Buffer.from(source))) throw new Error(`[weapp-vite] 多个 npm 依赖产生了不同内容的同名文件：${fileName}`);
+		files.set(fileName, source);
+	}
+	const output = {
+		watchFile(fileName) {
+			watchFiles.add(fileName);
+		},
+		directory(outDir) {
+			roots.add(outDir);
+			const parent = [...directories.keys()].filter((root) => relativeOutput(root, outDir) !== void 0).sort((a, b) => b.length - a.length)[0];
+			if (parent) return path.join(directories.get(parent), relativeOutput(parent, outDir));
+			const directory = path.join(temporaryRoot, String(directories.size));
+			directories.set(outDir, directory);
+			return directory;
+		},
+		async bundle(options, outDir) {
+			roots.add(outDir);
+			const result = await build({
+				...options,
+				build: {
+					...options.build,
+					write: false,
+					watch: null
+				},
+				plugins: [
+					...options.plugins ?? [],
+					captureWatchDependencies((file) => watchFiles.add(file)),
+					{
+						name: "weapp-vite:npm-inputs",
+						configResolved(config) {
+							for (const file of config.configFileDependencies) watchFiles.add(file);
+						},
+						buildEnd() {
+							for (const file of this.getModuleIds()) if (!file.includes("\0")) watchFiles.add(file.split("?")[0]);
+						}
+					}
+				]
+			});
+			for (const bundle of Array.isArray(result) ? result : [result]) {
+				if (!("output" in bundle)) throw new Error("[weapp-vite] npm 子构建必须返回内存产物。");
+				for (const item of bundle.output) addFile(path.resolve(outDir, item.fileName), item.type === "chunk" ? item.code : item.source);
+			}
+		}
+	};
+	for (const root of targetRoots) output.directory(root);
+	async function collect(directory, logicalRoot) {
+		let entries;
+		try {
+			entries = await readdir(directory, { withFileTypes: true });
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+		for (const entry of entries) {
+			const source = path.join(directory, entry.name);
+			const destination = path.join(logicalRoot, entry.name);
+			if (entry.isDirectory()) await collect(source, destination);
+			else if (entry.isFile()) addFile(destination, await readFile(source));
+			else throw new Error(`[weapp-vite] npm 中间目录含有无法发布的文件类型：${destination}`);
+		}
+	}
+	return {
+		output,
+		async finish(hostOutDir, mainOutDir, mirrors) {
+			for (const [logicalRoot, directory] of directories) await collect(directory, logicalRoot);
+			const mainFiles = [...files].filter(([fileName]) => relativeOutput(mainOutDir, fileName) !== void 0);
+			for (const mirror of mirrors) {
+				roots.add(mirror);
+				for (const [fileName, source] of mainFiles) {
+					const mirroredFile = path.join(mirror, relativeOutput(mainOutDir, fileName));
+					addFile(mirroredFile, relocateNpmSourcemap(source, fileName, mirroredFile));
+				}
+			}
+			const result = {
+				assets: [],
+				external: /* @__PURE__ */ new Map(),
+				watchFiles: [...watchFiles]
+			};
+			for (const [absolutePath, source] of files) {
+				const relative = relativeOutput(hostOutDir, absolutePath);
+				if (relative !== void 0) {
+					result.assets.push({
+						type: "asset",
+						fileName: relative,
+						source
+					});
+					continue;
+				}
+				const directory = [...roots].filter((root) => relativeOutput(root, absolutePath) !== void 0).sort((a, b) => a.length - b.length)[0];
+				const assets = result.external.get(directory) ?? [];
+				assets.push({
+					type: "asset",
+					fileName: relativeOutput(directory, absolutePath),
+					source
+				});
+				result.external.set(directory, assets);
+			}
+			return result;
+		}
+	};
+}
+//#endregion
+//#region src/vite/npm/index.ts
+/** 复用依赖编译器和 npm 关联配置，最终输出统一交给宿主 emit/write。 */
+async function prepareNpmAssets(ctx) {
+	const config = ctx.configService;
+	const empty = {
+		assets: [],
+		external: /* @__PURE__ */ new Map(),
+		watchFiles: []
+	};
+	if (config.weappLibConfig?.enabled || !config.weappViteConfig.npm?.enable) return empty;
+	const [main, ...mirrors] = getPackNpmRelationList(ctx, { defaultOutputRoot: config.outDir });
+	if (!main) return empty;
+	const packageJsonPath = path.resolve(config.cwd, main.packageJsonPath);
+	const resolveFrom = path.dirname(packageJsonPath);
+	let packageJson;
+	try {
+		packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return empty;
+		throw error;
+	}
+	const candidates = resolveNpmBuildCandidateDependenciesSync(ctx, packageJson, resolveFrom);
+	ctx.scanService.loadSubPackages();
+	const npmDirName = resolveNpmDistDirName(config);
+	const mainOutDir = path.resolve(config.cwd, main.miniprogramNpmDistDir, npmDirName);
+	const targets = [{
+		outDir: mainOutDir,
+		dependencies: resolveTargetDependencies(candidates, resolveMainBuildDependencyPatterns(ctx))
+	}, ...[...ctx.scanService.subPackageMap.values()].filter((entry) => entry.subPackage.dependencies?.length).map((entry) => ({
+		outDir: path.join(config.outDir, entry.subPackage.root, npmDirName),
+		dependencies: resolveTargetDependencies(candidates, entry.subPackage.dependencies)
+	}))];
+	const temporaryRoot = await mkdtemp(path.join(os.tmpdir(), "weapp-vite-npm-"));
+	const capture = createNpmOutput(temporaryRoot, targets.map((target) => target.outDir));
+	capture.output.watchFile?.(packageJsonPath);
+	const builder = createPackageBuilder(ctx, createOxcRuntimeSupport().vitePlugin, capture.output);
+	try {
+		for (const target of targets) await settlePackageBuilds(target.dependencies.map((dep) => builder.buildPackage({
+			dep,
+			resolveFrom,
+			outDir: target.outDir,
+			isDependenciesCacheOutdate: true
+		})));
+		const result = await capture.finish(config.outDir, mainOutDir, mirrors.map((relation) => path.resolve(config.cwd, relation.miniprogramNpmDistDir, npmDirName)));
+		if (result.external.size && config.inlineConfig.build?.write === false) throw new Error("[weapp-vite] build.write=false 无法表示宿主输出目录之外的 npm 产物；请使用 write=true 或将 npm 输出映射到宿主 outDir 内。");
+		return result;
+	} finally {
+		await rm(temporaryRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/vite/npm/publish.ts
+/** 手工映射到主目录外的依赖仍由宿主配套引擎写出，只清理上轮实际拥有的文件。 */
+async function publishNpmAssets(outDir, assets, obsolete) {
+	const virtualEntry = "\0weapp-vite-npm-output";
+	const plugin = {
+		name: "weapp-vite:npm-output-writer",
+		resolveId: (id) => id === virtualEntry ? id : void 0,
+		load: (id) => id === virtualEntry ? "export {}" : void 0,
+		buildStart() {
+			for (const asset of assets) this.emitFile(asset);
+		},
+		generateBundle(_options, bundle) {
+			for (const [fileName, item] of Object.entries(bundle)) if (item.type === "chunk" && item.facadeModuleId === virtualEntry) delete bundle[fileName];
+		},
+		async writeBundle() {
+			await pruneOwnedAssetFiles(outDir, obsolete);
+		}
+	};
+	const { rolldown } = await loadHostRolldownBuild();
+	const bundle = await rolldown({
+		input: virtualEntry,
+		logLevel: "silent",
+		plugins: [plugin]
+	});
+	try {
+		await bundle.write({
+			dir: outDir,
+			format: "es"
+		});
+	} finally {
+		await bundle.close();
+	}
+}
+//#endregion
+//#region src/vite/npm/ownership.ts
+async function readOwnership(fileName) {
+	let value;
+	try {
+		value = JSON.parse(await readFile(fileName, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
+		throw error;
+	}
+	if (!Array.isArray(value) || !value.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && Array.isArray(entry[1]) && entry[1].every((file) => typeof file === "string"))) throw new Error("[weapp-vite] npm 输出归属记录损坏，请移除 .weapp-vite/native-npm-output 后重建。");
+	return new Map(value);
+}
+/** 保存外部产物的实际归属，使独立 build 也能删除旧依赖而保留非构建文件。 */
+async function publishOwnedNpmAssets(cwd, hostOutDir, external) {
+	const key = createHash("sha256").update(hostOutDir).digest("hex").slice(0, 20);
+	const metadataRoot = path.join(cwd, ".weapp-vite/native-npm-output");
+	const metadataName = `${key}.json`;
+	const previous = await readOwnership(path.join(metadataRoot, metadataName));
+	const current = /* @__PURE__ */ new Map();
+	const currentFiles = /* @__PURE__ */ new Set();
+	for (const [directory, assets] of external) if (assets.length) {
+		const names = assets.map((asset) => asset.fileName);
+		current.set(directory, names);
+		for (const file of names) currentFiles.add(path.resolve(directory, file));
+	}
+	for (const directory of /* @__PURE__ */ new Set([...external.keys(), ...previous.keys()])) await publishNpmAssets(directory, external.get(directory) ?? [], (previous.get(directory) ?? []).filter((file) => !currentFiles.has(path.resolve(directory, file))));
+	if (current.size || previous.size) await publishNpmAssets(metadataRoot, [{
+		type: "asset",
+		fileName: metadataName,
+		source: JSON.stringify([...current])
+	}], []);
+}
+//#endregion
+//#region src/vite/session.ts
+/** 标准插件的目标校验和依赖准备，共享底层编译会话生命周期。 */
+var WeappBuildSession = class extends CompilerSession {
+	dependencyBuild;
+	validating;
+	isWeb = false;
+	statefulController;
+	async prepare(config, cwd, mode, isDev = false) {
+		if (!config.resolve?.preserveSymlinks) try {
+			cwd = resolveRealpath(cwd);
+		} catch {}
+		this.isWeb = config.weapp?.platform === "web";
+		await this.initialize({
+			cwd,
+			mode,
+			isDev,
+			emitDefaultAutoImportOutputs: false,
+			hostConfig: { config: {
+				...config,
+				root: cwd
+			} },
+			cliPlatform: this.isWeb ? "web" : void 0,
+			syncSupportFiles: false,
+			preloadAppEntry: false
+		});
+		const service = this.context.configService;
+		if (this.isWeb) {
+			const merged = service.mergeWeb();
+			if (!merged) throw new Error("[weapp-vite] Web 目标不能禁用 weapp.web。");
+			return merged;
+		}
+		if (isDev && resolveHmrRuntimeDecision({
+			platform: service.platform,
+			configured: service.weappViteConfig.hmr?.runtime,
+			compileHotReLoad: service.projectPrivateConfig.setting?.compileHotReLoad
+		}).runtime === "stateful-experimental") {
+			if (service.platform !== "weapp") throw new Error("[weapp-vite] stateful-experimental 仅支持微信；其他平台请配置 hmr.runtime=classic。");
+			this.statefulController = createStatefulHmrHostPlugins(this.context);
+		}
+		return this.context.configService.merge(void 0, createSharedBuildConfig(this.context.configService, this.context.scanService));
+	}
+	validateEntries() {
+		if (this.validating && !this.isClosing) return this.validating;
+		if (this.state !== "ready" && this.state !== "building") return Promise.reject(/* @__PURE__ */ new Error(`[weapp-vite] 无法从 ${this.state} 状态开始构建。`));
+		this.dependencyBuild = void 0;
+		return this.validating = this.run(async () => {
+			if (!this.isWeb && !this.context.configService.weappLibConfig?.enabled) {
+				const app = await this.context.scanService.loadAppEntry();
+				checkAppWorkersOptions("app", this.context.configService, app);
+			}
+			if (this.isClosing) throw new Error("[weapp-vite] 构建会话已关闭。");
+			await syncManagedTsconfigFiles(this.context);
+			if (this.isClosing) throw new Error("[weapp-vite] 构建会话已关闭。");
+			this.state = "building";
+		}).finally(() => {
+			this.validating = void 0;
+		});
+	}
+	async startDev(server) {
+		if (this.isWeb) {
+			await this.run(() => syncManagedTsconfigFiles(this.context));
+			this.state = "watching";
+			return;
+		}
+		let started = false;
+		let successful = false;
+		let reportedReady = false;
+		const reportReady = () => {
+			if (started && successful && !reportedReady && !this.isClosing) {
+				reportedReady = true;
+				server.config.logger.info(`[weapp-vite] 小程序开发产物已就绪 (${this.statefulController ? "stateful-experimental" : "classic"})`);
+			}
+		};
+		if (this.statefulController) this.onClose(attachStatefulHmrHost(this.context, {
+			server,
+			controller: this.statefulController
+		}));
+		this.onClose(attachDevModuleGraphHost(this.context, server, (result) => {
+			successful = result;
+			reportReady();
+		}));
+		this.onClose(() => this.context.watcherService.closeAll());
+		await this.validateEntries();
+		await this.run(() => this.context.buildService.build({}));
+		if (!this.isClosing) {
+			this.state = "watching";
+			if (this.statefulController) successful = true;
+			started = true;
+			reportReady();
+		}
+	}
+	async refreshHostControl() {
+		await getStatefulHmrHost(this.context)?.refreshControl?.();
+	}
+	buildDependencies() {
+		if (this.isWeb) return Promise.resolve({
+			assets: [],
+			external: /* @__PURE__ */ new Map(),
+			watchFiles: []
+		});
+		if (this.state !== "building") throw new Error("[weapp-vite] 依赖构建需要活动的构建会话。");
+		return this.dependencyBuild ??= this.run(() => prepareNpmAssets(this.context));
+	}
+	async publishDependencies() {
+		if (!this.dependencyBuild) return;
+		const { external } = await this.dependencyBuild;
+		const { cwd, outDir } = this.context.configService;
+		await this.run(() => publishOwnedNpmAssets(cwd, outDir, external));
+	}
+};
+//#endregion
+export { WeappBuildSession };

package/dist/test.d.mts

@@ -22,6 +22,7 @@ export interface WeappViteTestArtifactWatcher {
   close: () => Promise<void>;
   rebuild: () => Promise<WeappViteTestArtifact>;
 }
+export declare function isTestArtifactCurrent(artifact: WeappViteTestArtifact): Promise<boolean>;
 export declare function buildTestArtifact(options?: BuildTestArtifactOptions): Promise<{
   appConfigPath: string;
   miniprogramRootPath: string;

package/dist/test.mjs

@@ -1,82 +1,239 @@
-import { t as createCompilerContext } from "./createContext-UOEgeYnA.mjs";
-import path from "node:path";
+import { g as captureWatchDependencies, u as CompilerSession } from "./createCompilerContextInstance-DJH_P_nZ.mjs";
+import { a as parseSidecarModuleId, i as parseLogicalEntryId } from "./protocol-vg8HGJ4n.mjs";
 import process from "node:process";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
 import chokidar from "chokidar";
+//#region src/testArtifact/inputs.ts
+const sessionId = randomUUID();
+const excludedDirectories = /* @__PURE__ */ new Set([
+	".git",
+	".weapp-vite",
+	"node_modules"
+]);
+function resolveArtifactOutDir(cwd, options, generation = randomUUID()) {
+	if (options.outDir) return path.resolve(cwd, options.outDir);
+	const key = createHash("sha256").update(JSON.stringify({
+		configFile: options.configFile && path.resolve(cwd, options.configFile),
+		mode: options.mode ?? "test",
+		projectConfigPath: options.projectConfigPath && path.resolve(cwd, options.projectConfigPath),
+		skipNpm: options.skipNpm ?? false
+	})).digest("hex").slice(0, 16);
+	return path.join(cwd, ".weapp-vite/test-artifacts", `${process.pid}-${sessionId}`, key, generation);
+}
+function projectInputFiles(cwd) {
+	return [
+		...[
+			"vite.config",
+			"weapp-vite.config",
+			"vitest.config"
+		].flatMap((name) => [
+			"ts",
+			"mts",
+			"cts",
+			"js",
+			"mjs",
+			"cjs"
+		].map((ext) => `${name}.${ext}`)),
+		"package.json",
+		"pnpm-lock.yaml",
+		"package-lock.json",
+		"yarn.lock",
+		"tsconfig.json",
+		"project.config.json"
+	].map((file) => path.join(cwd, file));
+}
+/** 对真实输入及目录成员取内容摘要，覆盖同长度改写、新增路由和删除文件。 */
+async function fingerprintPaths(paths, excluded = []) {
+	const hash = createHash("sha256");
+	const visited = /* @__PURE__ */ new Set();
+	const ignored = excluded.map((file) => path.resolve(file));
+	const visit = async (file) => {
+		if (ignored.some((root) => file === root || file.startsWith(`${root}${path.sep}`))) return;
+		hash.update(`${file}\0`);
+		try {
+			if ((await fs.stat(file)).isDirectory()) {
+				const real = await fs.realpath(file);
+				if (visited.has(real)) return;
+				visited.add(real);
+				const entries = await fs.readdir(file, { withFileTypes: true });
+				for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) if (!excludedDirectories.has(entry.name)) await visit(path.join(file, entry.name));
+			} else hash.update(await fs.readFile(file));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			hash.update("missing");
+		}
+		hash.update("\0");
+	};
+	for (const file of [...new Set(paths)].sort()) await visit(path.resolve(file));
+	return hash.digest("hex");
+}
+//#endregion
 //#region src/testArtifact.ts
 let pendingBuild = Promise.resolve();
+const artifactInputs = /* @__PURE__ */ new WeakMap();
 function enqueueBuild(task) {
 	const result = pendingBuild.then(task, task);
 	pendingBuild = result.then(() => void 0, () => void 0);
 	return result;
 }
-function resolveTestOutDir(cwd, outDir) {
-	return path.resolve(cwd, outDir ?? ".weapp-vite/test-artifacts");
+async function isTestArtifactCurrent(artifact) {
+	const inputs = artifactInputs.get(artifact);
+	return inputs !== void 0 && inputs.fingerprint === await fingerprintPaths(inputs.paths);
 }
 async function buildTestArtifact(options = {}) {
 	return await enqueueBuild(async () => {
-		const cwd = path.resolve(options.cwd ?? process.cwd());
-		const outDir = resolveTestOutDir(cwd, options.outDir);
-		const inlineConfig = { build: {
-			emptyOutDir: true,
-			outDir
-		} };
-		const ctx = await createCompilerContext({
-			cwd,
-			mode: options.mode ?? "test",
-			isDev: false,
-			configFile: options.configFile,
-			inlineConfig,
-			outputRoot: outDir,
-			projectConfigPath: options.projectConfigPath,
-			emitDefaultAutoImportOutputs: false,
-			preloadAppEntry: false,
-			syncSupportFiles: false
-		});
-		await ctx.buildService.build({ skipNpm: options.skipNpm });
-		return {
-			appConfigPath: path.join(ctx.configService.outDir, "app.json"),
-			miniprogramRootPath: ctx.configService.outDir,
-			projectPath: cwd,
-			sourceRootPath: ctx.configService.absoluteSrcRoot
-		};
+		const session = new CompilerSession();
+		try {
+			const cwd = path.resolve(options.cwd ?? process.cwd());
+			const outDir = resolveArtifactOutDir(cwd, options);
+			const dependencies = new Set(projectInputFiles(cwd));
+			const discoveredInputs = /* @__PURE__ */ new Map();
+			const inlineConfig = {
+				plugins: [captureWatchDependencies((file) => {
+					dependencies.add(file);
+					if (!discoveredInputs.has(file)) discoveredInputs.set(file, fingerprintPaths([file]));
+				}), {
+					name: "weapp-vite:test-artifact-inputs",
+					generateBundle() {
+						for (const file of this.getModuleIds()) {
+							const clean = (parseLogicalEntryId(file)?.sourceId ?? parseSidecarModuleId(file)?.ownerId ?? file).split("?")[0];
+							if (path.isAbsolute(clean)) {
+								dependencies.add(clean);
+								for (const dependency of session.context.moduleGraphService.getTransformDependencies(clean)) dependencies.add(dependency);
+								for (const dependency of session.context.moduleGraphService.getEntryDependencies(clean)) dependencies.add(dependency.sourceId);
+							}
+						}
+					}
+				}],
+				build: {
+					emptyOutDir: true,
+					outDir
+				}
+			};
+			const ctx = await session.initialize({
+				cwd,
+				mode: options.mode ?? "test",
+				isDev: false,
+				configFile: options.configFile,
+				inlineConfig,
+				outputRoot: outDir,
+				projectConfigPath: options.projectConfigPath,
+				emitDefaultAutoImportOutputs: false,
+				preloadAppEntry: false,
+				syncSupportFiles: false
+			});
+			for (const file of ctx.configService.configFileDependencies ?? []) dependencies.add(file);
+			if (options.projectConfigPath) dependencies.add(path.resolve(cwd, options.projectConfigPath));
+			dependencies.add(ctx.configService.absoluteSrcRoot);
+			const initialInputs = [...dependencies];
+			const before = await fingerprintPaths(initialInputs, [outDir]);
+			await session.run(() => ctx.buildService.build({ skipNpm: options.skipNpm }));
+			const artifact = {
+				appConfigPath: path.join(ctx.configService.outDir, "app.json"),
+				miniprogramRootPath: ctx.configService.outDir,
+				projectPath: cwd,
+				sourceRootPath: ctx.configService.absoluteSrcRoot
+			};
+			const paths = [...dependencies, outDir];
+			const stable = (await Promise.all([...discoveredInputs].map(async ([file, fingerprint]) => await fingerprint === await fingerprintPaths([file])))).every(Boolean) && before === await fingerprintPaths(initialInputs, [outDir]);
+			artifactInputs.set(artifact, {
+				paths,
+				fingerprint: stable ? await fingerprintPaths(paths) : ""
+			});
+			return artifact;
+		} finally {
+			await session.close();
+		}
 	});
 }
 async function watchTestArtifact(options = {}) {
 	let artifact = await buildTestArtifact(options);
 	let closed = false;
 	let scheduled;
-	const rebuild = async () => {
-		if (closed) throw new Error("The weapp-vite test artifact watcher has already closed.");
-		artifact = await buildTestArtifact(options);
-		await options.onRebuilt?.(artifact);
-		return artifact;
+	let active;
+	let dirty = false;
+	let forced = false;
+	let closing;
+	const watchedInputs = () => artifactInputs.get(artifact).paths.filter((file) => file !== artifact.miniprogramRootPath && (file === artifact.sourceRootPath || !file.startsWith(`${artifact.sourceRootPath}${path.sep}`)));
+	let watched = watchedInputs();
+	const watcher = chokidar.watch(watched, {
+		ignoreInitial: true,
+		ignored(file) {
+			if (watched.some((input) => input === file || input.startsWith(`${file}${path.sep}`))) return false;
+			return /[/\\](?:node_modules|\.git|\.weapp-vite)(?:[/\\]|$)/.test(file) || file === artifact.miniprogramRootPath || file.startsWith(`${artifact.miniprogramRootPath}${path.sep}`);
+		}
+	});
+	const requestRebuild = (force) => {
+		if (closed) return Promise.reject(/* @__PURE__ */ new Error("The weapp-vite test artifact watcher has already closed."));
+		dirty = true;
+		forced ||= force;
+		if (!active) active = (async () => {
+			do {
+				dirty = false;
+				const forceBuild = forced;
+				forced = false;
+				if (!forceBuild && await isTestArtifactCurrent(artifact)) continue;
+				if (closed) break;
+				artifact = await buildTestArtifact(options);
+				if (!closed) {
+					const next = watchedInputs();
+					await watcher.unwatch(watched.filter((file) => !next.includes(file)));
+					watched = next;
+					watcher.add(watched);
+					await options.onRebuilt?.(artifact);
+				}
+				if (closed) break;
+			} while (dirty);
+			return artifact;
+		})().finally(() => {
+			active = void 0;
+		});
+		return active;
 	};
 	const scheduleRebuild = () => {
 		if (closed || scheduled) return;
 		scheduled = setTimeout(() => {
 			scheduled = void 0;
-			rebuild().catch((error) => options.onError?.(error));
+			requestRebuild(false).catch((error) => {
+				if (!closed) options.onError?.(error);
+			});
 		}, 20);
 	};
-	const watcher = chokidar.watch(artifact.sourceRootPath, {
-		ignoreInitial: true,
-		ignored: [artifact.miniprogramRootPath]
-	});
 	watcher.on("add", scheduleRebuild);
 	watcher.on("change", scheduleRebuild);
 	watcher.on("unlink", scheduleRebuild);
+	watcher.on("error", (error) => options.onError?.(error));
+	try {
+		await new Promise((resolve, reject) => {
+			watcher.once("ready", resolve);
+			watcher.once("error", reject);
+		});
+		if (!await isTestArtifactCurrent(artifact)) await requestRebuild(false);
+	} catch (error) {
+		closed = true;
+		if (scheduled) clearTimeout(scheduled);
+		await watcher.close();
+		await active?.catch(() => void 0);
+		throw error;
+	}
 	return {
 		get artifact() {
 			return artifact;
 		},
-		async close() {
-			if (closed) return;
+		close() {
+			if (closing) return closing;
 			closed = true;
 			if (scheduled) clearTimeout(scheduled);
-			await watcher.close();
+			closing = (async () => {
+				await watcher.close();
+				await active?.catch(() => void 0);
+			})();
+			return closing;
 		},
-		rebuild
+		rebuild: () => requestRebuild(true)
 	};
 }
 //#endregion
-export { buildTestArtifact, watchTestArtifact };
+export { buildTestArtifact, isTestArtifactCurrent, watchTestArtifact };