weapp-vite 7.5.0 → 7.7.0

package/dist/action-ytG5oFAw.mjs

@@ -0,0 +1,138 @@
+import { r as logger_default } from "./logger-DGn5iEVN.mjs";
+import { o as resolveConfigFile } from "./options-Cz8vZ-0w.mjs";
+import { c as startWeappViteMcpServer, s as resolveWeappMcpConfig } from "./mcp-ovJgl1N9.mjs";
+import { a as inspectMcpClientConfig, i as resolveSupportedMcpClient, n as buildMcpClientConfigPlan, r as formatMcpQuickStart, t as writeMcpClientConfig } from "./mcpClient-C8JzVZ46.mjs";
+import process from "node:process";
+import path from "pathe";
+import { runWithSuspendedSharedInput } from "weapp-ide-cli";
+import { createInterface } from "node:readline/promises";
+// src/cli/commands/mcp/action.ts
+function resolvePort(port) {
+	if (typeof port === "number" && Number.isInteger(port)) return port;
+	if (typeof port === "string" && port.trim()) {
+		const parsed = Number.parseInt(port, 10);
+		if (Number.isInteger(parsed)) return parsed;
+	}
+}
+async function resolveHttpUrl(options) {
+	if (options.url?.trim()) return options.url.trim();
+	const workspaceRoot = options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd();
+	const originalCwd = process.cwd();
+	try {
+		if (workspaceRoot !== originalCwd) process.chdir(workspaceRoot);
+		const configFile = resolveConfigFile(options);
+		const { loadConfig } = await import("./loadConfig-D4WGJcYp.mjs");
+		const loaded = await loadConfig(configFile);
+		const resolved = resolveWeappMcpConfig(loaded?.config?.weapp?.mcp);
+		return `http://${resolved.host}:${resolved.port}${resolved.endpoint}`;
+	} catch {
+		const resolved = resolveWeappMcpConfig(void 0);
+		return `http://${resolved.host}:${resolved.port}${resolved.endpoint}`;
+	} finally {
+		if (process.cwd() !== originalCwd) process.chdir(originalCwd);
+	}
+}
+async function confirmWrite() {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+	return await runWithSuspendedSharedInput(async () => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		try {
+			const normalized = (await rl.question("是否写入配置文件？(Y/n) ")).trim().toLowerCase();
+			return normalized === "" || normalized === "y" || normalized === "yes";
+		} finally {
+			rl.close();
+		}
+	});
+}
+function resolveClientTransport(transport) {
+	return transport === "http" ? "http" : "command";
+}
+async function handlePrint(clientName, options, write = false) {
+	const client = resolveSupportedMcpClient(clientName);
+	const workspaceRoot = options.workspaceRoot ?? process.cwd();
+	const transport = resolveClientTransport(options.transport);
+	const httpUrl = transport === "http" ? await resolveHttpUrl(options) : void 0;
+	const plan = buildMcpClientConfigPlan({
+		client,
+		transport,
+		url: httpUrl,
+		workspaceRoot
+	});
+	logger_default.info(`${plan.target.displayName} 配置文件：${plan.target.configPath}`);
+	logger_default.info(`服务器名称：${plan.target.serverName}`);
+	process.stdout.write(`${plan.preview}\n`);
+	if (!write) return;
+	if (options.yes || await confirmWrite()) {
+		await writeMcpClientConfig(plan);
+		logger_default.success(`已写入 ${plan.target.displayName} MCP 配置。`);
+		logger_default.info(`请重启 ${plan.target.displayName}，然后执行：wv mcp doctor ${client}`);
+		return;
+	}
+	logger_default.info("已取消写入。");
+}
+async function handleDoctor(clientName, options) {
+	const client = resolveSupportedMcpClient(clientName);
+	const result = await inspectMcpClientConfig({
+		client,
+		workspaceRoot: options.workspaceRoot ?? process.cwd()
+	});
+	logger_default.info(`${result.displayName} 配置文件：${result.configPath}`);
+	logger_default.info(`服务器名称：${result.serverName}`);
+	if (!result.configExists || result.issues.length > 0) {
+		for (const issue of result.issues) logger_default.warn(issue);
+		throw new Error("MCP 客户端配置检查未通过。");
+	}
+	if (result.transport) logger_default.info(`传输模式：${result.transport}`);
+	if (result.httpReachable !== void 0) logger_default.info(`HTTP 服务可达：${result.httpReachable ? "是" : "否"}`);
+	logger_default.success("MCP 客户端配置检查通过。");
+}
+async function handleServer(options) {
+	const resolvedTransport = options.transport === "http" ? "streamable-http" : options.transport === "command" ? void 0 : options.transport;
+	const handle = await startWeappViteMcpServer({
+		endpoint: options.endpoint,
+		host: options.host,
+		port: resolvePort(options.port),
+		restEndpoint: options.rest === false ? false : options.restEndpoint,
+		transport: resolvedTransport,
+		unref: options.unref,
+		workspaceRoot: options.workspaceRoot
+	});
+	const shutdown = async () => {
+		process.off("SIGINT", shutdown);
+		process.off("SIGTERM", shutdown);
+		process.stdin.off("end", shutdown);
+		await handle.close?.();
+	};
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	if (resolvedTransport !== "streamable-http") process.stdin.once("end", shutdown);
+	for (const line of formatMcpQuickStart({
+		httpUrl: resolvedTransport === "streamable-http" ? `http://${options.host ?? "127.0.0.1"}:${resolvePort(options.port) ?? 3088}${options.endpoint ?? "/mcp"}` : void 0,
+		transport: resolvedTransport === "streamable-http" ? "http" : "command"
+	})) logger_default.info(line);
+}
+/** 执行 MCP 子命令，注册与帮助阶段不加载服务依赖。 */
+async function runMcpCommand(args, options) {
+	const [subcommand, client] = args;
+	if (subcommand === "init") {
+		if (!client) throw new Error("缺少客户端名称，请使用：wv mcp init <codex|claude-code|cursor>");
+		await handlePrint(client, options, true);
+		return;
+	}
+	if (subcommand === "print") {
+		if (!client) throw new Error("缺少客户端名称，请使用：wv mcp print <codex|claude-code|cursor>");
+		await handlePrint(client, options, false);
+		return;
+	}
+	if (subcommand === "doctor") {
+		if (!client) throw new Error("缺少客户端名称，请使用：wv mcp doctor <codex|claude-code|cursor>");
+		await handleDoctor(client, options);
+		return;
+	}
+	if (subcommand) throw new Error(`未知的 mcp 子命令：${subcommand}`);
+	await handleServer(options);
+}
+export { runMcpCommand };

