weapp-vite 7.2.2 → 7.4.0

package/dist/dashboard/vite.d.mts

@@ -0,0 +1,9 @@
+import { t as AnalyzeDashboardDevframeController } from "../index-DbqVupg0.mjs";
+import { Plugin } from "vite";
+//#region src/dashboard/vite.d.ts
+export interface AnalyzeDashboardPluginOptions {
+  base?: string;
+}
+/** 使用官方适配器挂载到现有 Vite DevTools；认证、Origin 与 MCP 策略由宿主负责。 */
+export declare function createAnalyzeDashboardPlugin(controller: AnalyzeDashboardDevframeController, options?: AnalyzeDashboardPluginOptions): Plugin;
+//#endregion

package/dist/dashboard/vite.mjs

@@ -0,0 +1,44 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { createPluginFromDevframe } from "@vitejs/devtools-kit/node";
+//#region src/dashboard/vite.ts
+/** 使用官方适配器挂载到现有 Vite DevTools；认证、Origin 与 MCP 策略由宿主负责。 */
+function createAnalyzeDashboardPlugin(controller, options = {}) {
+	const plugin = createPluginFromDevframe(controller.definition, { base: options.base === void 0 ? void 0 : `/${options.base}/`.replace(/\/+/g, "/") });
+	const devtools = plugin.devtools;
+	let activeHostConfig;
+	return {
+		...plugin,
+		apply: "serve",
+		devtools: {
+			...devtools,
+			async setup(ctx) {
+				let setupStarted = false;
+				try {
+					if (ctx.viteConfig.command !== "serve") return;
+					const clientAssets = controller.definition.clientAssets;
+					if (typeof clientAssets !== "string" || !isAbsolute(clientAssets) || !existsSync(join(clientAssets, "index.html"))) throw new Error("Dashboard Vite 插件需要已构建 clientAssets 的绝对目录，请先调用 resolveDashboardClientAssets。");
+					setupStarted = true;
+					await devtools.setup(ctx);
+					activeHostConfig = ctx.viteConfig;
+				} catch (error) {
+					if (!activeHostConfig || setupStarted) {
+						activeHostConfig = void 0;
+						controller.dispose();
+					}
+					throw error;
+				}
+			}
+		},
+		async closeBundle(...args) {
+			if (this.environment.getTopLevelConfig() === activeHostConfig) {
+				activeHostConfig = void 0;
+				controller.dispose();
+			}
+			const closeBundle = plugin.closeBundle;
+			await (typeof closeBundle === "function" ? closeBundle : closeBundle?.handler)?.apply(this, args);
+		}
+	};
+}
+//#endregion
+export { createAnalyzeDashboardPlugin };

package/dist/dashboard-BzaVesmQ.mjs

