weapp-vite 7.5.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/{analyze-ZJUvEdaY.mjs → analyze-DN79YOAH.mjs}

@@ -1,67 +1,3 @@
-//#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
 function createModuleComparisonKey(source, sourceType) {
 	const origin = sourceType === "node_modules" || sourceType === "workspace" ? "dependency" : sourceType;
@@ -245,4 +181,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-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 };