package/dist/action-zmJrU8PC.mjs

@@ -0,0 +1,245 @@
+import { c as getBackendForCapability, n as formatBytes, u as CompilerSession } from "./createCompilerContextInstance-BXSdH2E8.mjs";
+import { r as logger_default, t as colors } from "./logger-DGn5iEVN.mjs";
+import { i as resolveRuntimeTargets, n as logRuntimeTarget, r as resolveConfiguredRuntimeTargets, t as createInlineConfig } from "./runtime-CKtMVERT.mjs";
+import { i as resolveIdeProjectPath, n as openIde } from "./openIde-QoYKhuuM.mjs";
+import { a as parseDashboardUiHost, i as isUiEnabled, o as resolveConfigFile, r as filterDuplicateOptions } from "./options-Cz8vZ-0w.mjs";
+import { n as formatDuration, r as scheduleCompletedProductionBuildExit, t as logBuildAppFinish } from "./logBuildAppFinish-DOBoof6S.mjs";
+import { n as createDashboardArtifactSnapshot } from "./artifacts-TrTX9_jj.mjs";
+import { i as startAnalyzeDashboard, n as writeAnalyzeHistorySnapshot, r as analyzeSubpackages, t as readLatestAnalyzeHistorySnapshot } from "./history-dKxzoHmN.mjs";
+import { t as setCommandNodeEnv } from "./nodeEnv-zq1EymWj.mjs";
+import { a as resolveBuildUploadOptions } from "./report-PJVyo-UZ.mjs";
+import { a as prepareAutoUploadMetadataWithRollback, n as executeUploadTarget, o as validateAutoUploadMetadata, t as createUploadTarget } from "./builtProject-B145uOt5.mjs";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+const WINDOWS_SEPARATOR_RE = /\\/g;
+function normalizeFileName(fileName) {
+	return fileName.replace(WINDOWS_SEPARATOR_RE, "/");
+}
+function getOutputItemBytes(item) {
+	if (item.type === "chunk") return typeof item.code === "string" ? Buffer.byteLength(item.code, "utf8") : 0;
+	if (typeof item.source === "string") return Buffer.byteLength(item.source, "utf8");
+	if (item.source instanceof Uint8Array) return item.source.byteLength;
+	return 0;
+}
+function resolveSubPackageRoot(fileName, roots) {
+	const normalized = normalizeFileName(fileName);
+	return roots.find((root) => normalized === root || normalized.startsWith(`${root}/`));
+}
+function collectPackageSizeReports(output, subPackageMap) {
+	const outputs = Array.isArray(output) ? output : [output];
+	const roots = [...subPackageMap?.keys() ?? []].filter(Boolean).sort((a, b) => b.length - a.length || a.localeCompare(b));
+	const packageBytes = /* @__PURE__ */ new Map([["__main__", 0]]);
+	for (const root of roots) packageBytes.set(root, 0);
+	for (const current of outputs) for (const item of current.output ?? []) {
+		const root = resolveSubPackageRoot(item.fileName, roots) ?? "__main__";
+		packageBytes.set(root, (packageBytes.get(root) ?? 0) + getOutputItemBytes(item));
+	}
+	const reports = [{
+		root: "__main__",
+		label: "主包",
+		bytes: packageBytes.get("__main__") ?? 0
+	}];
+	for (const root of roots) {
+		const meta = subPackageMap?.get(root);
+		const isIndependent = Boolean(meta?.subPackage.independent);
+		reports.push({
+			root,
+			label: `${isIndependent ? "独立分包" : "分包"} ${root}`,
+			bytes: packageBytes.get(root) ?? 0
+		});
+	}
+	return reports;
+}
+function logBuildPackageSizeReport(options) {
+	const warningBytes = Number(options.warningBytes ?? 2097152);
+	const reports = collectPackageSizeReports(options.output, options.subPackageMap);
+	logger_default.success("主包/分包体积报告：");
+	for (const report of reports) logger_default.info(`${report.label}：${formatBytes(report.bytes)}`);
+	if (!(Number.isFinite(warningBytes) && warningBytes > 0)) return;
+	for (const report of reports) {
+		if (report.bytes <= warningBytes) continue;
+		logger_default.warn(`[包体积] ${colors.yellow(report.label)} 体积 ${colors.yellow(formatBytes(report.bytes))}，已超过阈值 ${colors.yellow(formatBytes(warningBytes))}。`);
+	}
+}
+// src/cli/commands/build/action.ts
+function emitDashboardEvents(handle, events) {
+	handle?.emitRuntimeEvents(events);
+}
+function normalizeBuildSourcemap(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value;
+}
+function normalizeBuildMinify(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value;
+}
+function hasCliOption(options, key) {
+	return Object.prototype.hasOwnProperty.call(options, key);
+}
+function createBuildInlineConfig(options) {
+	const build = {};
+	if (typeof options.outDir === "string") build.outDir = options.outDir;
+	if (hasCliOption(options, "sourcemap")) build.sourcemap = normalizeBuildSourcemap(options.sourcemap);
+	if (hasCliOption(options, "minify")) build.minify = normalizeBuildMinify(options.minify);
+	if (typeof options.emptyOutDir === "boolean") build.emptyOutDir = options.emptyOutDir;
+	return Object.keys(build).length ? { build } : void 0;
+}
+/** 执行已完成参数校验的生产构建，复用注册器持有的原始命令参数。 */
+async function runBuildCommand(cli, root, options) {
+	let analyzeHandle;
+	let session;
+	let ctx;
+	let targets;
+	let uploadMetadataRollback;
+	let buildCompleted = false;
+	let buildFailed = false;
+	try {
+		options = { ...options };
+		filterDuplicateOptions(options);
+		options.uiHost = parseDashboardUiHost(options.uiHost);
+		let uploadOptions = resolveBuildUploadOptions(cli, options);
+		setCommandNodeEnv("production");
+		const cwd = root ?? process.cwd();
+		const configFile = resolveConfigFile(options);
+		targets = resolveRuntimeTargets(options);
+		if (uploadOptions) validateAutoUploadMetadata(uploadOptions, "upload");
+		if (uploadOptions && !getBackendForCapability(targets, "miniprogram", "build")) throw new Error("--upload 仅支持包含小程序目标的构建，不能用于纯 Web 构建。");
+		const inlineConfig = createInlineConfig(targets, {
+			scope: options.scope,
+			inlineConfig: createBuildInlineConfig(options)
+		});
+		if (uploadOptions) {
+			const prepared = await prepareAutoUploadMetadataWithRollback(cwd, uploadOptions, "upload");
+			uploadOptions = prepared.options;
+			uploadMetadataRollback = prepared.rollback;
+		}
+		session = new CompilerSession();
+		ctx = await session.initialize({
+			cwd,
+			mode: options.mode ?? "production",
+			configFile,
+			inlineConfig,
+			cliPlatform: targets.rawPlatform,
+			projectConfigPath: options.projectConfig,
+			emitDefaultAutoImportOutputs: false,
+			preloadAppEntry: false
+		});
+		targets = resolveConfiguredRuntimeTargets(targets, ctx.configService.options?.sourceConfig?.weapp?.platform);
+		if (uploadOptions && !getBackendForCapability(targets, "miniprogram", "build")) {
+			await uploadMetadataRollback?.();
+			uploadMetadataRollback = void 0;
+			throw new Error("--upload 仅支持包含小程序目标的构建，不能用于纯 Web 构建。");
+		}
+		uploadMetadataRollback = void 0;
+		for (const backend of targets.select("build")) session.onClose(() => backend.driver.close(ctx));
+		const { configService } = ctx;
+		const uploadTarget = uploadOptions ? await createUploadTarget(configService, uploadOptions, "upload") : void 0;
+		const miniBackend = getBackendForCapability(targets, "miniprogram", "build");
+		const webBackend = getBackendForCapability(targets, "web", "build");
+		logRuntimeTarget(targets, { resolvedConfigPlatform: configService.platform });
+		const enableAnalyze = Boolean(isUiEnabled(options) && miniBackend);
+		for (const backend of targets.select("build")) {
+			if (backend.descriptor.id === "miniprogram") {
+				const miniBuildStartedAt = Date.now();
+				const output = await session.run(() => backend.driver.build(ctx, options));
+				const miniBuildDurationMs = Date.now() - miniBuildStartedAt;
+				logger_default.success(`小程序构建完成，耗时：${colors.green(formatDuration(miniBuildDurationMs))}`);
+				if (!Array.isArray(output) && "output" in output) logBuildPackageSizeReport({
+					output,
+					subPackageMap: ctx.scanService?.subPackageMap,
+					warningBytes: configService.weappViteConfig.packageSizeWarningBytes
+				});
+				if (enableAnalyze) {
+					const analyzeStartedAt = Date.now();
+					const previousAnalyzeResult = await readLatestAnalyzeHistorySnapshot(configService);
+					const artifactSnapshot = createDashboardArtifactSnapshot();
+					const analyzeResult = await analyzeSubpackages(ctx, { onArtifact: artifactSnapshot.capture });
+					await writeAnalyzeHistorySnapshot(analyzeResult, configService);
+					const analyzeDurationMs = Date.now() - analyzeStartedAt;
+					analyzeHandle = await startAnalyzeDashboard(analyzeResult, {
+						watch: true,
+						uiHost: options.uiHost,
+						artifacts: artifactSnapshot.files,
+						cwd: configService.cwd,
+						packageManagerAgent: configService.packageManager.agent,
+						pluginRoot: configService.absolutePluginRoot,
+						srcRoot: configService.absoluteSrcRoot,
+						previousResult: previousAnalyzeResult,
+						initialEvents: [{
+							kind: "build",
+							level: "success",
+							title: "mini build completed",
+							detail: `生产构建已完成，当前 analyze 结果包含 ${analyzeResult.packages.length} 个包。`,
+							durationMs: miniBuildDurationMs,
+							tags: ["build", "mini"]
+						}, {
+							kind: "build",
+							level: "success",
+							title: "analyze completed",
+							detail: `分析已完成，当前包含 ${analyzeResult.packages.length} 个包与 ${analyzeResult.modules.length} 个模块。`,
+							durationMs: analyzeDurationMs,
+							tags: ["build", "analyze"]
+						}]
+					}) ?? void 0;
+				}
+				continue;
+			}
+			const webConfig = configService.weappWebConfig;
+			if (backend.descriptor.id !== "web" || !webConfig?.enabled) continue;
+			const webBuildStartedAt = Date.now();
+			try {
+				await session.run(() => backend.driver.build(ctx, options));
+				const webBuildDurationMs = Date.now() - webBuildStartedAt;
+				logger_default.success(`Web 构建完成，输出目录：${colors.green(configService.relativeCwd(webConfig.outDir))}，耗时：${colors.green(formatDuration(webBuildDurationMs))}`);
+				emitDashboardEvents(analyzeHandle, [{
+					kind: "build",
+					level: "success",
+					title: "web build completed",
+					detail: `Web 构建已完成，输出目录 ${configService.relativeCwd(webConfig.outDir)}。`,
+					durationMs: webBuildDurationMs,
+					tags: ["build", "web"]
+				}]);
+			} catch (error) {
+				emitDashboardEvents(analyzeHandle, [{
+					kind: "diagnostic",
+					level: "error",
+					title: "web build failed",
+					detail: error instanceof Error ? error.message : String(error),
+					durationMs: Date.now() - webBuildStartedAt,
+					tags: ["build", "web"]
+				}]);
+				logger_default.error(error);
+				throw error;
+			}
+		}
+		if (uploadTarget && uploadOptions) await executeUploadTarget(uploadTarget, uploadOptions, "upload");
+		if (miniBackend) logBuildAppFinish(configService, void 0, { skipWeb: !webBackend });
+		if (options.open && getBackendForCapability(targets, "miniprogram", "ide")) {
+			emitDashboardEvents(analyzeHandle, [{
+				kind: "command",
+				level: "info",
+				title: "opening ide",
+				detail: "构建完成后准备打开 IDE 项目。",
+				tags: ["ide", "open"]
+			}]);
+			const generatedProjectConfig = configService.multiPlatform.projectConfigs !== void 0;
+			await openIde(configService.platform, resolveIdeProjectPath(generatedProjectConfig ? configService.outDir : configService.mpDistRoot, generatedProjectConfig), {
+				openRecovery: options.openRecovery,
+				trustProject: options.trustProject,
+				openStrategy: options.ideOpenStrategy
+			});
+		}
+		if (analyzeHandle) await analyzeHandle.waitForExit();
+		buildCompleted = true;
+	} catch (error) {
+		buildFailed = true;
+		throw error;
+	} finally {
+		if (buildFailed) await session?.close().catch((error) => logger_default.error(error));
+		else await session?.close();
+		if (buildCompleted) scheduleCompletedProductionBuildExit(options, analyzeHandle);
+	}
+}
+export { runBuildCommand };

