weapp-vite 7.3.0 → 7.5.0

package/dist/dashboard-DvqF3Key.mjs

@@ -0,0 +1,1842 @@
+import { t as VERSION } from "./constants-DEZdcsMn.mjs";
+import { i as createAnalyzeBudgetCheck, n as createModuleByteMap, r as createAnalyzeComparison, t as createDuplicateModuleInsights } from "./analyze-ZJUvEdaY.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "pathe";
+import fs from "node:fs";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { defineDevframe, defineRpcFunction } from "devframe";
+import { z } from "zod";
+//#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/excerpt.ts
+/** 按已校验的 UTF-16 范围截取内容，保留换行与代理项，不改变完整文件大小。 */
+function createDashboardFileExcerpt(content, range) {
+	if (!range) return { content };
+	const totalCharacters = content.length;
+	if (range.offset > totalCharacters) throw new RangeError("文件读取偏移超出内容范围。");
+	const end = Math.min(totalCharacters, range.offset + range.limit);
+	return {
+		content: content.slice(range.offset, end),
+		range: {
+			offset: range.offset,
+			totalCharacters,
+			nextOffset: end < totalCharacters ? end : null
+		}
+	};
+}
+//#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/investigations/schema.ts
+const id = z.string().uuid();
+const version = z.number().int().positive();
+const text = z.string().trim().min(1).max(4096);
+const path$1 = z.string().min(1).max(2048);
+const bytes = z.number().nonnegative().nullable();
+const reportIdentitySchema = z.strictObject({
+	sessionId: id,
+	revision: z.number().int().nonnegative(),
+	reportHash: z.string().regex(/^[a-f0-9]{64}$/)
+});
+const investigationTargetSchema = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("package"),
+		packageId: path$1
+	}),
+	z.strictObject({
+		kind: z.literal("artifact"),
+		packageId: path$1,
+		file: path$1
+	}),
+	z.strictObject({
+		kind: z.literal("module"),
+		packageId: path$1,
+		file: path$1,
+		moduleId: path$1
+	})
+]);
+const measurementsSchema = z.strictObject({
+	label: z.string(),
+	rawBytes: bytes,
+	gzipBytes: bytes,
+	brotliBytes: bytes,
+	attributedBytes: bytes,
+	sourceBytes: bytes
+});
+const investigationProposalInputSchema = z.strictObject({
+	summary: text,
+	changes: z.array(z.strictObject({
+		path: path$1,
+		description: text
+	})).min(1).max(64),
+	checks: z.array(text).min(1).max(32),
+	risks: z.array(text).max(32)
+});
+const investigationReceiptInputSchema = z.strictObject({
+	outcome: z.enum(["completed", "failed"]),
+	summary: text,
+	changedFiles: z.array(path$1).max(64),
+	checks: z.array(z.strictObject({
+		command: text,
+		outcome: z.enum([
+			"passed",
+			"failed",
+			"not-run"
+		]),
+		summary: text
+	})).max(32)
+});
+const investigationSchema = z.strictObject({
+	id,
+	version,
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
+	report: reportIdentitySchema,
+	target: investigationTargetSchema,
+	question: text,
+	evidence: measurementsSchema,
+	status: z.enum([
+		"submitted",
+		"claimed",
+		"proposed",
+		"authorized",
+		"executing",
+		"completed",
+		"failed",
+		"cancelled",
+		"stale",
+		"verified"
+	]),
+	agent: z.strictObject({
+		name: z.string().trim().min(1).max(120),
+		claimedAt: z.string().datetime()
+	}).nullable(),
+	proposal: investigationProposalInputSchema.extend({ id }).nullable(),
+	authorization: z.strictObject({
+		proposalId: id,
+		authorizedAt: z.string().datetime()
+	}).nullable(),
+	receipt: investigationReceiptInputSchema.extend({ reportedAt: z.string().datetime() }).nullable(),
+	verification: z.strictObject({
+		report: reportIdentitySchema,
+		summary: text,
+		after: measurementsSchema.nullable(),
+		verifiedAt: z.string().datetime()
+	}).nullable()
+});
+const investigationsStateSchema = z.strictObject({
+	version: z.number().int().nonnegative(),
+	items: z.array(investigationSchema).max(32)
+});
+const getInvestigationRequestSchema = z.strictObject({ id });
+const createInvestigationRequestSchema = z.strictObject({
+	report: reportIdentitySchema,
+	target: investigationTargetSchema,
+	question: text
+});
+const investigationRequestSchema = z.strictObject({
+	id,
+	version
+});
+const claimInvestigationRequestSchema = investigationRequestSchema.extend({ agentName: z.string().trim().min(1).max(120) });
+const investigationClaimSchema = z.strictObject({
+	investigation: investigationSchema,
+	claimToken: z.string().regex(/^[a-f0-9]{64}$/)
+});
+const agentInvestigationRequestSchema = investigationRequestSchema.extend({ claimToken: z.string().regex(/^[a-f0-9]{64}$/) });
+const proposeInvestigationRequestSchema = agentInvestigationRequestSchema.extend({ proposal: investigationProposalInputSchema });
+const authorizeInvestigationRequestSchema = investigationRequestSchema.extend({ proposalId: id });
+const completeInvestigationRequestSchema = agentInvestigationRequestSchema.extend({ receipt: investigationReceiptInputSchema });
+const verifyInvestigationRequestSchema = investigationRequestSchema.extend({
+	report: reportIdentitySchema,
+	summary: text
+});
+//#endregion
+//#region src/dashboard/schema.ts
+const nonnegativeInteger = z.number().int().nonnegative();
+const revisionSchema = nonnegativeInteger.describe("Revision from get-dashboard-state; refresh state if it becomes stale.");
+const analyzeTargetSchema = z.enum(["current", "previous"]);
+const analyzeDescriptorSchema = z.object({
+	characters: nonnegativeInteger,
+	hash: z.string(),
+	pages: z.number().int().positive()
+});
+const dashboardAnalyzePageRequestSchema = z.object({
+	index: nonnegativeInteger.describe("Zero-based page index, less than the selected descriptor pages count."),
+	revision: revisionSchema,
+	target: analyzeTargetSchema
+});
+const dashboardAnalyzePageSchema = z.object({
+	content: z.string(),
+	descriptor: analyzeDescriptorSchema,
+	index: nonnegativeInteger,
+	revision: revisionSchema,
+	target: analyzeTargetSchema
+});
+const dashboardFileRangeRequestSchema = z.object({
+	offset: nonnegativeInteger.describe("Zero-based UTF-16 code-unit offset; the content length is a valid EOF offset."),
+	limit: z.number().int().min(1).max(16384).describe("Maximum number of UTF-16 code units to return.")
+});
+const dashboardFileRangeSchema = z.object({
+	offset: nonnegativeInteger,
+	totalCharacters: nonnegativeInteger,
+	nextOffset: nonnegativeInteger.nullable()
+});
+const dashboardFileRequestSchema = z.object({
+	kind: z.enum(["source", "artifact"]),
+	path: z.string().describe("Report-listed relative path; source uses configured roots and artifact uses captured build content."),
+	range: dashboardFileRangeRequestSchema.optional()
+});
+const dashboardFileReadRequestSchema = dashboardFileRequestSchema.extend({ revision: revisionSchema });
+const dashboardFileContentSchema = dashboardFileRequestSchema.extend({
+	content: z.string(),
+	language: z.string(),
+	size: nonnegativeInteger,
+	range: dashboardFileRangeSchema.optional()
+});
+const runtimeEventProfileSchema = z.object({
+	timestamp: z.string().optional(),
+	totalMs: z.number().optional(),
+	eventId: z.string().optional(),
+	event: z.string().optional(),
+	file: z.string().optional(),
+	relativeFile: z.string().optional(),
+	sourceRootFile: z.string().optional(),
+	buildCoreMs: z.number().optional(),
+	buildStartMs: z.number().optional(),
+	pluginResolveMs: z.number().optional(),
+	transformMs: z.number().optional(),
+	snapshotResolveMs: z.number().optional(),
+	snapshotBuildMs: z.number().optional(),
+	writeMs: z.number().optional(),
+	watchToDirtyMs: z.number().optional(),
+	emitMs: z.number().optional(),
+	sharedChunkResolveMs: z.number().optional(),
+	resolveCount: z.number().optional(),
+	dirtyCount: z.number().optional(),
+	pendingCount: z.number().optional(),
+	emittedCount: z.number().optional(),
+	dirtyReasonSummary: z.array(z.string()).optional(),
+	pendingReasonSummary: z.array(z.string()).optional()
+});
+const dashboardRuntimeEventSchema = z.object({
+	id: z.string(),
+	timestamp: z.string(),
+	occurredAt: z.string().datetime(),
+	source: z.string(),
+	kind: z.enum([
+		"command",
+		"build",
+		"diagnostic",
+		"hmr",
+		"system"
+	]),
+	level: z.enum([
+		"info",
+		"success",
+		"warning",
+		"error"
+	]),
+	title: z.string(),
+	detail: z.string(),
+	durationMs: z.number().optional(),
+	tags: z.array(z.string()).optional(),
+	profile: runtimeEventProfileSchema.optional()
+});
+const dashboardStateSchema = z.object({
+	sessionId: z.string().uuid(),
+	investigations: investigationsStateSchema,
+	analyze: z.object({
+		current: analyzeDescriptorSchema,
+		previous: analyzeDescriptorSchema.nullable()
+	}),
+	revision: revisionSchema,
+	runtimeEvents: z.array(dashboardRuntimeEventSchema)
+});
+//#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";
+}
+async function readAllowedDashboardFile(input, roots, allowlist, artifacts) {
+	const request = dashboardFileRequestSchema.parse(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,
+			...createDashboardFileExcerpt(file.content, request.range)
+		};
+	}
+	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,
+			...createDashboardFileExcerpt(file.content, request.range)
+		};
+	} catch (error) {
+		if (error instanceof Error && (error.message === "文件不存在。" || error instanceof RangeError || 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();
+		}
+	};
+}
+const occurredAtFilterSchema = z.string().datetime({ offset: true }).describe("Inclusive ISO timestamp with Z or an explicit timezone offset.");
+const dashboardRuntimeEventsQueryRequestSchema = z.object({
+	kind: dashboardRuntimeEventSchema.shape.kind.optional(),
+	level: dashboardRuntimeEventSchema.shape.level.optional(),
+	source: z.string().optional().describe("Exact event source, case-sensitive."),
+	query: z.string().optional().describe("Case-insensitive text in title, detail, kind, level, source or tags."),
+	since: occurredAtFilterSchema.optional(),
+	until: occurredAtFilterSchema.optional(),
+	limit: z.number().int().min(1).max(24).optional()
+}).refine((input) => !input.since || !input.until || Date.parse(input.since) <= Date.parse(input.until), {
+	message: "事件查询的 since 不得晚于 until。",
+	path: ["until"]
+});
+const dashboardRuntimeEventsPageSchema = z.object({
+	items: z.array(dashboardRuntimeEventSchema).max(24),
+	total: z.number().int().nonnegative().max(24),
+	retention: z.object({
+		capacity: z.literal(24),
+		retained: z.number().int().nonnegative().max(24),
+		dropped: z.number().int().nonnegative(),
+		oldestOccurredAt: dashboardRuntimeEventSchema.shape.occurredAt.nullable()
+	})
+});
+function matchesEventText(event, query) {
+	return [
+		event.title,
+		event.detail,
+		event.kind,
+		event.level,
+		event.source,
+		...event.tags ?? []
+	].join(" ").toLowerCase().includes(query);
+}
+/** 查询当前保留的事件；匹配总数与丢弃计数不受返回条数影响。 */
+function queryDashboardRuntimeEvents(events, dropped, input) {
+	const request = dashboardRuntimeEventsQueryRequestSchema.parse(input);
+	const since = request.since === void 0 ? void 0 : Date.parse(request.since);
+	const until = request.until === void 0 ? void 0 : Date.parse(request.until);
+	const query = request.query?.trim().toLowerCase();
+	const limit = request.limit ?? 24;
+	const items = [];
+	let total = 0;
+	let oldestOccurredAt = null;
+	for (const event of events) {
+		if (oldestOccurredAt === null || event.occurredAt < oldestOccurredAt) oldestOccurredAt = event.occurredAt;
+		if (request.kind !== void 0 && event.kind !== request.kind) continue;
+		if (request.level !== void 0 && event.level !== request.level) continue;
+		if (request.source !== void 0 && event.source !== request.source) continue;
+		if (since !== void 0 || until !== void 0) {
+			const occurredAt = Date.parse(event.occurredAt);
+			if (since !== void 0 && occurredAt < since || until !== void 0 && occurredAt > until) continue;
+		}
+		if (query && !matchesEventText(event, query)) continue;
+		total++;
+		if (items.length < limit) items.push(event);
+	}
+	return {
+		items,
+		total,
+		retention: {
+			capacity: 24,
+			retained: events.length,
+			dropped,
+			oldestOccurredAt
+		}
+	};
+}
+//#endregion
+//#region src/dashboard/events.ts
+function createDashboardRuntimeEvent(input) {
+	const occurredAt = /* @__PURE__ */ new Date();
+	return {
+		id: `dashboard:${occurredAt.getTime()}:${Math.random().toString(36).slice(2, 8)}`,
+		kind: input.kind,
+		level: input.level,
+		title: input.title,
+		detail: input.detail,
+		timestamp: occurredAt.toLocaleTimeString("zh-CN", { hour12: false }),
+		occurredAt: occurredAt.toISOString(),
+		source: input.source ?? "weapp-vite",
+		durationMs: input.durationMs,
+		tags: input.tags,
+		profile: input.profile
+	};
+}
+/** 在当前宿主会话内保留有限事件，不伪造已丢弃的历史。 */
+function createDashboardRuntimeEventStore(initialInputs) {
+	let events = [];
+	let dropped = 0;
+	let disposed = false;
+	function assertActive() {
+		if (disposed) throw new Error("Dashboard 事件会话已关闭。");
+	}
+	function prepend(inputs) {
+		if (disposed || inputs.length === 0) return;
+		dropped += Math.max(0, events.length + inputs.length - 24);
+		const next = [];
+		for (let index = 0; index < Math.min(inputs.length, 24); index++) next.push(createDashboardRuntimeEvent(inputs[index]));
+		for (let index = 0; index < events.length && next.length < 24; index++) next.push(events[index]);
+		events = next;
+	}
+	prepend(initialInputs);
+	return {
+		read() {
+			assertActive();
+			return [...events];
+		},
+		prepend,
+		query(input) {
+			assertActive();
+			return queryDashboardRuntimeEvents(events, dropped, input);
+		},
+		dispose() {
+			disposed = true;
+			events = [];
+		}
+	};
+}
+//#endregion
+//#region src/dashboard/investigations/rpc.ts
+/** 浏览器所有者操作刻意不声明 agent，由 DevFrame 的默认拒绝边界隔离。 */
+function createDashboardInvestigationRpc(store) {
+	return [
+		defineRpcFunction({
+			name: "list-investigations",
+			type: "query",
+			jsonSerializable: true,
+			args: [],
+			returns: investigationsStateSchema,
+			agent: {
+				title: "List object investigations",
+				safety: "read",
+				description: "Read up to 32 session-local investigation records. Tasks pin session, revision, report hash and exact report placement. Agent names and receipts are self-reported, not authentication or independent verification."
+			},
+			handler: store.list
+		}),
+		defineRpcFunction({
+			name: "get-investigation",
+			type: "query",
+			jsonSerializable: true,
+			args: [getInvestigationRequestSchema],
+			returns: investigationSchema,
+			agent: {
+				title: "Read object investigation",
+				safety: "read",
+				description: "Read a task, its current CAS version, exact proposal and browser authorization. Private claim tokens are never present in task state. Re-read after a version conflict; do not replay actions."
+			},
+			handler: store.get
+		}),
+		defineRpcFunction({
+			name: "create-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [createInvestigationRequestSchema],
+			returns: investigationSchema,
+			handler: store.create
+		}),
+		defineRpcFunction({
+			name: "cancel-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [investigationRequestSchema],
+			returns: investigationSchema,
+			handler: store.cancel
+		}),
+		defineRpcFunction({
+			name: "authorize-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [authorizeInvestigationRequestSchema],
+			returns: investigationSchema,
+			handler: store.authorize
+		}),
+		defineRpcFunction({
+			name: "verify-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [verifyInvestigationRequestSchema],
+			returns: investigationSchema,
+			handler: store.verify
+		}),
+		defineRpcFunction({
+			name: "claim-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [claimInvestigationRequestSchema],
+			returns: investigationClaimSchema,
+			agent: {
+				title: "Claim object investigation",
+				safety: "action",
+				description: "Claim a submitted task using its current id/version and a self-reported agentName. Only the winning claim returns a private claimToken; keep it private. This changes task metadata only, not source files or execution permissions."
+			},
+			handler: store.claim
+		}),
+		defineRpcFunction({
+			name: "propose-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [proposeInvestigationRequestSchema],
+			returns: investigationSchema,
+			agent: {
+				title: "Propose investigation changes",
+				safety: "action",
+				description: "Submit exact proposed paths, descriptions, checks and risks using id/version/claimToken. Proposals may be replaced before browser authorization only. Report hashes identify reports, not current source contents; obtain external OS/workspace permission separately."
+			},
+			handler: store.propose
+		}),
+		defineRpcFunction({
+			name: "start-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [agentInvestigationRequestSchema],
+			returns: investigationSchema,
+			agent: {
+				title: "Start authorized investigation",
+				safety: "action",
+				description: "Consume the current exact browser-authorized proposal once with id/version/claimToken. Rejects stale reports and replay. Only records execution intent: no commands or filesystem writes run here; actual work and OS permissions remain external."
+			},
+			handler: store.start
+		}),
+		defineRpcFunction({
+			name: "complete-investigation",
+			type: "action",
+			jsonSerializable: true,
+			args: [completeInvestigationRequestSchema],
+			returns: investigationSchema,
+			agent: {
+				title: "Report external investigation result",
+				safety: "action",
+				description: "Report external completion or failure with changedFiles and actual check outcomes using id/version/claimToken. Rebuilds during execution are allowed; cancelled tasks reject receipts. A receipt is self-reported and never marks human verification complete."
+			},
+			handler: store.complete
+		})
+	];
+}
+//#endregion
+//#region src/dashboard/investigations/target.ts
+/** 不把缺失测量计为零，也不混合原始、压缩与模块归因体积。 */
+function sumMeasured(files, key) {
+	let total = 0;
+	for (const file of files) {
+		if (file[key] === void 0) return null;
+		total += file[key];
+	}
+	return total;
+}
+/** 只解析报告中真实存在的包、产物及精确模块放置关系，不访问文件系统。 */
+function resolveInvestigationTarget(result, target) {
+	const pkg = result.packages.find((pkg) => pkg.id === target.packageId);
+	if (!pkg) return null;
+	if (target.kind === "package") return {
+		label: pkg.label,
+		rawBytes: sumMeasured(pkg.files, "size"),
+		gzipBytes: sumMeasured(pkg.files, "gzipSize"),
+		brotliBytes: sumMeasured(pkg.files, "brotliSize"),
+		attributedBytes: null,
+		sourceBytes: null
+	};
+	const file = pkg.files.find((file) => file.file === target.file);
+	if (!file) return null;
+	if (target.kind === "artifact") return {
+		label: file.file,
+		rawBytes: file.size ?? null,
+		gzipBytes: file.gzipSize ?? null,
+		brotliBytes: file.brotliSize ?? null,
+		attributedBytes: null,
+		sourceBytes: null
+	};
+	const occurrence = file.modules?.find((module) => module.id === target.moduleId);
+	const placement = occurrence ? void 0 : result.modules.find((module) => module.id === target.moduleId && module.packages.some((placement) => placement.packageId === pkg.id && placement.files.includes(file.file)));
+	if (!occurrence && !placement) return null;
+	return {
+		label: occurrence?.source ?? placement.source,
+		rawBytes: null,
+		gzipBytes: null,
+		brotliBytes: null,
+		attributedBytes: occurrence?.bytes ?? null,
+		sourceBytes: occurrence?.originalBytes ?? null
+	};
+}
+//#endregion
+//#region src/dashboard/investigations/store.ts
+const terminal = {
+	completed: true,
+	failed: true,
+	cancelled: true,
+	stale: true,
+	verified: true
+};
+/** 会话内唯一任务所有者；同步完成校验与 CAS 提交，再通知传输层。 */
+function createDashboardInvestigationStore(readReport, onChange) {
+	const entries = /* @__PURE__ */ new Map();
+	let version = 0;
+	function requireCurrent(identity) {
+		const current = readReport();
+		if (identity.sessionId !== current.identity.sessionId || identity.revision !== current.identity.revision || identity.reportHash !== current.identity.reportHash) throw new Error("Investigation report is stale; refresh the Dashboard report.");
+		return current.result;
+	}
+	function getEntry(id) {
+		readReport();
+		const entry = entries.get(id);
+		if (!entry) throw new Error("Investigation does not exist in this Dashboard session.");
+		return entry;
+	}
+	function requireVersion(input, statuses) {
+		const entry = getEntry(input.id);
+		if (entry.task.version !== input.version) throw new Error("Investigation version conflict; refresh the task before retrying.");
+		if (!statuses.includes(entry.task.status)) throw new Error(`Investigation cannot transition from ${entry.task.status}.`);
+		return entry;
+	}
+	function requireAgent(input, statuses) {
+		const entry = requireVersion(input, statuses);
+		if (!entry.claimToken || entry.claimToken !== input.claimToken) throw new Error("Invalid investigation claim token.");
+		return entry;
+	}
+	function commit(entry, status) {
+		entry.task.status = status;
+		entry.task.version += 1;
+		entry.task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		version += 1;
+		if (terminal[status]) delete entry.claimToken;
+		onChange();
+		return structuredClone(entry.task);
+	}
+	return {
+		list() {
+			readReport();
+			return {
+				version,
+				items: Array.from(entries.values(), (entry) => structuredClone(entry.task))
+			};
+		},
+		get(input) {
+			const { id } = getInvestigationRequestSchema.parse(input);
+			return structuredClone(getEntry(id).task);
+		},
+		create(input) {
+			const request = createInvestigationRequestSchema.parse(input);
+			const evidence = resolveInvestigationTarget(requireCurrent(request.report), request.target);
+			if (!evidence) throw new Error("Investigation target is not present in the current report placement.");
+			if (entries.size === 32) {
+				const oldestTerminal = Array.from(entries.values()).find((entry) => terminal[entry.task.status]);
+				if (!oldestTerminal) throw new Error("Dashboard already has 32 active investigations; cancel one before submitting another.");
+				entries.delete(oldestTerminal.task.id);
+			}
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const task = {
+				id: randomUUID(),
+				version: 1,
+				createdAt: now,
+				updatedAt: now,
+				report: request.report,
+				target: request.target,
+				question: request.question,
+				evidence,
+				status: "submitted",
+				agent: null,
+				proposal: null,
+				authorization: null,
+				receipt: null,
+				verification: null
+			};
+			entries.set(task.id, { task });
+			version += 1;
+			onChange();
+			return structuredClone(task);
+		},
+		cancel(input) {
+			const entry = requireVersion(investigationRequestSchema.parse(input), [
+				"submitted",
+				"claimed",
+				"proposed",
+				"authorized",
+				"executing"
+			]);
+			entry.task.authorization = null;
+			return commit(entry, "cancelled");
+		},
+		claim(input) {
+			const request = claimInvestigationRequestSchema.parse(input);
+			const entry = requireVersion(request, ["submitted"]);
+			requireCurrent(entry.task.report);
+			const claimToken = randomBytes(32).toString("hex");
+			entry.claimToken = claimToken;
+			entry.task.agent = {
+				name: request.agentName,
+				claimedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			return {
+				investigation: commit(entry, "claimed"),
+				claimToken
+			};
+		},
+		propose(input) {
+			const request = proposeInvestigationRequestSchema.parse(input);
+			const entry = requireAgent(request, ["claimed", "proposed"]);
+			requireCurrent(entry.task.report);
+			entry.task.proposal = {
+				...request.proposal,
+				id: randomUUID()
+			};
+			return commit(entry, "proposed");
+		},
+		authorize(input) {
+			const request = authorizeInvestigationRequestSchema.parse(input);
+			const entry = requireVersion(request, ["proposed"]);
+			requireCurrent(entry.task.report);
+			if (entry.task.proposal?.id !== request.proposalId) throw new Error("Investigation proposal changed; review the exact current proposal.");
+			entry.task.authorization = {
+				proposalId: request.proposalId,
+				authorizedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			return commit(entry, "authorized");
+		},
+		start(input) {
+			const entry = requireAgent(agentInvestigationRequestSchema.parse(input), ["authorized"]);
+			requireCurrent(entry.task.report);
+			if (!entry.task.proposal || entry.task.authorization?.proposalId !== entry.task.proposal.id) throw new Error("The exact investigation proposal has not been authorized.");
+			return commit(entry, "executing");
+		},
+		complete(input) {
+			const request = completeInvestigationRequestSchema.parse(input);
+			const entry = requireAgent(request, ["executing"]);
+			entry.task.receipt = {
+				...request.receipt,
+				reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			return commit(entry, request.receipt.outcome);
+		},
+		verify(input) {
+			const request = verifyInvestigationRequestSchema.parse(input);
+			const entry = requireVersion(request, ["completed"]);
+			const result = requireCurrent(request.report);
+			if (request.report.revision <= entry.task.report.revision) throw new Error("Human verification requires a newer report than the investigation baseline.");
+			entry.task.verification = {
+				report: request.report,
+				summary: request.summary,
+				after: resolveInvestigationTarget(result, entry.task.target),
+				verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			return commit(entry, "verified");
+		},
+		reportUpdated() {
+			for (const entry of entries.values()) if ([
+				"submitted",
+				"claimed",
+				"proposed",
+				"authorized"
+			].includes(entry.task.status)) {
+				entry.task.status = "stale";
+				entry.task.version += 1;
+				entry.task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+				entry.task.authorization = null;
+				delete entry.claimToken;
+				version += 1;
+			}
+		},
+		dispose() {
+			entries.clear();
+			version = 0;
+		}
+	};
+}
+const dashboardLogo = `data:image/svg+xml,${encodeURIComponent(`<svg width="36" height="35" viewBox="0 0 36 35" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M35.0904 5.15683L18.9345 33.6611C18.6009 34.2496 17.744 34.253 17.4054 33.6674L0.929122 5.15958C0.560269 4.52138 1.11338 3.74834 1.84637 3.8776L18.0196 6.72991C18.1227 6.7481 18.2284 6.74793 18.3315 6.72938L34.1665 3.88169C34.8971 3.75032 35.4528 4.51737 35.0904 5.15683Z" fill="url(#paint0_linear_3_14)"/>
+<path d="M27.852 15.3948L18.0994 29.6346C17.996 29.7856 17.8465 29.8987 17.6735 29.9568C17.5005 30.0148 17.3135 30.0143 17.1409 29.956C16.9682 29.8974 16.8194 29.7837 16.7169 29.6325C16.6144 29.4809 16.5639 29.3 16.573 29.1171L16.7169 22.5L10.6621 19.9057C10.5274 19.8769 10.402 19.8151 10.2968 19.7259C10.1916 19.6367 10.11 19.5227 10.0592 19.3941C10.0083 19.2655 9.98983 19.1262 10.0053 18.9886C10.0208 18.851 10.0698 18.7193 10.1479 18.6052L19.9006 4.36535C20.004 4.21429 20.1536 4.10122 20.3266 4.04325C20.4996 3.98528 20.6866 3.98558 20.8592 4.04415C21.0319 4.10269 21.1807 4.21628 21.2832 4.3677C21.3857 4.51909 21.4362 4.70002 21.427 4.88305V12L27.3379 14.0944C27.4725 14.1232 27.598 14.185 27.7033 14.2742C27.8085 14.3635 27.89 14.4775 27.9408 14.6061C27.9918 14.7347 28.0101 14.8739 27.9947 15.0115C27.9793 15.1491 27.9302 15.2807 27.852 15.3948Z" fill="#FACC15"/>
+<path d="M20.5083 13.0001C21.8824 13.0001 23 13.9633 23 15.1542C23 15.5243 22.8853 15.8865 22.6783 16.2129C22.365 16.6897 21.8638 17.0427 21.2575 17.2107C21.1289 17.2489 20.9952 17.2696 20.8604 17.272C20.7986 17.2731 20.7373 17.2625 20.68 17.2408C20.6226 17.2191 20.5704 17.1867 20.5264 17.1457C20.4824 17.1046 20.4475 17.0556 20.4237 17.0016C20.3999 16.9475 20.3878 16.8895 20.3879 16.831C20.3879 16.583 20.596 16.3905 20.8604 16.3905C20.8789 16.3905 20.9178 16.3905 20.965 16.3734C21.3722 16.2667 21.694 16.047 21.8739 15.7547C21.9966 15.5702 22.0539 15.3654 22.0539 15.1542C22.0539 14.4555 21.3621 13.8833 20.5184 13.8833C20.2274 13.8837 19.9412 13.9534 19.686 14.086C19.2394 14.3238 18.975 14.7206 18.975 15.1542V18.8534C18.975 19.6032 18.529 20.2923 17.7899 20.6811C17.3928 20.8928 16.9462 21 16.4917 21C15.1182 21 14 20.0363 14 18.8454C14 18.4758 14.1153 18.1131 14.3217 17.7867C14.635 17.3099 15.1367 16.9569 15.7425 16.7894C15.9124 16.7451 16.0271 16.7281 16.1396 16.7281C16.4057 16.7281 16.6126 16.9227 16.6126 17.1686C16.6128 17.2271 16.6006 17.2851 16.5769 17.3392C16.5531 17.3932 16.5182 17.4422 16.4742 17.4833C16.4302 17.5243 16.378 17.5567 16.3206 17.5784C16.2633 17.6001 16.2019 17.6107 16.1402 17.6096C16.1211 17.6096 16.0822 17.6096 16.0356 17.6267C15.6278 17.7414 15.3066 17.9627 15.1266 18.2448C15.0034 18.4299 14.9466 18.6342 14.9466 18.8459C14.9466 19.5446 15.6385 20.1163 16.49 20.1163C16.7812 20.1161 17.0676 20.0466 17.323 19.9141C17.7691 19.6757 18.0334 19.279 18.0334 18.8459V15.1558C18.0334 14.4059 18.4795 13.7174 19.2185 13.3281C19.609 13.1095 20.0549 12.9961 20.5083 13.0001Z" fill="white"/>
+<defs>
+<linearGradient id="paint0_linear_3_14" x1="0.526842" y1="2.8589" x2="20.2854" y2="30.0554" gradientUnits="userSpaceOnUse">
+<stop stop-color="#95EC69"/>
+<stop offset="1" stop-color="#2BA245"/>
+</linearGradient>
+</defs>
+</svg>`)}`;
+//#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 readDashboardAnalyzePage(input, revision, snapshot) {
+	const request = dashboardAnalyzePageRequestSchema.parse(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/queries/schema.ts
+const count = z.number().int().nonnegative();
+const packageType = z.enum([
+	"main",
+	"subPackage",
+	"independent",
+	"virtual"
+]);
+const sourceType = z.enum([
+	"src",
+	"plugin",
+	"node_modules",
+	"workspace"
+]);
+const change = z.enum([
+	"added",
+	"removed",
+	"increased",
+	"decreased",
+	"unmeasured"
+]);
+const query = z.string().trim().max(200).optional();
+const revision = count.describe("Revision from get-dashboard-state; refresh state when stale.");
+const target = z.enum(["current", "previous"]);
+const pagination = {
+	offset: count.default(0),
+	limit: z.number().int().min(1).max(100).default(20)
+};
+const pageResult = {
+	total: count,
+	offset: count,
+	nextOffset: count.nullable()
+};
+const reportResult = {
+	revision,
+	target,
+	reportHash: z.string()
+};
+const order = z.enum(["asc", "desc"]).default("desc");
+const analyzeQuerySchema = z.object({
+	revision,
+	target: target.default("current")
+});
+const budgetCheckSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	scope: z.enum([
+		"total",
+		"runtime",
+		"main",
+		"subPackage",
+		"independent",
+		"virtual"
+	]),
+	currentBytes: count,
+	limitBytes: count,
+	ratio: z.number(),
+	status: z.enum([
+		"ok",
+		"warning",
+		"exceeded",
+		"unknown"
+	]),
+	measurement: z.enum([
+		"file-bytes",
+		"upper-bound",
+		"unavailable"
+	])
+});
+const analyzeSummarySchema = z.object({
+	...reportResult,
+	previousAvailable: z.boolean(),
+	totals: z.object({
+		packages: count,
+		files: count,
+		modules: count,
+		bytes: count,
+		unmeasuredFiles: count
+	}),
+	totalBudget: budgetCheckSchema.nullable(),
+	runtimeBudget: budgetCheckSchema.nullable(),
+	packageBudgets: z.object({
+		ok: count,
+		warning: count,
+		exceeded: count,
+		unknown: count
+	})
+});
+const packagesQuerySchema = analyzeQuerySchema.extend({
+	...pagination,
+	type: packageType.optional(),
+	query,
+	budgetStatus: z.enum([
+		"ok",
+		"warning",
+		"exceeded",
+		"unknown"
+	]).optional(),
+	sortBy: z.enum([
+		"bytes",
+		"name",
+		"budgetRatio"
+	]).default("bytes"),
+	order
+});
+const packagesPageSchema = z.object({
+	...reportResult,
+	...pageResult,
+	items: z.array(z.object({
+		id: z.string(),
+		label: z.string(),
+		type: packageType,
+		bytes: count,
+		fileCount: count,
+		moduleCount: count,
+		unmeasuredFiles: count,
+		budget: budgetCheckSchema.nullable()
+	}))
+});
+const artifactsQuerySchema = analyzeQuerySchema.extend({
+	...pagination,
+	packageId: z.string().optional(),
+	moduleId: z.string().optional().describe("Exact module id from query-analyze-modules; returns its artifact placements."),
+	type: z.enum(["chunk", "asset"]).optional(),
+	query,
+	sortBy: z.enum(["size", "path"]).default("size"),
+	order
+});
+const artifactsPageSchema = z.object({
+	...reportResult,
+	...pageResult,
+	items: z.array(z.object({
+		packageId: z.string(),
+		packageType,
+		file: z.string(),
+		type: z.enum(["chunk", "asset"]),
+		from: z.enum(["main", "independent"]),
+		size: count.nullable(),
+		gzipSize: count.optional(),
+		brotliSize: count.optional(),
+		isEntry: z.boolean().optional(),
+		moduleCount: count,
+		source: z.string().optional(),
+		sourceType: sourceType.optional()
+	}))
+});
+const modulesQuerySchema = analyzeQuerySchema.extend({
+	...pagination,
+	packageId: z.string().optional(),
+	artifact: z.string().optional(),
+	sourceType: sourceType.optional(),
+	query,
+	duplicateOnly: z.boolean().default(false),
+	sortBy: z.enum([
+		"bytes",
+		"estimatedSavingBytes",
+		"source"
+	]).default("bytes"),
+	order
+});
+const modulesPageSchema = z.object({
+	...reportResult,
+	...pageResult,
+	items: z.array(z.object({
+		id: z.string(),
+		source: z.string(),
+		sourceType,
+		bytes: count.describe("Largest known module occurrence, not the sum of all copies."),
+		packageCount: count,
+		fileCount: count,
+		estimatedSavingBytes: count.describe("Upper-level duplication estimate, not guaranteed removable output bytes."),
+		hasIndependentPackage: z.boolean(),
+		advice: z.string().optional()
+	}))
+});
+const comparisonQuerySchema = z.object({
+	revision,
+	...pagination,
+	scope: z.enum([
+		"package",
+		"file",
+		"module"
+	]).describe("Module scope compares recorded chunk contributions by canonical source, not all asset/source placements."),
+	packageId: z.string().optional(),
+	change: change.optional(),
+	query
+});
+const comparisonPageSchema = z.object({
+	revision,
+	currentHash: z.string(),
+	previousHash: z.string().nullable(),
+	available: z.boolean(),
+	totals: z.object({
+		currentBytes: count.nullable(),
+		previousBytes: count.nullable(),
+		deltaBytes: z.number().int().nullable(),
+		currentUnmeasuredFiles: count,
+		previousUnmeasuredFiles: count
+	}).nullable(),
+	...pageResult,
+	items: z.array(z.object({
+		key: z.string(),
+		label: z.string(),
+		change,
+		currentBytes: count.nullable(),
+		previousBytes: count.nullable(),
+		deltaBytes: z.number().int().nullable(),
+		packageId: z.string().optional(),
+		packageLabel: z.string().optional(),
+		file: z.string().optional(),
+		moduleId: z.string().optional(),
+		sourceType: sourceType.optional(),
+		category: z.string().optional(),
+		advice: z.string().optional()
+	}))
+});
+//#endregion
+//#region src/dashboard/queries/shared.ts
+function summarizeBudget(item) {
+	if (!item) return null;
+	const { id, label, scope, currentBytes, limitBytes, ratio, status, measurement } = item;
+	return {
+		id,
+		label,
+		scope,
+		currentBytes,
+		limitBytes,
+		ratio,
+		status,
+		measurement
+	};
+}
+function selectAnalyzeReport(read, request) {
+	const snapshot = read(request.revision);
+	const payload = snapshot[request.target];
+	if (!payload) throw new Error("没有上一份分析快照。");
+	return {
+		result: payload.source,
+		context: {
+			revision: request.revision,
+			target: request.target,
+			reportHash: payload.descriptor.hash
+		},
+		previousAvailable: snapshot.previous !== null
+	};
+}
+function matchesQuery(query, ...values) {
+	if (!query) return true;
+	const needle = query.toLowerCase();
+	return values.some((value) => value?.toLowerCase().includes(needle));
+}
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function ordered(value, order) {
+	return order === "asc" ? value : -value;
+}
+function paginate(items, request) {
+	const end = Math.min(request.offset + request.limit, items.length);
+	return {
+		total: items.length,
+		offset: request.offset,
+		nextOffset: end < items.length ? end : null,
+		items: items.slice(request.offset, end)
+	};
+}
+function reportTotals(result) {
+	let bytes = 0;
+	let files = 0;
+	let unmeasuredFiles = 0;
+	for (const pkg of result.packages) {
+		files += pkg.files.length;
+		for (const file of pkg.files) {
+			bytes += file.size ?? 0;
+			unmeasuredFiles += file.size === void 0 ? 1 : 0;
+		}
+	}
+	return {
+		packages: result.packages.length,
+		files,
+		modules: result.modules.length,
+		bytes,
+		unmeasuredFiles
+	};
+}
+/** 模块归属以报告的 usage 为准；资源源码不一定出现在 chunk 的贡献列表中。 */
+function createModulePlacementIndex(result) {
+	const index = /* @__PURE__ */ new Map();
+	for (const module of result.modules) for (const usage of module.packages) {
+		let placement = index.get(usage.packageId);
+		if (!placement) {
+			placement = {
+				moduleIds: /* @__PURE__ */ new Set(),
+				files: /* @__PURE__ */ new Map()
+			};
+			index.set(usage.packageId, placement);
+		}
+		placement.moduleIds.add(module.id);
+		for (const file of usage.files) {
+			let modules = placement.files.get(file);
+			if (!modules) {
+				modules = /* @__PURE__ */ new Set();
+				placement.files.set(file, modules);
+			}
+			modules.add(module.id);
+		}
+	}
+	return index;
+}
+//#endregion
+//#region src/dashboard/queries/analysis.ts
+function getAnalyzeSummary(read, input) {
+	const { result, context, previousAvailable } = selectAnalyzeReport(read, analyzeQuerySchema.parse(input));
+	const budgets = createAnalyzeBudgetCheck(result);
+	const packageBudgets = {
+		ok: 0,
+		warning: 0,
+		exceeded: 0,
+		unknown: 0
+	};
+	for (const budget of budgets) if (budget.scope !== "total" && budget.scope !== "runtime") packageBudgets[budget.status] += 1;
+	return {
+		...context,
+		previousAvailable,
+		totals: reportTotals(result),
+		totalBudget: summarizeBudget(budgets.find((item) => item.scope === "total")),
+		runtimeBudget: summarizeBudget(budgets.find((item) => item.scope === "runtime")),
+		packageBudgets
+	};
+}
+function compareAnalyzeBuilds(read, input) {
+	const request = comparisonQuerySchema.parse(input);
+	const snapshot = read(request.revision);
+	const context = {
+		revision: request.revision,
+		currentHash: snapshot.current.descriptor.hash,
+		previousHash: snapshot.previous?.descriptor.hash ?? null
+	};
+	if (!snapshot.previous) return {
+		...context,
+		available: false,
+		totals: null,
+		total: 0,
+		offset: request.offset,
+		nextOffset: null,
+		items: []
+	};
+	const current = snapshot.current.source;
+	const previous = snapshot.previous.source;
+	const comparison = createAnalyzeComparison(request.packageId === void 0 ? current : { packages: current.packages.filter((pkg) => pkg.id === request.packageId) }, request.packageId === void 0 ? previous : { packages: previous.packages.filter((pkg) => pkg.id === request.packageId) });
+	const currentTotals = request.packageId === void 0 ? null : reportTotals(current);
+	const previousTotals = request.packageId === void 0 ? null : reportTotals(previous);
+	const currentUnmeasuredFiles = currentTotals?.unmeasuredFiles ?? comparison.currentUnmeasuredFiles;
+	const previousUnmeasuredFiles = previousTotals?.unmeasuredFiles ?? comparison.previousUnmeasuredFiles;
+	const currentBytes = currentUnmeasuredFiles > 0 ? null : currentTotals?.bytes ?? comparison.currentBytes;
+	const previousBytes = previousUnmeasuredFiles > 0 ? null : previousTotals?.bytes ?? comparison.previousBytes;
+	const items = comparison[request.scope === "package" ? "packages" : request.scope === "file" ? "files" : "modules"].filter((item) => (request.change === void 0 || item.change === request.change) && matchesQuery(request.query, item.label, item.file, item.moduleId, item.packageLabel));
+	items.sort((a, b) => (b.deltaBytes === null ? -1 : Math.abs(b.deltaBytes)) - (a.deltaBytes === null ? -1 : Math.abs(a.deltaBytes)) || compareText(a.key, b.key));
+	return {
+		...context,
+		available: true,
+		totals: {
+			currentBytes,
+			previousBytes,
+			deltaBytes: currentBytes === null || previousBytes === null ? null : currentBytes - previousBytes,
+			currentUnmeasuredFiles,
+			previousUnmeasuredFiles
+		},
+		...paginate(items, request)
+	};
+}
+//#endregion
+//#region src/dashboard/queries/catalog.ts
+function queryAnalyzePackages(read, input) {
+	const request = packagesQuerySchema.parse(input);
+	const { result, context } = selectAnalyzeReport(read, request);
+	const budgets = new Map(createAnalyzeBudgetCheck(result).filter((item) => item.scope !== "total" && item.scope !== "runtime").map((item) => [item.id, item]));
+	const placements = createModulePlacementIndex(result);
+	const items = [];
+	for (const pkg of result.packages) {
+		const budget = summarizeBudget(budgets.get(pkg.id));
+		if (request.type !== void 0 && pkg.type !== request.type || request.budgetStatus !== void 0 && budget?.status !== request.budgetStatus || !matchesQuery(request.query, pkg.id, pkg.label)) continue;
+		let bytes = 0;
+		let unmeasuredFiles = 0;
+		for (const file of pkg.files) {
+			bytes += file.size ?? 0;
+			unmeasuredFiles += file.size === void 0 ? 1 : 0;
+		}
+		items.push({
+			id: pkg.id,
+			label: pkg.label,
+			type: pkg.type,
+			bytes,
+			fileCount: pkg.files.length,
+			moduleCount: placements.get(pkg.id)?.moduleIds.size ?? 0,
+			unmeasuredFiles,
+			budget
+		});
+	}
+	items.sort((a, b) => {
+		return ordered(request.sortBy === "name" ? compareText(a.label, b.label) : request.sortBy === "budgetRatio" ? (a.budget?.ratio ?? -1) - (b.budget?.ratio ?? -1) : a.bytes - b.bytes, request.order) || compareText(a.id, b.id);
+	});
+	return {
+		...context,
+		...paginate(items, request)
+	};
+}
+function queryAnalyzeArtifacts(read, input) {
+	const request = artifactsQuerySchema.parse(input);
+	const { result, context } = selectAnalyzeReport(read, request);
+	const items = [];
+	const placements = createModulePlacementIndex(result);
+	for (const pkg of result.packages) {
+		if (request.packageId !== void 0 && pkg.id !== request.packageId) continue;
+		const moduleFiles = placements.get(pkg.id)?.files;
+		for (const file of pkg.files) {
+			if (request.type !== void 0 && file.type !== request.type || request.moduleId !== void 0 && !moduleFiles?.get(file.file)?.has(request.moduleId) || !matchesQuery(request.query, file.file, file.source)) continue;
+			items.push({
+				packageId: pkg.id,
+				packageType: pkg.type,
+				file: file.file,
+				type: file.type,
+				from: file.from,
+				size: file.size ?? null,
+				gzipSize: file.gzipSize,
+				brotliSize: file.brotliSize,
+				isEntry: file.isEntry,
+				moduleCount: moduleFiles?.get(file.file)?.size ?? 0,
+				source: file.source,
+				sourceType: file.sourceType
+			});
+		}
+	}
+	items.sort((a, b) => {
+		return ordered(request.sortBy === "path" ? compareText(a.file, b.file) : (a.size ?? -1) - (b.size ?? -1), request.order) || compareText(a.packageId, b.packageId) || compareText(a.file, b.file);
+	});
+	return {
+		...context,
+		...paginate(items, request)
+	};
+}
+function queryAnalyzeModules(read, input) {
+	const request = modulesQuerySchema.parse(input);
+	const { result, context } = selectAnalyzeReport(read, request);
+	const bytes = createModuleByteMap(result);
+	const duplicates = new Map(createDuplicateModuleInsights(result).map((item) => [item.id, item]));
+	const independentPackages = new Set(result.packages.filter((pkg) => pkg.type === "independent").map((pkg) => pkg.id));
+	const items = [];
+	for (const module of result.modules) {
+		const duplicate = duplicates.get(module.id);
+		if (request.sourceType !== void 0 && module.sourceType !== request.sourceType || request.duplicateOnly && !duplicate || !matchesQuery(request.query, module.id, module.source) || (request.packageId !== void 0 || request.artifact !== void 0) && !module.packages.some((pkg) => (request.packageId === void 0 || pkg.packageId === request.packageId) && (request.artifact === void 0 || pkg.files.includes(request.artifact)))) continue;
+		items.push({
+			id: module.id,
+			source: module.source,
+			sourceType: module.sourceType,
+			bytes: bytes.get(module.id) ?? 0,
+			packageCount: module.packages.length,
+			fileCount: module.packages.reduce((total, pkg) => total + pkg.files.length, 0),
+			estimatedSavingBytes: duplicate?.estimatedSavingBytes ?? 0,
+			hasIndependentPackage: duplicate?.hasIndependentPackage ?? module.packages.some((pkg) => independentPackages.has(pkg.packageId)),
+			advice: duplicate?.advice
+		});
+	}
+	items.sort((a, b) => {
+		return ordered(request.sortBy === "source" ? compareText(a.source, b.source) : a[request.sortBy] - b[request.sortBy], request.order) || compareText(a.id, b.id);
+	});
+	return {
+		...context,
+		...paginate(items, request)
+	};
+}
+//#endregion
+//#region src/dashboard/queries/index.ts
+function createDashboardAnalyzeQueries(read) {
+	return {
+		summary: defineRpcFunction({
+			name: "get-analyze-summary",
+			type: "query",
+			jsonSerializable: true,
+			args: [analyzeQuerySchema],
+			returns: analyzeSummarySchema,
+			agent: {
+				title: "Analyze summary and budgets",
+				safety: "read",
+				description: "Start diagnostics here: report totals, total budget and package budget-status counts without downloading JSON pages. Bytes sum known artifact sizes; unmeasuredFiles identifies incomplete size data. Use package queries to locate budget warnings."
+			},
+			handler: (input) => getAnalyzeSummary(read, input)
+		}),
+		packages: defineRpcFunction({
+			name: "query-analyze-packages",
+			type: "query",
+			jsonSerializable: true,
+			args: [packagesQuerySchema],
+			returns: packagesPageSchema,
+			agent: {
+				title: "Analyze packages",
+				safety: "read",
+				description: "Filter packages by type, name or budget status; sort by size, name or budget ratio. Returns bounded rows and nextOffset pinned to a report revision/hash. Select a package id to inspect artifacts and modules."
+			},
+			handler: (input) => queryAnalyzePackages(read, input)
+		}),
+		artifacts: defineRpcFunction({
+			name: "query-analyze-artifacts",
+			type: "query",
+			jsonSerializable: true,
+			args: [artifactsQuerySchema],
+			returns: artifactsPageSchema,
+			agent: {
+				title: "Analyze artifacts and module placements",
+				safety: "read",
+				description: "Find largest artifacts or locate an exact module id within emitted files. Filter by package, module, type or path. Rows omit nested module arrays. Read an artifact excerpt using read-dashboard-file with its file path and the current revision; previous artifacts are metadata only."
+			},
+			handler: (input) => queryAnalyzeArtifacts(read, input)
+		}),
+		modules: defineRpcFunction({
+			name: "query-analyze-modules",
+			type: "query",
+			jsonSerializable: true,
+			args: [modulesQuerySchema],
+			returns: modulesPageSchema,
+			agent: {
+				title: "Analyze modules and duplicates",
+				safety: "read",
+				description: "Filter modules by source, package, artifact or duplicate membership, then sort by bytes or estimated duplication savings. Bytes represent the largest known occurrence. Savings are estimates, not guaranteed removable bytes; independent packages may require isolation. Query artifacts with a module id for placements, not a source-import causal chain."
+			},
+			handler: (input) => queryAnalyzeModules(read, input)
+		}),
+		comparison: defineRpcFunction({
+			name: "compare-analyze-builds",
+			type: "query",
+			jsonSerializable: true,
+			args: [comparisonQuerySchema],
+			returns: comparisonPageSchema,
+			agent: {
+				title: "Compare current and previous builds",
+				safety: "read",
+				description: "Read bounded package, file or canonical-module additions, removals, growth and shrinkage, ordered by absolute delta. Totals always describe whole-build artifact sizes; module and file deltas overlap and must not be added together. No previous snapshot returns available:false and totals:null, not an empty baseline."
+			},
+			handler: (input) => compareAnalyzeBuilds(read, input)
+		})
+	};
+}
+//#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 }) {
+	const sessionId = randomUUID();
+	let revision = 0;
+	let snapshot = initialSnapshot;
+	let serializedSnapshot = serializeDashboardAnalyzeSnapshot(initialSnapshot);
+	const eventStore = createDashboardRuntimeEventStore(initialEvents);
+	let broadcastDashboardState;
+	const fileReader = createDashboardFileReader(roots, initialSnapshot.current, initialSnapshot.artifacts);
+	const queries = createDashboardAnalyzeQueries((requestedRevision) => {
+		if (!serializedSnapshot || requestedRevision !== revision) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+		return serializedSnapshot;
+	});
+	const investigations = createDashboardInvestigationStore(() => {
+		if (!snapshot || !serializedSnapshot) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+		return {
+			identity: {
+				sessionId,
+				revision,
+				reportHash: serializedSnapshot.current.descriptor.hash
+			},
+			result: snapshot.current
+		};
+	}, () => {
+		broadcastDashboardState?.();
+	});
+	const investigationRpc = createDashboardInvestigationRpc(investigations);
+	function getState() {
+		if (!serializedSnapshot) throw new Error(STALE_DASHBOARD_ANALYZE_REVISION_MESSAGE);
+		return {
+			sessionId,
+			investigations: investigations.list(),
+			analyze: {
+				current: serializedSnapshot.current.descriptor,
+				previous: serializedSnapshot.previous?.descriptor ?? null
+			},
+			revision,
+			runtimeEvents: eventStore.read()
+		};
+	}
+	const getDashboardState = defineRpcFunction({
+		name: "get-dashboard-state",
+		type: "query",
+		jsonSerializable: true,
+		args: [],
+		returns: dashboardStateSchema,
+		agent: {
+			title: "Dashboard state",
+			description: "Read the live Dashboard revision, report descriptors and recent runtime events. Use this revision with domain queries; start with get-analyze-summary instead of downloading whole report pages.",
+			safety: "read"
+		},
+		handler: getState
+	});
+	const getAnalyzePage = defineRpcFunction({
+		name: "get-analyze-page",
+		type: "query",
+		jsonSerializable: true,
+		args: [dashboardAnalyzePageRequestSchema],
+		returns: dashboardAnalyzePageSchema,
+		agent: {
+			title: "Analyze report page",
+			description: "Export one bounded JSON-text page of the current or previous report. Concatenate pages in index order; prefer domain summary, catalog and comparison queries for diagnostics.",
+			safety: "read"
+		},
+		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,
+		args: [dashboardFileReadRequestSchema],
+		returns: dashboardFileContentSchema,
+		agent: {
+			title: "Dashboard file content",
+			description: "Read a report-listed source or captured artifact at the current revision. Prefer range:{offset,limit} for bounded UTF-16 excerpts (limit <=16384); omit range only when full content is needed. Size is full UTF-8 bytes. Source files are live disk reads; artifacts come from the snapshot. Allowlist, symlink and file-size protections apply.",
+			safety: "read"
+		},
+		handler: async (input) => {
+			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;
+		}
+	});
+	const queryRuntimeEvents = defineRpcFunction({
+		name: "query-runtime-events",
+		type: "query",
+		jsonSerializable: true,
+		args: [dashboardRuntimeEventsQueryRequestSchema],
+		returns: dashboardRuntimeEventsPageSchema,
+		agent: {
+			title: "Recent runtime events",
+			description: "Filter the retained 24-event window by kind, level, source, text or inclusive ISO time bounds, including HMR profiles. Retention reports discarded events; this is not durable history and is independent of build revisions.",
+			safety: "read"
+		},
+		handler: (input) => eventStore.query(input)
+	});
+	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: dashboardLogo,
+			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);
+				dashboard.rpc.register(queries.summary);
+				dashboard.rpc.register(queries.packages);
+				dashboard.rpc.register(queries.artifacts);
+				dashboard.rpc.register(queries.modules);
+				dashboard.rpc.register(queries.comparison);
+				dashboard.rpc.register(queryRuntimeEvents);
+				for (const rpc of investigationRpc) dashboard.rpc.register(rpc);
+				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;
+			investigations.reportUpdated();
+			eventStore.prepend([{
+				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;
+			eventStore.prepend(events);
+			broadcastDashboardState?.();
+		},
+		dispose() {
+			if (!snapshot) return;
+			snapshot = void 0;
+			serializedSnapshot = void 0;
+			eventStore.dispose();
+			investigations.dispose();
+			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 };