weapp-vite 7.4.0 → 7.6.0

package/dist/action-DlC6JYpt.mjs

@@ -0,0 +1,95 @@
+import { r as logger_default } from "./logger-DGn5iEVN.mjs";
+import { t as createCompilerContext } from "./createContext-tApLtII-.mjs";
+import { i as resolveRuntimeTargets, t as createInlineConfig } from "./runtime-CLUhQsdA.mjs";
+import { o as resolveConfigFile, r as filterDuplicateOptions } from "./options-jqFwfD1G.mjs";
+import { t as setCommandNodeEnv } from "./nodeEnv-BmH8UZPR.mjs";
+import { o as resolveUploadTimeout, t as UploadCommandError } from "./report-hyonPGbZ.mjs";
+import { n as resolveUploadPlatforms } from "./upload-DozK8UdN.mjs";
+import { t as terminateStaleSassEmbeddedProcess } from "./processCleanup-BQn2kTcK.mjs";
+import { i as prepareAutoUploadMetadata, n as executeUploadTarget, r as UploadExecutionError, t as createUploadTarget } from "./builtProject-C29udgXY.mjs";
+import process from "node:process";
+import path from "node:path";
+//#region src/cli/commands/upload/action.ts
+async function buildUploadTarget(cwd, platform, options, action, item) {
+	const targets = resolveRuntimeTargets({ platform });
+	const ctx = await createCompilerContext({
+		cwd,
+		mode: options.mode ?? "production",
+		configFile: resolveConfigFile(options),
+		inlineConfig: createInlineConfig(targets),
+		cliPlatform: platform,
+		projectConfigPath: options.projectConfig,
+		emitDefaultAutoImportOutputs: false,
+		preloadAppEntry: false
+	});
+	try {
+		const target = await createUploadTarget(ctx.configService, options, action);
+		if (item) {
+			item.platform = target.platform;
+			item.requestedVersion = target.context.version;
+			item.stage = "build";
+		}
+		logger_default.info(`[${action}:${target.platform}] 构建${target.context.version ? ` ${target.context.version}` : ""}`);
+		await ctx.buildService.build({});
+		return target;
+	} finally {
+		ctx.watcherService.closeAll();
+		terminateStaleSassEmbeddedProcess();
+	}
+}
+async function runUploadCommand(root, options, action = "upload") {
+	filterDuplicateOptions(options);
+	const platforms = resolveUploadPlatforms(options.platform ?? options.p);
+	setCommandNodeEnv("production");
+	const cwd = path.resolve(root ?? process.cwd());
+	if (action === "preview") {
+		options = await prepareAutoUploadMetadata(cwd, options, action);
+		for (const platform of platforms) {
+			const target = await buildUploadTarget(cwd, platform, options, action);
+			await executeUploadTarget(target, options, action);
+		}
+		return;
+	}
+	const report = {
+		schemaVersion: 1,
+		action: "upload",
+		status: "success",
+		results: platforms.map((platform) => ({
+			platform: platform ?? null,
+			stage: "prepare",
+			status: "not-run"
+		}))
+	};
+	let active = report.results[0];
+	try {
+		const timeoutMs = resolveUploadTimeout(options.timeout);
+		options = await prepareAutoUploadMetadata(cwd, options, action);
+		for (const item of report.results) item.requestedVersion = options.uv?.trim();
+		for (const [index, platform] of platforms.entries()) {
+			active = report.results[index];
+			const target = await buildUploadTarget(cwd, platform, options, action, active);
+			active.stage = "validate";
+			const result = await executeUploadTarget(target, options, action, {
+				timeoutMs,
+				onUpload: () => {
+					active.stage = "upload";
+				}
+			});
+			active.status = options.dryRun ? "dry-run" : "success";
+			if (!options.dryRun) active.result = result;
+		}
+		return report;
+	} catch (error) {
+		report.status = "failed";
+		report.error = error instanceof Error ? error.message : String(error);
+		active.status = "failed";
+		active.error = report.error;
+		if (error instanceof UploadExecutionError) {
+			active.remoteOutcome = error.remoteOutcome;
+			if (error.remoteOutcome === "unknown" && error.reason !== "failed") active.status = "unknown";
+		}
+		throw new UploadCommandError(report);
+	}
+}
+//#endregion
+export { runUploadCommand };