package/dist/{analyze-ZJUvEdaY.mjs → analyze-DCZo-sJd.mjs}

@@ -1,68 +1,4 @@
-//#region src/analyze/subpackages/artifacts/category.ts
-function isRuntimeCategory(category) {
-	return category === "runtime" || category === "reactivity" || category === "host" || category === "helper";
-}
-//#endregion
-//#region src/analyze/subpackages/budget.ts
-const defaultBudgets = {
-	totalBytes: 20971520,
-	mainBytes: 2097152,
-	subPackageBytes: 2097152,
-	independentBytes: 2097152,
-	warningRatio: .85,
-	source: "default"
-};
-function createAnalyzeBudgetCheck(result) {
-	const budgets = result.metadata?.budgets ?? defaultBudgets;
-	const createItem = (options, unknown = false) => {
-		const ratio = options.limitBytes > 0 ? options.currentBytes / options.limitBytes : options.currentBytes > 0 ? 1 : 0;
-		return {
-			...options,
-			ratio,
-			status: unknown ? "unknown" : ratio >= 1 ? "exceeded" : ratio >= budgets.warningRatio ? "warning" : "ok"
-		};
-	};
-	const files = result.packages.flatMap((pkg) => pkg.files);
-	const unique = new Map(files.map((file) => [file.file, file]));
-	const sizeUnknown = (items) => items.some((file) => typeof file.size !== "number" || !Number.isFinite(file.size) || file.size < 0);
-	const items = [createItem({
-		id: "__total__",
-		label: "总包",
-		scope: "total",
-		currentBytes: [...unique.values()].reduce((sum, file) => sum + (file.size ?? 0), 0),
-		limitBytes: budgets.totalBytes,
-		measurement: "file-bytes",
-		files: [...unique.keys()].sort()
-	}, sizeUnknown(files))];
-	for (const pkg of result.packages) {
-		const limitBytes = budgets.packageBytes?.[pkg.id] ?? (pkg.type === "main" ? budgets.mainBytes : pkg.type === "subPackage" ? budgets.subPackageBytes : pkg.type === "independent" ? budgets.independentBytes : void 0);
-		if (limitBytes === void 0) continue;
-		items.push(createItem({
-			id: pkg.id,
-			label: pkg.label,
-			scope: pkg.type,
-			currentBytes: pkg.files.reduce((sum, file) => sum + (file.size ?? 0), 0),
-			limitBytes,
-			measurement: "file-bytes",
-			files: pkg.files.map((file) => file.file).sort()
-		}, sizeUnknown(pkg.files)));
-	}
-	if (budgets.runtimeBytes !== void 0) {
-		const artifacts = result.artifacts;
-		items.push(createItem({
-			id: "__runtime__",
-			label: "Runtime（含混合 chunk 的文件上界）",
-			scope: "runtime",
-			currentBytes: artifacts?.runtime.upperBoundBytes ?? 0,
-			limitBytes: budgets.runtimeBytes,
-			measurement: artifacts ? "upper-bound" : "unavailable",
-			files: artifacts?.files.filter((file) => artifacts.runtime.unknownFiles.includes(file.file) || file.modules.some((module) => isRuntimeCategory(module.category))).map((file) => file.file) ?? files.filter((file) => file.type === "chunk" || /\.[cm]?js$/i.test(file.file)).map((file) => file.file)
-		}, !artifacts || artifacts.runtime.unknownFiles.length > 0));
-	}
-	return items.sort((a, b) => b.ratio - a.ratio || a.label.localeCompare(b.label));
-}
-//#endregion
-//#region src/dashboard/analyze/comparison.ts
+// src/dashboard/analyze/comparison.ts
 function createModuleComparisonKey(source, sourceType) {
 	const origin = sourceType === "node_modules" || sourceType === "workspace" ? "dependency" : sourceType;
 	const queryIndex = source.indexOf("?");
@@ -205,16 +141,14 @@ function createAnalyzeComparison(current, previous) {
 		modules: compareSizeMaps(currentMaps.modules, previousMaps.modules)
 	};
 }