@@ -0,0 +1,558 @@
+import { t as VERSION } from "./constants-WOsG3Eqd.mjs";
+import { createRequire } from "node:module";
+import path from "pathe";
+import fs from "node:fs";
+import process from "node:process";
+import { createHash } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { defineDevframe, defineRpcFunction } from "devframe";
+//#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
+//#region src/dashboard/paths.ts
+function normalizeDashboardRelativePath(value) {
+	return value.replaceAll("\\", "/");
+}
+function stripDashboardFileQuery(value) {
+	const queryIndex = value.indexOf("?");
+	return queryIndex === -1 ? value : value.slice(0, queryIndex);
+}
+function addDashboardAllowedPath(paths, value) {
+	if (!value || value.includes("\0")) return;
+	const normalizedPath = normalizeDashboardRelativePath(stripDashboardFileQuery(value));
+	if (!normalizedPath || path.isAbsolute(normalizedPath)) return;
+	paths.add(normalizedPath);
+}
+function addDashboardAllowedSourcePath(paths, value, rootKind) {
+	if (!value || value.includes("\0")) return;
+	const normalizedPath = normalizeDashboardRelativePath(stripDashboardFileQuery(value));
+	if (!normalizedPath || path.isAbsolute(normalizedPath)) return;
+	const rootKinds = paths.get(normalizedPath) ?? /* @__PURE__ */ new Set();
+	rootKinds.add(rootKind);
+	paths.set(normalizedPath, rootKinds);
+}
+function resolveDashboardSourceRootKind(sourceType) {
+	if (sourceType === "plugin") return "plugin";
+	if (sourceType === "workspace" || sourceType === "node_modules") return "project";
+	return "src";
+}
+function createDashboardContentAllowlist(result) {
+	const artifactPaths = /* @__PURE__ */ new Set();
+	const sourcePaths = /* @__PURE__ */ new Map();
+	for (const packageReport of result.packages) for (const file of packageReport.files) {
+		addDashboardAllowedPath(artifactPaths, file.file);
+		const fileSourceType = file.sourceType ?? file.modules?.find((module) => module.source === file.source)?.sourceType;
+		addDashboardAllowedSourcePath(sourcePaths, file.source, resolveDashboardSourceRootKind(fileSourceType));
+		for (const module of file.modules ?? []) addDashboardAllowedSourcePath(sourcePaths, module.source, module.sourceType === "src" ? "src" : module.sourceType === "plugin" ? "plugin" : "project");
+	}
+	return {
+		artifactPaths,
+		sourcePaths
+	};
+}
+function resolveDashboardContentPath(root, requestPath, options) {
+	if (!root || !requestPath || requestPath.includes("\0")) return;
+	const normalizedRequestPath = normalizeDashboardRelativePath(stripDashboardFileQuery(requestPath));
+	if (path.isAbsolute(normalizedRequestPath) || !options.allowedPaths.has(normalizedRequestPath)) return;
+	const rootPath = path.resolve(root);
+	const absolutePath = path.resolve(rootPath, normalizedRequestPath);
+	const relativePath = path.relative(rootPath, absolutePath);
+	const allowParent = options.allowParent === true;
+	if (!relativePath || !allowParent && (relativePath.startsWith("..") || path.isAbsolute(relativePath))) return;
+	return {
+		absolutePath,
+		allowParent,
+		relativePath: allowParent ? normalizedRequestPath : normalizeDashboardRelativePath(relativePath),
+		rootPath
+	};
+}
+function resolveDashboardSourceContentPaths(roots, requestPath, allowedPaths) {
+	const normalizedRequestPath = normalizeDashboardRelativePath(stripDashboardFileQuery(requestPath));
+	const rootKinds = allowedPaths.get(normalizedRequestPath);
+	if (!rootKinds || rootKinds.size !== 1) return [];
+	const [rootKind] = rootKinds;
+	if (rootKind === "project") {
+		const resolved = resolveDashboardContentPath(roots.projectRoot, normalizedRequestPath, {
+			allowParent: true,
+			allowedPaths: /* @__PURE__ */ new Set([normalizedRequestPath])
+		});
+		return resolved ? [resolved] : [];
+	}
+	if (rootKind === "plugin") {
+		if (!roots.pluginRoot) return [];
+		const pluginBase = path.basename(roots.pluginRoot);
+		if (normalizedRequestPath !== pluginBase && !normalizedRequestPath.startsWith(`${pluginBase}/`)) return [];
+		const pluginRelativePath = normalizedRequestPath === pluginBase ? "" : normalizedRequestPath.slice(pluginBase.length + 1);
+		const resolved = resolveDashboardContentPath(roots.pluginRoot, pluginRelativePath, { allowedPaths: /* @__PURE__ */ new Set([pluginRelativePath]) });
+		return resolved ? [{
+			...resolved,
+			relativePath: normalizedRequestPath
+		}] : [];
+	}
+	if (!roots.srcRoot) return [];
+	const candidates = (normalizedRequestPath.startsWith("src/") ? [normalizedRequestPath, normalizedRequestPath.slice(4)] : [normalizedRequestPath]).flatMap((relativePath) => {
+		const resolved = resolveDashboardContentPath(roots.srcRoot, relativePath, { allowedPaths: /* @__PURE__ */ new Set([relativePath]) });
+		return resolved ? [{
+			...resolved,
+			relativePath: normalizedRequestPath
+		}] : [];
+	});
+	return [...new Map(candidates.map((candidate) => [candidate.absolutePath, candidate])).values()];
+}
+function resolveDashboardArtifactPath(requestPath, allowedPaths) {
+	const normalizedPath = normalizeDashboardRelativePath(stripDashboardFileQuery(requestPath));
+	if (!normalizedPath || normalizedPath.includes("\0") || path.isAbsolute(normalizedPath) || path.posix.normalize(normalizedPath).startsWith("..") || !allowedPaths.has(normalizedPath)) return;
+	return normalizedPath;
+}
+//#endregion
+//#region src/dashboard/content.ts
+function isPathWithin(rootPath, targetPath) {
+	const relativePath = path.relative(rootPath, targetPath);
+	return !relativePath || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function resolveInspectionRoot(resolved) {
+	let inspectionRoot = resolved.rootPath;
+	if (!resolved.allowParent) return inspectionRoot;
+	while (!isPathWithin(inspectionRoot, resolved.absolutePath)) {
+		const parent = path.dirname(inspectionRoot);
+		if (parent === inspectionRoot) return;
+		inspectionRoot = parent;
+	}
+	return inspectionRoot;
+}
+async function assertDashboardPathHasNoSymlink(resolved) {
+	const inspectionRoot = resolveInspectionRoot(resolved);
+	if (!inspectionRoot) throw new Error("文件路径超出允许范围。");
+	const relativePath = path.relative(inspectionRoot, resolved.absolutePath);
+	let currentPath = inspectionRoot;
+	for (const segment of relativePath.split(path.sep).filter(Boolean)) {
+		currentPath = path.join(currentPath, segment);
+		if ((await fs.promises.lstat(currentPath)).isSymbolicLink()) throw new Error("文件路径包含不允许的符号链接。");
+	}
+}
+function isSameOpenedFile(pathStat, handleStat) {
+	if (pathStat.dev !== handleStat.dev) return false;
+	return pathStat.ino === 0 || handleStat.ino === 0 || pathStat.ino === handleStat.ino;
+}
+async function openDashboardFile(resolved) {
+	await assertDashboardPathHasNoSymlink(resolved);
+	const flags = process.platform === "win32" ? fs.constants.O_RDONLY : fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW;
+	const handle = await fs.promises.open(resolved.absolutePath, flags);
+	try {
+		await assertDashboardPathHasNoSymlink(resolved);
+		const [pathStat, handleStat] = await Promise.all([fs.promises.stat(resolved.absolutePath), handle.stat()]);
+		if (!isSameOpenedFile(pathStat, handleStat)) throw new Error("文件路径在读取期间发生变化。");
+		return handle;
+	} catch (error) {
+		await handle.close();
+		throw error;
+	}
+}
+async function readDashboardFileHandle(handle) {
+	const stat = await handle.stat();
+	if (!stat.isFile()) throw new Error("目标路径不是文件。");
+	if (stat.size > 2097152) throw new Error(`文件超过 ${MAX_DASHBOARD_FILE_CONTENT_BYTES} 字节，已拒绝读取。`);
+	let content = Buffer.allocUnsafe(Math.min(Math.max(stat.size + 1, 1), 2097153));
+	let offset = 0;
+	while (true) {
+		if (offset === content.length) {
+			if (content.length === 2097153) throw new Error(`文件超过 ${MAX_DASHBOARD_FILE_CONTENT_BYTES} 字节，已拒绝读取。`);
+			const expanded = Buffer.allocUnsafe(Math.min(content.length * 2, 2097153));
+			content.copy(expanded, 0, 0, offset);
+			content = expanded;
+		}
+		const { bytesRead } = await handle.read(content, offset, content.length - offset, offset);
+		if (bytesRead === 0) break;
+		offset += bytesRead;
+		if (offset > 2097152) throw new Error(`文件超过 ${MAX_DASHBOARD_FILE_CONTENT_BYTES} 字节，已拒绝读取。`);
+	}
+	return {
+		content: content.subarray(0, offset).toString("utf8"),
+		size: offset
+	};
+}
+function resolveDashboardFileLanguage(filePath) {
+	const extension = path.extname(filePath).toLowerCase();
+	if ([
+		".js",
+		".mjs",
+		".cjs",
+		".wxs",
+		".sjs"
+	].includes(extension)) return "javascript";
+	if ([
+		".ts",
+		".mts",
+		".cts"
+	].includes(extension)) return "typescript";
+	if ([".json", ".map"].includes(extension)) return "json";
+	if ([
+		".css",
+		".wxss",
+		".scss",
+		".sass",
+		".less"
+	].includes(extension)) return "css";
+	if ([
+		".vue",
+		".wxml",
+		".html"
+	].includes(extension)) return "html";
+	return "plaintext";
+}
+function normalizeDashboardFileRequest(input) {
+	if (!input || typeof input !== "object" || !("kind" in input) || !("path" in input)) throw new Error("必须传入合法的 kind 和相对路径。");
+	const kind = input.kind;
+	const requestPath = input.path;
+	if (kind !== "source" && kind !== "artifact" || typeof requestPath !== "string") throw new Error("必须传入合法的 kind 和相对路径。");
+	return {
+		kind,
+		path: requestPath
+	};
+}
+async function readAllowedDashboardFile(input, roots, allowlist, artifacts) {
+	const request = normalizeDashboardFileRequest(input);
+	if (request.kind === "artifact") {
+		const filePath = resolveDashboardArtifactPath(request.path, allowlist.artifactPaths);
+		if (!filePath) throw new Error("必须传入合法的 kind 和相对路径。");
+		const file = artifacts.get(filePath);
+		if (!file) throw new Error("分析快照中没有此产物内容。");
+		if (file.error || file.content === void 0) throw new Error(file.error ?? "分析快照中没有此产物内容。");
+		return {
+			kind: request.kind,
+			path: filePath,
+			language: resolveDashboardFileLanguage(filePath),
+			size: file.size,
+			content: file.content
+		};
+	}
+	const resolvedCandidates = resolveDashboardSourceContentPaths(roots, request.path, allowlist.sourcePaths);
+	if (resolvedCandidates.length === 0) throw new Error("必须传入合法的 kind 和相对路径。");
+	const openedCandidates = [];
+	try {
+		for (const resolved of resolvedCandidates) try {
+			openedCandidates.push({
+				handle: await openDashboardFile(resolved),
+				resolved
+			});
+		} catch (error) {
+			if ((typeof error === "object" && error && "code" in error ? String(error.code) : "") !== "ENOENT") throw error;
+		}
+		if (openedCandidates.length === 0) throw new Error("文件不存在。");
+		if (openedCandidates.length > 1) throw new Error("源码路径存在多个候选文件，已拒绝读取。");
+		const [{ handle, resolved }] = openedCandidates;
+		const file = await readDashboardFileHandle(handle);
+		return {
+			kind: request.kind,
+			path: resolved.relativePath,
+			language: resolveDashboardFileLanguage(resolved.relativePath),
+			size: file.size,
+			content: file.content
+		};
+	} catch (error) {
+		if (error instanceof Error && (error.message === "文件不存在。" || error.message === "源码路径存在多个候选文件，已拒绝读取。" || error.message === "目标路径不是文件。" || error.message.startsWith("文件超过 ") || error.message.startsWith("文件路径"))) throw error;
+		throw new Error("读取文件失败。");
+	} finally {
+		await Promise.allSettled(openedCandidates.map((candidate) => candidate.handle.close()));
+	}
+}
+function createDashboardFileReader(roots, result, artifacts) {
+	let allowlist = createDashboardContentAllowlist(result);
+	let currentArtifacts = artifacts;
+	let disposed = false;
+	return {
+		read: async (input) => {
+			if (disposed || !currentArtifacts) throw new Error("Dashboard 文件读取会话已关闭。");
+			return await readAllowedDashboardFile(input, roots, allowlist, currentArtifacts);
+		},
+		update(nextResult, nextArtifacts) {
+			if (disposed) return;
+			allowlist = createDashboardContentAllowlist(nextResult);
+			currentArtifacts = nextArtifacts;
+		},
+		dispose() {
+			disposed = true;
+			currentArtifacts = void 0;
+			allowlist.artifactPaths.clear();
+			allowlist.sourcePaths.clear();
+		}
+	};
+}
+//#endregion
+//#region src/dashboard/events.ts
+function createDashboardRuntimeEvent(input) {
+	return {
+		id: `dashboard:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
+		kind: input.kind,
+		level: input.level,
+		title: input.title,
+		detail: input.detail,
+		timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false }),
+		source: input.source ?? "weapp-vite",
+		durationMs: input.durationMs,
+		tags: input.tags,
+		profile: input.profile
+	};
+}
+function prependDashboardRuntimeEvents(current, inputs) {
+	return [...inputs.map(createDashboardRuntimeEvent), ...current].slice(0, 24);
+}
+//#endregion
+//#region src/dashboard/payload.ts
+const MAX_DASHBOARD_ANALYZE_PAGE_CHARACTERS = 65536;
+const STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE = "Analyze revision 已变化，请重新获取 Dashboard 状态。";
+function serializeDashboardAnalyzePayload(result) {
+	const value = JSON.stringify(result);
+	return {
+		descriptor: {
+			characters: value.length,
+			hash: createHash("sha256").update(value).digest("hex"),
+			pages: Math.max(1, Math.ceil(value.length / MAX_DASHBOARD_ANALYZE_PAGE_CHARACTERS))
+		},
+		source: result,
+		value
+	};
+}
+function serializeDashboardAnalyzeSnapshot(snapshot, cached) {
+	const previous = snapshot.previous ? cached?.current.source === snapshot.previous ? cached.current : cached?.previous?.source === snapshot.previous ? cached.previous : serializeDashboardAnalyzePayload(snapshot.previous) : null;
+	return {
+		current: cached?.current.source === snapshot.current ? cached.current : serializeDashboardAnalyzePayload(snapshot.current),
+		previous
+	};
+}
+function normalizeAnalyzePageRequest(input) {
+	if (!input || typeof input !== "object") throw new Error("必须传入合法的 Analyze 分页请求。");
+	if (!("revision" in input) || !("target" in input) || !("index" in input)) throw new Error("必须传入合法的 Analyze 分页请求。");
+	const revision = input.revision;
+	const target = input.target;
+	const index = input.index;
+	if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0 || target !== "current" && target !== "previous" || typeof index !== "number" || !Number.isSafeInteger(index) || index < 0) throw new Error("必须传入合法的 Analyze 分页请求。");
+	return {
+		revision,
+		target,
+		index
+	};
+}
+function readDashboardAnalyzePage(input, revision, snapshot) {
+	const request = normalizeAnalyzePageRequest(input);
+	if (request.revision !== revision) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+	const payload = request.target === "current" ? snapshot.current : snapshot.previous;
+	if (!payload || request.index >= payload.descriptor.pages) throw new Error("Analyze 分页不存在。");
+	const start = request.index * MAX_DASHBOARD_ANALYZE_PAGE_CHARACTERS;
+	return {
+		content: payload.value.slice(start, start + MAX_DASHBOARD_ANALYZE_PAGE_CHARACTERS),
+		descriptor: payload.descriptor,
+		index: request.index,
+		revision,
+		target: request.target
+	};
+}
+//#endregion
+//#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
+		};
+	} 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;
+}
+function resolveDashboardRoot(options) {
+	const resolved = resolveDashboardPackage(options.cwd);
+	if (!resolved) return;
+	return options.watch ? resolveDashboardDevRoot(resolved.root, resolved.manifest) ?? resolveDashboardDistRoot(resolved.root, resolved.manifest) : resolveDashboardDistRoot(resolved.root, resolved.manifest) ?? resolveDashboardDevRoot(resolved.root, resolved.manifest);
+}
+/** 定位可选仪表盘包的原生构建 SPA；未安装或尚未构建时返回 undefined。 */
+function resolveDashboardClientAssets(cwd) {
+	const resolved = resolveDashboardPackage(cwd);
+	return resolved ? resolveDashboardDistRoot(resolved.root, resolved.manifest)?.root : void 0;
+}
+//#endregion
+//#region src/dashboard/index.ts
+const DEVFRAME_ID = "weapp-vite";
+/** 创建只读分析能力，不启动服务器，也不修改宿主的共享状态或认证策略。 */
+function createAnalyzeDashboardDevframe({ snapshot: initialSnapshot, roots, initialEvents = [], clientAssets }) {
+	let revision = 0;
+	let snapshot = initialSnapshot;
+	let serializedSnapshot = serializeDashboardAnalyzeSnapshot(initialSnapshot);
+	let runtimeEvents = initialEvents.map(createDashboardRuntimeEvent);
+	let broadcastDashboardState;
+	const fileReader = createDashboardFileReader(roots, initialSnapshot.current, initialSnapshot.artifacts);
+	function getState() {
+		if (!serializedSnapshot) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+		return {
+			analyze: {
+				current: serializedSnapshot.current.descriptor,
+				previous: serializedSnapshot.previous?.descriptor ?? null
+			},
+			revision,
+			runtimeEvents: [...runtimeEvents]
+		};
+	}
+	const getDashboardState = defineRpcFunction({
+		name: "get-dashboard-state",
+		type: "query",
+		jsonSerializable: true,
+		handler: getState
+	});
+	const getAnalyzePage = defineRpcFunction({
+		name: "get-analyze-page",
+		type: "query",
+		jsonSerializable: true,
+		handler: (input) => {
+			if (!serializedSnapshot) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+			return readDashboardAnalyzePage(input, revision, serializedSnapshot);
+		}
+	});
+	const readDashboardFile = defineRpcFunction({
+		name: "read-dashboard-file",
+		type: "query",
+		jsonSerializable: true,
+		handler: async (input) => {
+			if (!input || typeof input !== "object" || !("revision" in input) || typeof input.revision !== "number" || !Number.isSafeInteger(input.revision) || input.revision < 0) throw new Error("必须传入合法的文件读取 revision。");
+			const requestedRevision = input.revision;
+			if (!snapshot || requestedRevision !== revision) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+			const content = await fileReader.read(input);
+			if (!snapshot || requestedRevision !== revision) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+			return content;
+		}
+	});
+	return {
+		definition: defineDevframe({
+			id: DEVFRAME_ID,
+			name: "weapp-vite",
+			version: VERSION,
+			packageName: "weapp-vite",
+			importMetaUrl: import.meta.url,
+			homepage: "https://vite.weapp.dev/",
+			description: "weapp-vite 构建分析与小程序开发工具。",
+			icon: "ph:rocket-launch-duotone",
+			capabilities: {
+				dev: true,
+				build: false
+			},
+			clientAssets,
+			async setup(ctx) {
+				if (!snapshot) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+				const dashboard = ctx.scope(DEVFRAME_ID);
+				dashboard.rpc.register(getDashboardState);
+				dashboard.rpc.register(getAnalyzePage);
+				dashboard.rpc.register(readDashboardFile);
+				broadcastDashboardState = async () => {
+					await dashboard.rpc.broadcast({
+						method: "dashboard-state-updated",
+						args: [getState()],
+						event: true
+					});
+				};
+			}
+		}),
+		async update(result, artifacts, previousResult) {
+			if (!snapshot) return;
+			const nextSnapshot = {
+				current: result,
+				previous: previousResult ?? snapshot.current,
+				artifacts
+			};
+			const nextSerialized = serializeDashboardAnalyzeSnapshot(nextSnapshot, serializedSnapshot);
+			fileReader.update(result, artifacts);
+			snapshot = nextSnapshot;
+			serializedSnapshot = nextSerialized;
+			revision += 1;
+			runtimeEvents = prependDashboardRuntimeEvents(runtimeEvents, [{
+				kind: "build",
+				level: "info",
+				title: "analyze payload refreshed",
+				detail: `已推送新的 analyze 结果，当前包含 ${result.packages.length} 个包与 ${result.modules.length} 个模块。`,
+				tags: ["analyze", "refresh"]
+			}]);
+			await broadcastDashboardState?.();
+		},
+		emitRuntimeEvents(events) {
+			if (!snapshot || events.length === 0) return;
+			runtimeEvents = prependDashboardRuntimeEvents(runtimeEvents, events);
+			broadcastDashboardState?.();
+		},
+		dispose() {
+			if (!snapshot) return;
+			snapshot = void 0;
+			serializedSnapshot = void 0;
+			runtimeEvents = [];
+			broadcastDashboardState = void 0;
+			fileReader.dispose();
+		}
+	};
+}
+//#endregion
+export { createDashboardArtifactSnapshot as a, resolveDashboardRoot as i, ANALYZE_DASHBOARD_PACKAGE_NAME as n, resolveDashboardClientAssets as r, createAnalyzeDashboardDevframe as t };

package/dist/dashboard.d.mts

@@ -0,0 +1,2 @@
+import { a as resolveDashboardClientAssets, c as DashboardContentRoots, d as createDashboardArtifactSnapshot, f as AnalyzeSubpackagesResult, i as createAnalyzeDashboardDevframe, l as DashboardArtifactFile, n as CreateAnalyzeDashboardDevframeOptions, o as DashboardRuntimeEventInput, r as DashboardAnalyzeSnapshot, s as DashboardRuntimeEventProfile, t as AnalyzeDashboardDevframeController, u as DashboardArtifactFiles } from "./index-DbqVupg0.mjs";
+export { AnalyzeDashboardDevframeController, type AnalyzeSubpackagesResult, CreateAnalyzeDashboardDevframeOptions, DashboardAnalyzeSnapshot, type DashboardArtifactFile, type DashboardArtifactFiles, type DashboardContentRoots, type DashboardRuntimeEventInput, type DashboardRuntimeEventProfile, createAnalyzeDashboardDevframe, createDashboardArtifactSnapshot, resolveDashboardClientAssets };

package/dist/dashboard.mjs

@@ -0,0 +1,2 @@
+import { a as createDashboardArtifactSnapshot, r as resolveDashboardClientAssets, t as createAnalyzeDashboardDevframe } from "./dashboard-BzaVesmQ.mjs";
+export { createAnalyzeDashboardDevframe, createDashboardArtifactSnapshot, resolveDashboardClientAssets };