package/dist/action-zEDY7oh_.mjs

@@ -0,0 +1,247 @@
+import { c as getBackendForCapability, n as formatBytes, u as CompilerSession } from "./createCompilerContextInstance-aYwi8wQt.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-CLUhQsdA.mjs";
+import { i as resolveIdeProjectPath, n as openIde } from "./openIde-CroqOgk5.mjs";
+import { a as parseDashboardUiHost, i as isUiEnabled, o as resolveConfigFile, r as filterDuplicateOptions } from "./options-jqFwfD1G.mjs";
+import { n as formatDuration, r as scheduleCompletedProductionBuildExit, t as logBuildAppFinish } from "./logBuildAppFinish-ChjwATMv.mjs";
+import { n as createDashboardArtifactSnapshot } from "./artifacts-BOyC9Fy-.mjs";
+import { i as startAnalyzeDashboard, n as writeAnalyzeHistorySnapshot, r as analyzeSubpackages, t as readLatestAnalyzeHistorySnapshot } from "./history-BIiRCzbq.mjs";
+import { t as setCommandNodeEnv } from "./nodeEnv-BmH8UZPR.mjs";
+import { a as resolveBuildUploadOptions } from "./report-hyonPGbZ.mjs";
+import { a as prepareAutoUploadMetadataWithRollback, n as executeUploadTarget, o as validateAutoUploadMetadata, t as createUploadTarget } from "./builtProject-C29udgXY.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))}。`);
+	}
+}
+//#endregion
+//#region 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);
+	}
+}
+//#endregion
+export { runBuildCommand };

package/dist/adapters-CcHrsYaj.mjs

@@ -0,0 +1 @@
+export { MINI_PROGRAM_PLATFORM_DESCRIPTORS as t } from "@weapp-core/shared";

package/dist/analyze-DN79YOAH.mjs