-//#endregion
-//#region src/dashboard/analyze/moduleBytes.ts
+// src/dashboard/analyze/moduleBytes.ts
 /** 取每个原始模块 ID 的最大已知贡献，缺少产物贡献时使用原始体积。 */
 function createModuleByteMap(result) {
 	const bytes = /* @__PURE__ */ new Map();
 	for (const pkg of result.packages) for (const file of pkg.files) for (const mod of file.modules ?? []) bytes.set(mod.id, Math.max(bytes.get(mod.id) ?? 0, mod.bytes ?? mod.originalBytes ?? 0));
 	return bytes;
 }
-//#endregion
-//#region src/dashboard/analyze/duplicates.ts
+// src/dashboard/analyze/duplicates.ts
 function createDuplicateAdvice(sourceType, hasIndependentPackage, estimatedSavingBytes) {
 	if (hasIndependentPackage) return estimatedSavingBytes > 0 ? "含独立分包，先确认隔离要求，再评估是否抽公共入口。" : "含独立分包，重复可能来自隔离边界。";
 	if (sourceType === "node_modules") return "依赖被多个包带入，检查引用边界或考虑主包公共入口。";
@@ -244,5 +178,4 @@ function createDuplicateModuleInsights(result) {
 		};
 	}).sort((a, b) => b.estimatedSavingBytes - a.estimatedSavingBytes || b.packageCount - a.packageCount || b.bytes - a.bytes || a.source.localeCompare(b.source) || a.id.localeCompare(b.id));
 }
