weapp-vite 7.5.0 → 7.7.0

package/dist/history-dKxzoHmN.mjs

@@ -0,0 +1,774 @@
+import { c as getDevServerCloseRecord, l as replaceDevServerClose, s as getDevShutdownScope } from "./lifecycle-CUo8PMQc.mjs";
+import { C as createDevViteServer, O as createSharedBuildConfig, w as createGlassEaselAnalyzeResult } from "./createCompilerContextInstance-BXSdH2E8.mjs";
+import { r as logger_default, t as colors } from "./logger-DGn5iEVN.mjs";
+import { a as resolveDashboardInstallation, r as ANALYZE_DASHBOARD_PACKAGE_NAME } from "./artifacts-TrTX9_jj.mjs";
+import { t as loadDashboardTransportModule } from "./dashboardTransport-C9290QgS.mjs";
+import { n as isRuntimeCategory, t as createAnalyzeBudgetCheck } from "./budget-_Mu-4GKn.mjs";
+import { r as resolveAnalyzeHistoryMetadata, t as createAnalyzeMetadata } from "./metadata-HlDKtlsu.mjs";
+import { i as resolveModuleSourceType, n as normalizeModuleId, r as resolveAssetSource, t as classifyPackage } from "./classifier-CNTJOYQL.mjs";
+import process from "node:process";
+import path, { posix } from "pathe";
+import { readFileSync } from "node:fs";
+import fs$1 from "node:fs/promises";
+import { build } from "vite";
+import { createHash } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { resolveCommand } from "package-manager-detector/commands";
+import { brotliCompressSync, gzipSync } from "node:zlib";
+// src/cli/analyze/dashboard.ts
+function createInstallCommand(agent) {
+	const resolved = resolveCommand(agent ?? "npm", "install", [ANALYZE_DASHBOARD_PACKAGE_NAME]);
+	if (!resolved) return `npm install ${ANALYZE_DASHBOARD_PACKAGE_NAME}`;
+	return `${resolved.command} ${resolved.args.join(" ")}`;
+}
+async function startAnalyzeDashboard(result, options) {
+	const shutdown = getDevShutdownScope();
+	const resolved = resolveDashboardInstallation(options);
+	if (!resolved) {
+		logger_default.warn(`[weapp-vite ui] 未安装可选仪表盘包 ${colors.bold(colors.green(ANALYZE_DASHBOARD_PACKAGE_NAME))}，已自动降级关闭 dashboard 能力。`);
+		logger_default.info(`如需启用，请执行 ${colors.bold(colors.green(createInstallCommand(options.packageManagerAgent)))}`);
+		return;
+	}
+	const { root, configFile, packageJsonPath } = resolved;
+	const { ANALYZE_DASHBOARD_DEVFRAME_BASE, ANALYZE_DASHBOARD_HUB_BASE, createAnalyzeDashboardViteBridge } = await import("./dashboardViteBridge-B7QgQo94.mjs");
+	const [{ createAnalyzeDashboardDevframe }, { buildOtpAuthUrl, refreshTempAuthCode }] = await Promise.all([import("./dashboard.mjs"), loadDashboardTransportModule(packageJsonPath, "devframe/node/auth")]);
+	const devframe = createAnalyzeDashboardDevframe({
+		clientAssets: options.uiHost === "hub" ? root : void 0,
+		snapshot: {
+			current: result,
+			previous: options.previousResult ?? null,
+			artifacts: options.artifacts
+		},
+		initialEvents: [{
+			kind: "command",
+			level: "success",
+			title: options.watch ? "dashboard watch session started" : "dashboard static session started",
+			detail: options.watch ? "weapp-vite UI 已进入实时分析模式，后续 analyze 结果会继续推送到 dashboard。" : "weapp-vite UI 已进入静态分析模式，当前页面展示的是一次性分析结果。",
+			tags: options.watch ? ["watch", "analyze"] : ["static", "analyze"]
+		}, ...options.initialEvents ?? []],
+		roots: {
+			pluginRoot: options.pluginRoot,
+			projectRoot: options.cwd,
+			srcRoot: options.srcRoot ?? (options.cwd ? path.resolve(options.cwd, "src") : void 0)
+		}
+	});
+	const bridge = createAnalyzeDashboardViteBridge(devframe, {
+		packageJsonPath,
+		projectRoot: options.cwd ?? process.cwd(),
+		uiHost: options.uiHost
+	});
+	let server;
+	let onHostClose;
+	const closeResources = async () => {
+		return (await Promise.allSettled([
+			Promise.resolve().then(() => devframe.dispose()),
+			Promise.resolve().then(() => bridge.close()),
+			Promise.resolve().then(() => shutdown ? shutdown.run("cleanup", () => server?.close()) : server?.close())
+		])).filter((result) => result.status === "rejected").map((result) => result.reason);
+	};
+	try {
+		server = await createDevViteServer({
+			root,
+			base: ANALYZE_DASHBOARD_DEVFRAME_BASE,
+			configFile: configFile ?? false,
+			clearScreen: false,
+			appType: "spa",
+			publicDir: false,
+			plugins: [{
+				name: "weapp-vite:dashboard-lifetime",
+				enforce: "pre",
+				configureServer(createdServer) {
+					server ??= createdServer;
+					const record = getDevServerCloseRecord(createdServer);
+					const close = record.close;
+					replaceDevServerClose(createdServer, async () => {
+						try {
+							await close();
+						} finally {
+							if (server && getDevServerCloseRecord(server) === record) onHostClose?.();
+						}
+					});
+				}
+			}, bridge],
+			server: {
+				host: "127.0.0.1",
+				port: 0,
+				watch: { ignored: ["**/*"] }
+			},
+			logLevel: "error"
+		});
+		if (!shutdown?.stopping) await server.listen(0);
+	} catch (error) {
+		const cleanupErrors = await closeResources();
+		if (cleanupErrors.length) throw new AggregateError([error, ...cleanupErrors], "Dashboard 启动及资源清理失败", { cause: error });
+		throw error;
+	}
+	const activeServer = server;
+	const urls = [...activeServer.resolvedUrls?.local ?? [], ...activeServer.resolvedUrls?.network ?? []];
+	const authCode = refreshTempAuthCode();
+	const authenticatedUrls = urls.map((url) => {
+		const entryUrl = options.uiHost === "hub" ? new URL(ANALYZE_DASHBOARD_HUB_BASE, url).href : url;
+		return buildOtpAuthUrl(entryUrl, authCode);
+	});
+	let closing;
+	let resolveExit;
+	const waitPromise = new Promise((resolve) => {
+		resolveExit = resolve;
+	});
+	const signals = ["SIGINT", "SIGTERM"];
+	let onExit;
+	let releaseOwnership;
+	const finish = () => {
+		for (const signal of signals) process.removeListener(signal, onExit);
+		releaseOwnership?.();
+		resolveExit();
+	};
+	onHostClose = () => {
+		if (!closing) finish();
+	};
+	const close = () => {
+		if (!closing) closing = closeResources().then((errors) => {
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Dashboard 资源清理失败");
+		}).finally(finish);
+		return closing;
+	};
+	onExit = async () => {
+		await close().catch((error) => logger_default.error(error));
+	};
+	if (!shutdown) for (const signal of signals) process.once(signal, onExit);
+	const handle = {
+		update: devframe.update,
+		emitRuntimeEvents: devframe.emitRuntimeEvents,
+		waitForExit: () => waitPromise,
+		close,
+		urls: authenticatedUrls
+	};
+	releaseOwnership = shutdown?.own(close);
+	if (shutdown?.stopping) {
+		await close();
+		return;
+	}
+	if (options.watch) {
+		if (!options.silentStartupLog) {
+			logger_default.info("weapp-vite UI 已启动（分析视图，实时模式），按 Ctrl+C 退出。");
+			for (const url of handle.urls) logger_default.info(`  ➜  ${colors.bold(colors.cyan(url))}`);
+		}
+		return handle;
+	}
+	if (!options.silentStartupLog) {
+		logger_default.info("weapp-vite UI 已启动（分析视图，静态模式），按 Ctrl+C 退出。");
+		for (const url of handle.urls) logger_default.info(`  ➜  ${colors.bold(colors.cyan(url))}`);
+	}
+	await waitPromise;
+}
+// src/analyze/components/suggestions.ts
+function createComponentSuggestion(usage) {
+	if (usage.componentPackage !== "__main__" || usage.crossPackageUsageCount === 0) return;
+	if (usage.crossPackageUsageCount === usage.placeholderCoveredCrossPackageUsageCount) return;
+	const pagePackages = Array.from(new Set(Array.from(usage.pages.values()).map((page) => page.packageId))).sort((left, right) => {
+		if (left === "__main__") return -1;
+		if (right === "__main__") return 1;
+		return left.localeCompare(right);
+	});
+	const subPackageIds = pagePackages.filter((packageId) => packageId !== "__main__");
+	const usedByMain = pagePackages.includes("__main__");
+	if (subPackageIds.length === 1 && !usedByMain) {
+		const targetPackage = subPackageIds[0];
+		return {
+			kind: "move-to-subpackage",
+			component: usage.component,
+			componentPackage: usage.componentPackage,
+			targetPackage,
+			pagePackages,
+			message: `主包组件 ${usage.component} 仅被分包 ${targetPackage} 使用，建议评估移动到该分包。`
+		};
+	}
+	if (subPackageIds.length > 1) return {
+		kind: "shared-subpackage-or-placeholder",
+		component: usage.component,
+		componentPackage: usage.componentPackage,
+		pagePackages,
+		message: `主包组件 ${usage.component} 被多个分包使用，建议评估分包归属、共享策略或 componentPlaceholder。`
+	};
+	if (usedByMain && subPackageIds.length > 0) return {
+		kind: "split-or-async",
+		component: usage.component,
+		componentPackage: usage.componentPackage,
+		pagePackages,
+		message: `主包组件 ${usage.component} 同时被主包和分包使用，建议评估组件拆分、归属或异步化策略。`
+	};
+}
+// src/analyze/components/index.ts
+function normalizeRoute(value) {
+	return posix.normalize(value.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.json$/, ""));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringArray(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+}
+function readUsingComponents(config) {
+	if (!isRecord(config) || !isRecord(config.usingComponents)) return [];
+	return Object.entries(config.usingComponents).filter((entry) => typeof entry[1] === "string" && entry[1].trim() !== "");
+}
+function readComponentGenericDefaults(config) {
+	if (!isRecord(config) || !isRecord(config.componentGenerics)) return [];
+	return Object.entries(config.componentGenerics).map(([name, value]) => isRecord(value) && typeof value.default === "string" && value.default.trim() !== "" ? [name, value.default] : void 0).filter((entry) => Boolean(entry));
+}
+function readComponentPlaceholder(config) {
+	if (!isRecord(config) || !isRecord(config.componentPlaceholder)) return /* @__PURE__ */ new Set();
+	return new Set(Object.keys(config.componentPlaceholder));
+}
+function resolveComponentRoute(owner, request) {
+	const normalizedRequest = request.replace(/\\/g, "/").trim();
+	if (!normalizedRequest || normalizedRequest.startsWith("plugin://")) return;
+	if (normalizedRequest.startsWith(".")) return normalizeRoute(posix.join(posix.dirname(owner), normalizedRequest));
+	if (normalizedRequest.startsWith("/")) return normalizeRoute(normalizedRequest);
+	return normalizeRoute(normalizedRequest);
+}
+function resolvePackageId(route, subPackages) {
+	return subPackages.map((item) => item.root).filter(Boolean).sort((left, right) => right.length - left.length).find((root) => route === root || route.startsWith(`${root}/`)) ?? "__main__";
+}
+function collectAppPages(configs) {
+	const appJson = configs.get("app");
+	if (!isRecord(appJson)) return /* @__PURE__ */ new Set();
+	const pages = /* @__PURE__ */ new Set();
+	for (const page of toStringArray(appJson.pages)) pages.add(normalizeRoute(page));
+	const subPackages = Array.isArray(appJson.subPackages) ? appJson.subPackages : Array.isArray(appJson.subpackages) ? appJson.subpackages : [];
+	for (const item of subPackages) {
+		if (!isRecord(item) || typeof item.root !== "string") continue;
+		for (const page of toStringArray(item.pages)) pages.add(normalizeRoute(posix.join(item.root, page)));
+	}
+	return pages;
+}
+function registerUsage(usageMap, edge, page, pagePackage, componentPackage) {
+	const usage = usageMap.get(edge.component) ?? {
+		component: edge.component,
+		componentPackage,
+		totalUsageCount: 0,
+		pages: /* @__PURE__ */ new Map(),
+		crossPackageUsageCount: 0,
+		placeholderCoveredCrossPackageUsageCount: 0
+	};
+	usage.totalUsageCount += 1;
+	const pageUsage = usage.pages.get(page) ?? {
+		page,
+		packageId: pagePackage,
+		usageCount: 0
+	};
+	pageUsage.usageCount += 1;
+	usage.pages.set(page, pageUsage);
+	if (pagePackage !== componentPackage) {
+		usage.crossPackageUsageCount += 1;
+		if (edge.placeholderCovered) usage.placeholderCoveredCrossPackageUsageCount += 1;
+	}
+	usageMap.set(edge.component, usage);
+}
+function collectAnalyzeComponentJsonConfigs(output) {
+	if (!output) return [];
+	const configs = [];
+	for (const item of output.output ?? []) {
+		if (item.type !== "asset" || !item.fileName.endsWith(".json")) continue;
+		const asset = item;
+		if (typeof asset.source !== "string") continue;
+		try {
+			configs.push({
+				file: normalizeRoute(asset.fileName),
+				config: JSON.parse(asset.source)
+			});
+		} catch {}
+	}
+	return configs;
+}
+function analyzeComponentUsage(options) {
+	const configs = /* @__PURE__ */ new Map();
+	for (const item of options.jsonConfigs) configs.set(normalizeRoute(item.file), item.config);
+	const pages = collectAppPages(configs);
+	const graph = /* @__PURE__ */ new Map();
+	const packageMap = /* @__PURE__ */ new Map();
+	for (const route of configs.keys()) packageMap.set(route, resolvePackageId(route, options.subPackages));
+	for (const [owner, config] of configs) {
+		const placeholders = readComponentPlaceholder(config);
+		const edges = [...readUsingComponents(config), ...readComponentGenericDefaults(config)].map(([name, request]) => {
+			const component = resolveComponentRoute(owner, request);
+			return component && configs.has(component) ? {
+				owner,
+				component,
+				placeholderCovered: placeholders.has(name)
+			} : void 0;
+		}).filter((edge) => Boolean(edge)).filter((edge, index, all) => all.findIndex((item) => item.component === edge.component) === index);
+		if (edges.length > 0) graph.set(owner, edges);
+	}
+	const usageMap = /* @__PURE__ */ new Map();
+	const visit = (owner, page, stack) => {
+		for (const edge of graph.get(owner) ?? []) {
+			const componentPackage = packageMap.get(edge.component) ?? "__main__";
+			const pagePackage = packageMap.get(page) ?? "__main__";
+			registerUsage(usageMap, edge, page, pagePackage, componentPackage);
+			if (stack.has(edge.component)) continue;
+			const nextStack = new Set(stack);
+			nextStack.add(edge.component);
+			visit(edge.component, page, nextStack);
+		}
+	};
+	for (const page of pages) visit(page, page, /* @__PURE__ */ new Set([page]));
+	return Array.from(usageMap.values()).map((usage) => {
+		const pages = Array.from(usage.pages.values()).sort((left, right) => left.page.localeCompare(right.page));
+		const suggestions = [createComponentSuggestion(usage)].filter((item) => Boolean(item));
+		return {
+			component: usage.component,
+			componentPackage: usage.componentPackage,
+			totalUsageCount: usage.totalUsageCount,
+			pageUsageCount: pages.length,
+			pages,
+			suggestions
+		};
+	}).sort((left, right) => {
+		const usageDelta = right.totalUsageCount - left.totalUsageCount;
+		return usageDelta !== 0 ? usageDelta : left.component.localeCompare(right.component);
+	});
+}
+// src/analyze/subpackages/artifacts/owner.ts
+/** 每次分析独立缓存包边界，兼容 pnpm、工作区和普通 node_modules。 */
+function createModuleOwnerResolver() {
+	const cache = /* @__PURE__ */ new Map();
+	const resolveDirectory = (directory) => {
+		if (cache.has(directory)) return cache.get(directory);
+		let owner;
+		try {
+			const value = JSON.parse(readFileSync(path.join(directory, "package.json"), "utf8"));
+			if (value && typeof value === "object" && "name" in value && typeof value.name === "string") owner = {
+				name: value.name,
+				version: "version" in value && typeof value.version === "string" ? value.version : void 0
+			};
+		} catch (error) {
+			if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
+		}
+		const parent = path.dirname(directory);
+		if (!owner && parent !== directory && path.basename(directory) !== "node_modules") owner = resolveDirectory(parent);
+		cache.set(directory, owner);
+		return owner;
+	};
+	return (id) => id === "\0rolldown/runtime.js" ? { name: "rolldown" } : path.isAbsolute(id) && !id.includes("\0") ? resolveDirectory(path.dirname(id.replace(/[?#].*$/, ""))) : void 0;
+}
+function classifyOwnedModule(owner, application) {
+	if (application) return "application";
+	if (owner?.name === "@vue/reactivity") return "reactivity";
+	if (owner?.name === "@vue/shared" || owner?.name === "@weapp-core/constants" || owner?.name === "rolldown") return "helper";
+	if (owner && [
+		"weapi",
+		"@wevu/api",
+		"@wevu/web-apis",
+		"@weapp-vite/web",
+		"@weapp-vite/web-apis"
+	].includes(owner.name)) return "host";
+	if (owner && ["wevu", "@weapp-vite/react"].includes(owner.name)) return "runtime";
+	return owner ? "dependency" : "unknown";
+}
+// src/analyze/subpackages/artifacts/index.ts
+function createArtifactAnalysis(packages, resolveOwner = createModuleOwnerResolver()) {
+	const files = /* @__PURE__ */ new Map();
+	const moduleCopies = /* @__PURE__ */ new Map();
+	for (const pkg of packages) for (const file of pkg.files) {
+		if (files.has(file.file)) throw new Error(`产物重复归属：${file.file}`);
+		if (typeof file.size !== "number" || !Number.isFinite(file.size) || file.size < 0) throw new Error(`产物缺少有效字节数：${file.file}`);
+		const retained = (file.modules ?? []).filter((module) => module.bytes !== 0);
+		const length = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+		const totalLength = retained.reduce((sum, module) => sum + length(module.bytes), 0);
+		const scale = Math.max(totalLength, file.moduleRenderedLength ?? 0, file.size);
+		const modules = retained.map((module) => {
+			const owner = resolveOwner(module.id);
+			const category = classifyOwnedModule(owner, module.sourceType === "src" || module.sourceType === "plugin");
+			const estimatedBytes = scale > 0 ? file.size * length(module.bytes) / scale : 0;
+			const copies = moduleCopies.get(module.id) ?? [];
+			copies.push(estimatedBytes);
+			moduleCopies.set(module.id, copies);
+			return {
+				source: module.source,
+				package: owner,
+				category,
+				renderedLength: module.bytes,
+				estimatedBytes
+			};
+		});
+		const runtime = modules.filter((module) => isRuntimeCategory(module.category));
+		const roles = new Set(modules.map((module) => isRuntimeCategory(module.category) ? "runtime" : module.category === "application" ? "application" : module.category === "dependency" ? "dependency" : "unknown"));
+		const isAsset = file.type === "asset" && !file.modules && !/\.[cm]?js$/i.test(file.file);
+		const role = isAsset ? "asset" : roles.size > 1 ? "mixed" : [...roles][0] ?? "unknown";
+		files.set(file.file, {
+			file: file.file,
+			packageId: pkg.id,
+			origin: file.from,
+			type: file.type,
+			bytes: file.size,
+			sha256: file.sha256,
+			role,
+			classification: isAsset ? "asset" : modules.length ? "module-ownership" : "unavailable",
+			estimation: "rendered-length-proportional",
+			modules,
+			runtimeEstimatedBytes: runtime.reduce((sum, module) => sum + module.estimatedBytes, 0),
+			unattributedBytes: Math.max(0, file.size - modules.reduce((sum, module) => sum + module.estimatedBytes, 0))
+		});
+	}
+	const artifacts = [...files.values()].sort((a, b) => a.file.localeCompare(b.file));
+	if (artifacts.length === 0) throw new Error("未生成可分析产物，不能把缺失输出计为零字节。");
+	return {
+		files: artifacts,
+		totalBytes: artifacts.reduce((sum, file) => sum + file.bytes, 0),
+		duplicateEstimatedBytes: [...moduleCopies.values()].reduce((sum, copies) => sum + copies.reduce((a, b) => a + b, 0) - Math.max(...copies), 0),
+		runtime: {
+			estimatedBytes: artifacts.reduce((sum, file) => sum + file.runtimeEstimatedBytes, 0),
+			upperBoundBytes: artifacts.filter((file) => file.modules.some((module) => isRuntimeCategory(module.category))).reduce((sum, file) => sum + file.bytes, 0),
+			unknownFiles: artifacts.filter((file) => file.role === "unknown" || file.modules.some((module) => module.category === "unknown")).map((file) => file.file)
+		}
+	};
+}
+// src/analyze/subpackages/registry.ts
+function ensurePackage(packages, classification) {
+	const existing = packages.get(classification.id);
+	if (existing) return existing;
+	const created = {
+		...classification,
+		files: /* @__PURE__ */ new Map()
+	};
+	packages.set(classification.id, created);
+	return created;
+}
+function ensureModule(modules, id, source, sourceType) {
+	const existing = modules.get(id);
+	if (existing) return existing;
+	const created = {
+		id,
+		source,
+		sourceType,
+		packages: /* @__PURE__ */ new Map()
+	};
+	modules.set(id, created);
+	return created;
+}
+function registerModuleInPackage(modules, moduleId, source, sourceType, packageId, fileName) {
+	const moduleEntry = ensureModule(modules, moduleId, source, sourceType);
+	const files = moduleEntry.packages.get(packageId) ?? /* @__PURE__ */ new Set();
+	files.add(fileName);
+	moduleEntry.packages.set(packageId, files);
+}
+// src/analyze/subpackages/output.ts
+function getAssetBuffer(asset) {
+	if (typeof asset.source === "string") return Buffer.from(asset.source, "utf8");
+	if (asset.source instanceof Uint8Array) return Buffer.from(asset.source);
+}
+function getCompressedSizes(content) {
+	if (content === void 0) return {};
+	const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
+	return {
+		gzipSize: gzipSync(buffer).byteLength,
+		brotliSize: brotliCompressSync(buffer).byteLength
+	};
+}
+function processChunk(chunk, origin, ctx, classifierContext, packages, modules) {
+	const classification = classifyPackage(chunk.fileName, origin, classifierContext);
+	const packageEntry = ensurePackage(packages, classification);
+	const chunkEntry = {
+		file: chunk.fileName,
+		type: "chunk",
+		from: origin,
+		size: typeof chunk.code === "string" ? Buffer.byteLength(chunk.code, "utf8") : void 0,
+		sha256: createHash("sha256").update(chunk.code).digest("hex"),
+		...getCompressedSizes(chunk.code),
+		isEntry: chunk.isEntry,
+		modules: []
+	};
+	if (chunk.imports.length > 0) chunkEntry.imports = [...chunk.imports].sort((a, b) => a.localeCompare(b));
+	if (chunk.dynamicImports.length > 0) chunkEntry.dynamicImports = [...chunk.dynamicImports].sort((a, b) => a.localeCompare(b));
+	const moduleEntries = Object.entries(chunk.modules ?? {});
+	chunkEntry.moduleRenderedLength = moduleEntries.reduce((sum, [, info]) => sum + (typeof info.renderedLength === "number" && Number.isFinite(info.renderedLength) && info.renderedLength > 0 ? info.renderedLength : 0), 0);
+	for (const [rawModuleId, info] of moduleEntries) {
+		const generatedRuntime = rawModuleId === "\0rolldown/runtime.js";
+		const absoluteId = generatedRuntime ? rawModuleId : normalizeModuleId(rawModuleId);
+		if (!absoluteId) continue;
+		const { source, sourceType } = generatedRuntime ? {
+			source: "rolldown:runtime",
+			sourceType: "workspace"
+		} : resolveModuleSourceType(absoluteId, ctx);
+		const moduleEntry = {
+			id: absoluteId,
+			source,
+			sourceType,
+			bytes: info?.renderedLength
+		};
+		if (typeof info?.code === "string") moduleEntry.originalBytes = Buffer.byteLength(info.code, "utf8");
+		chunkEntry.modules.push(moduleEntry);
+		registerModuleInPackage(modules, absoluteId, source, sourceType, classification.id, chunk.fileName);
+	}
+	if (chunkEntry.modules) chunkEntry.modules.sort((a, b) => a.source.localeCompare(b.source));
+	packageEntry.files.set(chunk.fileName, chunkEntry);
+}
+function processAsset(asset, origin, ctx, classifierContext, packages, modules) {
+	const classification = classifyPackage(asset.fileName, origin, classifierContext);
+	const packageEntry = ensurePackage(packages, classification);
+	const assetBuffer = getAssetBuffer(asset);
+	const entry = {
+		file: asset.fileName,
+		type: "asset",
+		from: origin,
+		size: assetBuffer?.byteLength,
+		sha256: assetBuffer ? createHash("sha256").update(assetBuffer).digest("hex") : void 0,
+		...getCompressedSizes(assetBuffer)
+	};
+	let assetSource;
+	for (const sourceFile of [...asset.originalFileNames ?? [], asset.fileName]) {
+		assetSource = resolveAssetSource(sourceFile, ctx);
+		if (assetSource) break;
+	}
+	if (assetSource) {
+		entry.source = assetSource.source;
+		entry.sourceType = assetSource.sourceType;
+		registerModuleInPackage(modules, assetSource.absolute, assetSource.source, assetSource.sourceType, classification.id, asset.fileName);
+	}
+	packageEntry.files.set(asset.fileName, entry);
+}
+function processOutput(output, origin, ctx, classifierContext, packages, modules, onArtifact) {
+	if (!output) return;
+	for (const item of output.output ?? []) if (item.type === "chunk") {
+		processChunk(item, origin, ctx, classifierContext, packages, modules);
+		onArtifact?.(item.fileName, item.code);
+	} else if (item.type === "asset") {
+		const originalChunk = ctx.runtimeState?.build?.output?.analysisChunks?.get(item.fileName);
+		if (originalChunk) {
+			processChunk({
+				...originalChunk,
+				fileName: item.fileName,
+				code: Buffer.from(item.source).toString("utf8")
+			}, origin, ctx, classifierContext, packages, modules);
+			const classification = classifyPackage(item.fileName, origin, classifierContext);
+			packages.get(classification.id).files.get(item.fileName).type = "asset";
+		} else processAsset(item, origin, ctx, classifierContext, packages, modules);
+		onArtifact?.(item.fileName, item.source);
+	}
+}
+// src/analyze/subpackages/summary.ts
+function toArray(value) {
+	return Array.from(value);
+}
+function summarizePackages(packages) {
+	const order = {
+		main: 0,
+		subPackage: 1,
+		independent: 2,
+		virtual: 3
+	};
+	const reports = toArray(packages.values()).map((pkg) => {
+		const files = toArray(pkg.files.values());
+		files.sort((a, b) => a.file.localeCompare(b.file));
+		return {
+			id: pkg.id,
+			label: pkg.label,
+			type: pkg.type,
+			files
+		};
+	});
+	reports.sort((a, b) => {
+		const delta = order[a.type] - order[b.type];
+		if (delta !== 0) return delta;
+		if (a.id === "__main__") return -1;
+		if (b.id === "__main__") return 1;
+		return a.id.localeCompare(b.id);
+	});
+	return reports;
+}
+function summarizeModules(modules) {
+	const usage = toArray(modules.values()).map((module) => {
+		const packages = toArray(module.packages.entries()).map(([packageId, files]) => {
+			return {
+				packageId,
+				files: toArray(files).sort((a, b) => a.localeCompare(b))
+			};
+		}).sort((a, b) => {
+			if (a.packageId === b.packageId) return 0;
+			if (a.packageId === "__main__") return -1;
+			if (b.packageId === "__main__") return 1;
+			return a.packageId.localeCompare(b.packageId);
+		});
+		return {
+			id: module.id,
+			source: module.source,
+			sourceType: module.sourceType,
+			packages
+		};
+	});
+	usage.sort((a, b) => a.source.localeCompare(b.source));
+	return usage;
+}
+function expandVirtualModulePlacements(modules, packages, context) {
+	for (const moduleEntry of modules.values()) {
+		const virtualEntries = Array.from(moduleEntry.packages.entries()).filter(([packageId]) => packageId.startsWith("virtual:"));
+		if (!virtualEntries.length) continue;
+		const virtualFileBases = /* @__PURE__ */ new Map();
+		for (const [virtualPackageId, files] of virtualEntries) {
+			const combination = virtualPackageId.slice(8);
+			if (!combination) continue;
+			const segments = combination.split(/[_+]/).map((segment) => segment.trim()).filter(Boolean);
+			if (!segments.length) continue;
+			let matchingBases = virtualFileBases.get(virtualPackageId);
+			if (!matchingBases) {
+				matchingBases = Array.from(files).map((file) => posix.basename(file));
+				virtualFileBases.set(virtualPackageId, matchingBases);
+			}
+			for (const root of segments) {
+				if (!context.subPackageRoots.has(root)) continue;
+				const targetPackage = packages.get(root);
+				if (!targetPackage) continue;
+				const moduleFiles = moduleEntry.packages.get(root) ?? /* @__PURE__ */ new Set();
+				const targetFiles = Array.from(targetPackage.files.values()).filter((fileEntry) => {
+					if (!matchingBases?.length) return true;
+					const base = posix.basename(fileEntry.file);
+					return matchingBases.includes(base);
+				}).map((fileEntry) => fileEntry.file);
+				if (targetFiles.length === 0) {
+					const fallback = targetPackage.files.values().next().value;
+					if (fallback) moduleFiles.add(fallback.file);
+				} else for (const fileName of targetFiles) moduleFiles.add(fileName);
+				if (moduleFiles.size > 0) moduleEntry.packages.set(root, moduleFiles);
+			}
+		}
+	}
+}
+function summarizeSubPackages(metas) {
+	const descriptors = metas.map((meta) => {
+		return {
+			root: meta.subPackage.root ?? "",
+			independent: Boolean(meta.subPackage.independent),
+			name: meta.subPackage.name
+		};
+	}).filter((descriptor) => descriptor.root);
+	descriptors.sort((a, b) => a.root.localeCompare(b.root));
+	return descriptors;
+}
+// src/analyze/subpackages/index.ts
+async function analyzeBuild(ctx, options) {
+	const { configService, scanService, buildService } = ctx;
+	if (!configService || !scanService || !buildService) throw new Error("analyzeSubpackages 需要先初始化 configService、scanService 和 buildService。");
+	await scanService.loadAppEntry();
+	const subPackageMetas = scanService.loadSubPackages();
+	const subPackageRoots = /* @__PURE__ */ new Set();
+	const independentRoots = /* @__PURE__ */ new Set();
+	for (const meta of subPackageMetas) {
+		const root = meta.subPackage.root;
+		if (root) {
+			subPackageRoots.add(root);
+			if (meta.subPackage.independent) independentRoots.add(root);
+		}
+	}
+	const classifierContext = {
+		subPackageRoots,
+		independentRoots
+	};
+	const analysisConfig = configService.merge(void 0, createSharedBuildConfig(configService, scanService), { build: {
+		write: false,
+		watch: null
+	} });
+	const mainResult = await build(analysisConfig);
+	const mainOutputs = Array.isArray(mainResult) ? mainResult : [mainResult];
+	const packages = /* @__PURE__ */ new Map();
+	const modules = /* @__PURE__ */ new Map();
+	const componentJsonConfigs = [];
+	for (const output of mainOutputs) {
+		processOutput(output, "main", ctx, classifierContext, packages, modules, options?.onArtifact);
+		componentJsonConfigs.push(...collectAnalyzeComponentJsonConfigs(output));
+	}
+	for (const root of independentRoots) {
+		const output = buildService.getIndependentOutput(root);
+		processOutput(output, "independent", ctx, classifierContext, packages, modules, options?.onArtifact);
+		componentJsonConfigs.push(...collectAnalyzeComponentJsonConfigs(output));
+	}
+	expandVirtualModulePlacements(modules, packages, classifierContext);
+	const subPackages = summarizeSubPackages(subPackageMetas);
+	const packageReports = summarizePackages(packages);
+	const artifacts = createArtifactAnalysis(packageReports);
+	const result = {
+		schemaVersion: 2,
+		build: {
+			id: createHash("sha256").update(JSON.stringify([
+				configService.platform,
+				configService.mode,
+				artifacts.files.map((file) => [file.file, file.sha256])
+			])).digest("hex"),
+			platform: configService.platform,
+			mode: configService.mode
+		},
+		artifacts,
+		metadata: createAnalyzeMetadata(ctx.configService),
+		packages: packageReports,
+		modules: summarizeModules(modules),
+		subPackages,
+		components: analyzeComponentUsage({
+			jsonConfigs: componentJsonConfigs,
+			subPackages
+		}),
+		glassEasel: createGlassEaselAnalyzeResult(ctx)
+	};
+	result.budgetChecks = createAnalyzeBudgetCheck(result);
+	return result;
+}
+async function analyzeSubpackages(ctx, options) {
+	const previous = ctx.runtimeState.build.output.analysisChunks;
+	ctx.runtimeState.build.output.analysisChunks = /* @__PURE__ */ new Map();
+	try {
+		return await analyzeBuild(ctx, options);
+	} finally {
+		ctx.runtimeState.build.output.analysisChunks = previous;
+	}
+}
+// src/analyze/subpackages/history.ts
+const jsonExtension = ".json";
+function createSnapshotFileName(date = /* @__PURE__ */ new Date()) {
+	return `${date.toISOString().replace(/[:.]/g, "-")}${jsonExtension}`;
+}
+function isAnalyzeResult(value) {
+	return Boolean(value && typeof value === "object" && Array.isArray(value.packages) && Array.isArray(value.modules) && Array.isArray(value.subPackages));
+}
+async function listSnapshotFiles(dir) {
+	try {
+		return (await fs$1.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(jsonExtension)).map((entry) => path.join(dir, entry.name)).sort((a, b) => b.localeCompare(a));
+	} catch {
+		return [];
+	}
+}
+async function trimSnapshotFiles(dir, limit) {
+	const staleFiles = (await listSnapshotFiles(dir)).slice(limit);
+	await Promise.all(staleFiles.map(async (file) => {
+		try {
+			await fs$1.unlink(file);
+		} catch {}
+	}));
+}
+async function readLatestAnalyzeHistorySnapshot(configService) {
+	const history = resolveAnalyzeHistoryMetadata(configService);
+	if (!history.enabled) return null;
+	const files = await listSnapshotFiles(history.dir);
+	for (const file of files) try {
+		const parsed = JSON.parse(await fs$1.readFile(file, "utf8"));
+		if (isAnalyzeResult(parsed)) return parsed;
+	} catch {}
+	return null;
+}
+async function writeAnalyzeHistorySnapshot(result, configService, now = /* @__PURE__ */ new Date()) {
+	const history = resolveAnalyzeHistoryMetadata(configService);
+	if (!history.enabled) return;
+	await fs$1.mkdir(history.dir, { recursive: true });
+	const snapshotPath = path.join(history.dir, createSnapshotFileName(now));
+	if (result.metadata) result.metadata = {
+		...result.metadata,
+		history: {
+			...history,
+			dir: configService.relativeCwd(history.dir),
+			latestSnapshot: configService.relativeCwd(snapshotPath)
+		}
+	};
+	await fs$1.writeFile(snapshotPath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+	await trimSnapshotFiles(history.dir, history.limit);
+	return snapshotPath;
+}
+export { startAnalyzeDashboard as i, writeAnalyzeHistorySnapshot as n, analyzeSubpackages as r, readLatestAnalyzeHistorySnapshot as t };