@@ -0,0 +1,184 @@
+//#region src/dashboard/analyze/comparison.ts
+function createModuleComparisonKey(source, sourceType) {
+	const origin = sourceType === "node_modules" || sourceType === "workspace" ? "dependency" : sourceType;
+	const queryIndex = source.indexOf("?");
+	let canonicalSource = (queryIndex === -1 ? source : source.slice(0, queryIndex)).replaceAll("\\", "/").replace(/^\0/, "");
+	if (origin === "dependency") {
+		const nodeModulesIndex = canonicalSource.lastIndexOf("/node_modules/");
+		if (nodeModulesIndex >= 0) canonicalSource = canonicalSource.slice(nodeModulesIndex + 14);
+		else if (canonicalSource.startsWith("node_modules/")) canonicalSource = canonicalSource.slice(13);
+		else if (sourceType === "workspace") canonicalSource = (canonicalSource.match(/(?:^|\/)packages-runtime\/(wevu\/.*)$/) ?? canonicalSource.match(/(?:^|\/)(@[^/]+\/[^/]+\/dist\/.*)$/))?.[1] ?? canonicalSource;
+	}
+	return `${origin}\0${canonicalSource}`;
+}
+function classifyIncrementCategory(source, sourceType) {
+	if (source.includes("wevu") || source.includes("@weapp-vite/dashboard")) return "WeVu / runtime";
+	if (sourceType === "node_modules" || source.includes("node_modules")) return "第三方依赖";
+	if (sourceType === "workspace") return "工作区包";
+	if (sourceType === "plugin") return "插件生成";
+	if (source.endsWith(".wxss") || source.endsWith(".css") || source.endsWith(".scss")) return "样式资源";
+	if (source.endsWith(".wxml") || source.endsWith(".json")) return "页面结构";
+	return "业务源码";
+}
+function createChangeAdvice(category, change) {
+	if (change === "unmeasured") return "缺少体积测量，不能判断增长或缩小。";
+	if (change === "removed" || change === "decreased") return "确认体积减少符合预期，检查受影响页面与依赖边界。";
+	if (category === "第三方依赖") return "检查依赖边界或公共入口。";
+	if (category === "WeVu / runtime") return "排查组件和 API 引用边界。";
+	if (category === "样式资源") return "检查样式复用和生成范围。";
+	return change === "added" ? "确认分包归属和懒加载边界。" : "对比新增引用和共享模块。";
+}
+function createSizeMaps(result) {
+	const packages = /* @__PURE__ */ new Map();
+	const files = /* @__PURE__ */ new Map();
+	const moduleIds = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	let unmeasuredFiles = 0;
+	for (const pkg of result.packages) {
+		let packageBytes = 0;
+		let packageUnmeasuredFiles = 0;
+		for (const file of pkg.files) {
+			const bytes = file.size ?? null;
+			if (bytes === null) packageUnmeasuredFiles += 1;
+			else packageBytes += bytes;
+			const fileKey = `file:${pkg.id}\0${file.file}`;
+			files.set(fileKey, {
+				key: fileKey,
+				label: file.file,
+				bytes,
+				packageId: pkg.id,
+				packageLabel: pkg.label,
+				file: file.file,
+				category: classifyIncrementCategory(file.source ?? file.file)
+			});
+			for (const mod of file.modules ?? []) {
+				const moduleBytes = mod.bytes ?? mod.originalBytes ?? null;
+				const existing = moduleIds.get(mod.id);
+				if (existing) {
+					existing.bytes = existing.bytes === null || moduleBytes === null ? null : Math.max(existing.bytes, moduleBytes);
+					continue;
+				}
+				const queryIndex = mod.source.indexOf("?");
+				moduleIds.set(mod.id, {
+					key: `module:${createModuleComparisonKey(mod.source, mod.sourceType)}`,
+					label: mod.source,
+					bytes: moduleBytes,
+					moduleId: mod.id,
+					sourceType: mod.sourceType,
+					packageId: pkg.id,
+					packageLabel: pkg.label,
+					file: file.file,
+					category: classifyIncrementCategory(queryIndex === -1 ? mod.source : mod.source.slice(0, queryIndex), mod.sourceType)
+				});
+			}
+		}
+		totalBytes += packageBytes;
+		unmeasuredFiles += packageUnmeasuredFiles;
+		const key = `package:${pkg.id}`;
+		packages.set(key, {
+			key,
+			label: pkg.label,
+			bytes: packageUnmeasuredFiles > 0 ? null : packageBytes,
+			packageId: pkg.id,
+			packageLabel: pkg.label
+		});
+	}
+	const modules = /* @__PURE__ */ new Map();
+	for (const mod of moduleIds.values()) {
+		const existing = modules.get(mod.key);
+		if (!existing) modules.set(mod.key, mod);
+		else if (existing.bytes === null || mod.bytes === null) existing.bytes = null;
+		else if (existing.bytes < mod.bytes) modules.set(mod.key, mod);
+	}
+	return {
+		packages,
+		files,
+		modules,
+		totalBytes: unmeasuredFiles > 0 ? null : totalBytes,
+		unmeasuredFiles
+	};
+}
+function compareSizeMaps(current, previous) {
+	const changes = [];
+	const append = (entry, currentBytes, previousBytes, change) => {
+		changes.push({
+			key: entry.key,
+			label: entry.label,
+			packageId: entry.packageId,
+			packageLabel: entry.packageLabel,
+			file: entry.file,
+			moduleId: entry.moduleId,
+			sourceType: entry.sourceType,
+			category: entry.category,
+			change,
+			currentBytes,
+			previousBytes,
+			deltaBytes: currentBytes === null || previousBytes === null ? null : currentBytes - previousBytes,
+			advice: entry.category ? createChangeAdvice(entry.category, change) : void 0
+		});
+	};
+	for (const [key, entry] of current) {
+		const old = previous.get(key);
+		if (!old) append(entry, entry.bytes, 0, "added");
+		else if (entry.bytes === null || old.bytes === null) append(entry, entry.bytes, old.bytes, "unmeasured");
+		else if (entry.bytes !== old.bytes) append(entry, entry.bytes, old.bytes, entry.bytes > old.bytes ? "increased" : "decreased");
+	}
+	for (const [key, entry] of previous) if (!current.has(key)) append(entry, 0, entry.bytes, "removed");
+	return changes.sort((a, b) => (b.deltaBytes ?? -Infinity) - (a.deltaBytes ?? -Infinity) || a.key.localeCompare(b.key));
+}
+/** 比较两个真实快照；模块仅按已记录的 chunk 贡献归并，缺失测量不视为零。 */
+function createAnalyzeComparison(current, previous) {
+	const currentMaps = createSizeMaps(current);
+	const previousMaps = createSizeMaps(previous);
+	return {
+		currentBytes: currentMaps.totalBytes,
+		previousBytes: previousMaps.totalBytes,
+		deltaBytes: currentMaps.totalBytes === null || previousMaps.totalBytes === null ? null : currentMaps.totalBytes - previousMaps.totalBytes,
+		currentUnmeasuredFiles: currentMaps.unmeasuredFiles,
+		previousUnmeasuredFiles: previousMaps.unmeasuredFiles,
+		packages: compareSizeMaps(currentMaps.packages, previousMaps.packages),
+		files: compareSizeMaps(currentMaps.files, previousMaps.files),
+		modules: compareSizeMaps(currentMaps.modules, previousMaps.modules)
+	};
+}
+//#endregion
+//#region 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
+function createDuplicateAdvice(sourceType, hasIndependentPackage, estimatedSavingBytes) {
+	if (hasIndependentPackage) return estimatedSavingBytes > 0 ? "含独立分包，先确认隔离要求，再评估是否抽公共入口。" : "含独立分包，重复可能来自隔离边界。";
+	if (sourceType === "node_modules") return "依赖被多个包带入，检查引用边界或考虑主包公共入口。";
+	if (sourceType === "src" || sourceType === "workspace") return "共享源码跨包重复，优先抽公共模块或调整分包归属。";
+	if (sourceType === "plugin") return "插件生成内容跨包重复，检查插件产物输出策略。";
+	return "检查该模块是否需要在多个包内重复存在。";
+}
+/** 按原始模块 ID 统计跨包重复，节省量是估算值，不代表可安全移除的字节。 */
+function createDuplicateModuleInsights(result) {
+	const moduleBytes = createModuleByteMap(result);
+	const packageTypes = new Map(result.packages.map((pkg) => [pkg.id, pkg.type]));
+	return result.modules.filter((module) => module.packages.length > 1).map((module) => {
+		const bytes = moduleBytes.get(module.id) ?? 0;
+		const packages = module.packages.map((pkg) => pkg.packageId);
+		const estimatedSavingBytes = bytes * (packages.length - 1);
+		const hasIndependentPackage = packages.some((id) => packageTypes.get(id) === "independent");
+		return {
+			id: module.id,
+			source: module.source,
+			sourceType: module.sourceType,
+			packageCount: packages.length,
+			bytes,
+			estimatedSavingBytes,
+			packages,
+			hasIndependentPackage,
+			advice: createDuplicateAdvice(module.sourceType, hasIndependentPackage, estimatedSavingBytes)
+		};
+	}).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 { createModuleByteMap as n, createAnalyzeComparison as r, createDuplicateModuleInsights as t };

package/dist/artifacts-BOyC9Fy-.mjs

@@ -0,0 +1,106 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "pathe";
+import fs from "node:fs";
+import { Buffer } from "node:buffer";
+//#region 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;
+}
+//#endregion
+//#region 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;
+		}
+	};
+}
+//#endregion
+export { resolveDashboardInstallation as a, resolveDashboardClientAssets as i, createDashboardArtifactSnapshot as n, ANALYZE_DASHBOARD_PACKAGE_NAME as r, MAX_DASHBOARD_FILE_CONTENT_BYTES as t };