-//#endregion
-export { isRuntimeCategory as a, createAnalyzeBudgetCheck as i, createModuleByteMap as n, createAnalyzeComparison as r, createDuplicateModuleInsights as t };
+export { createModuleByteMap as n, createAnalyzeComparison as r, createDuplicateModuleInsights as t };

package/dist/artifacts-TrTX9_jj.mjs

@@ -0,0 +1,104 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "pathe";
+import fs from "node:fs";
+import { Buffer } from "node:buffer";
+// src/dashboard/assets.ts
+const ANALYZE_DASHBOARD_PACKAGE_NAME = "@weapp-vite/dashboard";
+const require = createRequire(import.meta.url);
+function parseDashboardManifest(source) {
+	const parsed = JSON.parse(source);
+	const metadata = parsed && typeof parsed === "object" && "weappViteDashboard" in parsed ? parsed.weappViteDashboard : void 0;
+	if (!metadata || typeof metadata !== "object") return;
+	return { weappViteDashboard: {
+		devConfigFile: "devConfigFile" in metadata && typeof metadata.devConfigFile === "string" ? metadata.devConfigFile : void 0,
+		devRoot: "devRoot" in metadata && typeof metadata.devRoot === "string" ? metadata.devRoot : void 0,
+		distDir: "distDir" in metadata && typeof metadata.distDir === "string" ? metadata.distDir : void 0
+	} };
+}
+function resolveDashboardPackage(cwd) {
+	const resolvePaths = cwd && cwd !== process.cwd() ? [cwd, process.cwd()] : cwd ? [cwd] : void 0;
+	try {
+		const packageJsonPath = require.resolve(`${ANALYZE_DASHBOARD_PACKAGE_NAME}/package.json`, { paths: resolvePaths });
+		let manifest;
+		try {
+			manifest = parseDashboardManifest(fs.readFileSync(packageJsonPath, "utf8"));
+		} catch {
+			manifest = void 0;
+		}
+		return {
+			root: path.dirname(packageJsonPath),
+			manifest,
+			packageJsonPath
+		};
+	} catch {
+		return;
+	}
+}
+function resolveDashboardDistRoot(packageRoot, manifest) {
+	const root = path.resolve(packageRoot, manifest?.weappViteDashboard?.distDir ?? "dist");
+	return fs.existsSync(path.join(root, "index.html")) ? { root } : void 0;
+}
+function resolveDashboardDevRoot(packageRoot, manifest) {
+	const devRoot = manifest?.weappViteDashboard?.devRoot;
+	const devConfigFile = manifest?.weappViteDashboard?.devConfigFile;
+	if (!devRoot || !devConfigFile) return;
+	const root = path.resolve(packageRoot, devRoot);
+	const configFile = path.resolve(root, devConfigFile);
+	return fs.existsSync(root) && fs.existsSync(configFile) ? {
+		root,
+		configFile
+	} : void 0;
+}
+/** 同一次解析绑定 Dashboard 资源目录及其传输依赖的安装所有者。 */
+function resolveDashboardInstallation(options) {
+	const resolved = resolveDashboardPackage(options.cwd);
+	if (!resolved) return;
+	const assets = options.watch ? resolveDashboardDevRoot(resolved.root, resolved.manifest) ?? resolveDashboardDistRoot(resolved.root, resolved.manifest) : resolveDashboardDistRoot(resolved.root, resolved.manifest) ?? resolveDashboardDevRoot(resolved.root, resolved.manifest);
+	return assets ? {
+		...assets,
+		packageJsonPath: resolved.packageJsonPath
+	} : void 0;
+}
+/** 定位可选仪表盘包的原生构建 SPA；未安装或尚未构建时返回 undefined。 */
+function resolveDashboardClientAssets(cwd) {
+	const resolved = resolveDashboardPackage(cwd);
+	return resolved ? resolveDashboardDistRoot(resolved.root, resolved.manifest)?.root : void 0;
+}
+// src/dashboard/artifacts.ts
+const MAX_DASHBOARD_FILE_CONTENT_BYTES = 2097152;
+/** 保留同一次分析的产物内容，不读取或改写开发构建目录。 */
+function createDashboardArtifactSnapshot() {
+	const files = /* @__PURE__ */ new Map();
+	let retainedBytes = 0;
+	return {
+		files,
+		capture(fileName, source) {
+			const key = fileName.replaceAll("\\", "/");
+			const previous = files.get(key);
+			if (previous?.content !== void 0) retainedBytes -= previous.size;
+			const size = typeof source === "string" ? Buffer.byteLength(source, "utf8") : source.byteLength;
+			if (size > 2097152) {
+				files.set(key, {
+					size,
+					error: `文件超过 ${MAX_DASHBOARD_FILE_CONTENT_BYTES} 字节，已拒绝读取。`
+				});
+				return;
+			}
+			if (retainedBytes + size > 33554432) {
+				files.set(key, {
+					size,
+					error: "分析产物内容超过快照容量上限，已拒绝读取。"
+				});
+				return;
+			}
+			const content = typeof source === "string" ? source : Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString("utf8");
+			files.set(key, {
+				content,
+				size
+			});
+			retainedBytes += size;
+		}
+	};
+}
+export { resolveDashboardInstallation as a, resolveDashboardClientAssets as i, createDashboardArtifactSnapshot as n, ANALYZE_DASHBOARD_PACKAGE_NAME as r, MAX_DASHBOARD_FILE_CONTENT_BYTES as t };