@vitejs/devtools-rolldown 0.1.24 → 0.2.0

package/dist/index.mjs

@@ -3,58 +3,31 @@ import { createRequire } from "node:module";
 import { defineRpcFunction } from "@vitejs/devtools-kit";
 import fs, { existsSync } from "node:fs";
 import process$1 from "node:process";
-import { join } from "pathe";
-import { colors } from "devframe/utils/colors";
-import { consoleReporter, createLogger, defineDiagnostics } from "logs-sdk";
-import { ansiFormatter } from "logs-sdk/formatters/ansi";
+import { basename, dirname, join } from "pathe";
+import { defineDiagnostics, reporterLog } from "nostics";
 import fs$1 from "node:fs/promises";
-import { pipeline } from "node:stream/promises";
-import split2 from "split2";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { createHash } from "node:crypto";
+import { parseToEvent } from "@rolldown/debug";
 import { diffLines } from "diff";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-const logger = createLogger({
-	diagnostics: [defineDiagnostics({
-		docsBase: "https://devtools.vite.dev/errors",
-		codes: {
-			RDDT0001: {
-				message: "Rolldown logs directory `.rolldown` not found, you might want to run build with `build.rolldownOptions.devtools` enabled first.",
-				level: "warn"
-			},
-			RDDT0002: {
-				message: (p) => `JSON parse stream skip bad line ${p.line}: ${p.error}\n${p.preview}`,
-				level: "warn"
-			}
-		}
-	})],
-	formatter: ansiFormatter(colors),
-	reporters: consoleReporter
+//#endregion
+//#region src/node/diagnostics.ts
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devtools.vite.dev/errors",
+	reporters: [reporterLog],
+	codes: {
+		RDDT0001: { why: "Rolldown logs directory `.rolldown` not found, you might want to run build with `build.rolldownOptions.devtools` enabled first." },
+		RDDT0002: { why: (p) => `Rolldown log reader skipped bad line ${p.line}: ${p.error}\n${p.preview}` }
+	}
 });
 //#endregion
-//#region src/node/utils/json-parse-stream.ts
-async function parseJsonStreamWithConcatArrays(stream, processor) {
-	const values = [];
-	let lineNumber = 0;
-	await pipeline(stream, split2(), async (source) => {
-		for await (const line of source) {
-			lineNumber += 1;
-			if (!line) continue;
-			try {
-				const parsed = JSON.parse(line);
-				const result = processor ? processor(parsed) : parsed;
-				values.push(result);
-			} catch (e) {
-				const preview = line.length > 256 ? `${line.slice(0, 256)}...` : line;
-				logger.RDDT0002({
-					line: lineNumber,
-					error: e.message,
-					preview
-				}).log();
-			}
-		}
-	});
-	return values;
+//#region src/node/utils/format.ts
+function getContentByteSize(content) {
+	if (!content) return 0;
+	return Buffer$1.byteLength(content);
 }
 //#endregion
 //#region src/shared/utils/guess-chunk-name.ts
@@ -93,12 +66,6 @@ function getInitialChunkIds(chunks) {
 	return initialChunkIds;
 }
 //#endregion
-//#region src/node/utils/format.ts
-function getContentByteSize(content) {
-	if (!content) return 0;
-	return new TextEncoder().encode(content).length;
-}
-//#endregion
 //#region src/node/rolldown/events-manager.ts
 const MODULE_BUILD_START_HOOKS = [
 	"HookResolveIdCallStart",
@@ -110,8 +77,29 @@ const MODULE_BUILD_END_HOOKS = [
 	"HookLoadCallEnd",
 	"HookTransformCallEnd"
 ];
+function getContentInfo(content) {
+	if (!content) return { byteSize: 0 };
+	return { byteSize: getContentByteSize(content) };
+}
+function getContentRef(content) {
+	return typeof content === "string" && content.startsWith("$ref:") ? content.slice(5) : void 0;
+}
+function getEventId(event, index) {
+	return `${"timestamp" in event ? event.timestamp : "x"}#${index}`;
+}
+function getLastEventSnapshot(event) {
+	if (!("action" in event)) return event;
+	const snapshot = {
+		action: event.action,
+		event_id: event.event_id
+	};
+	if ("timestamp" in event) snapshot.timestamp = event.timestamp;
+	if ("session_id" in event) snapshot.session_id = event.session_id;
+	return snapshot;
+}
 var RolldownEventsManager = class {
-	events = [];
+	eventCount = 0;
+	lastEvent;
 	chunks = /* @__PURE__ */ new Map();
 	assets = /* @__PURE__ */ new Map();
 	chunkAssetMap = /* @__PURE__ */ new Map();
@@ -122,18 +110,34 @@ var RolldownEventsManager = class {
 	plugin_build_metrics = /* @__PURE__ */ new Map();
 	build_start_time = 0;
 	build_end_time = 0;
-	interpretSourceRefs(event, key) {
-		if (key in event && typeof event[key] === "string") {
-			if (event[key].startsWith("$ref:")) {
-				const refKey = event[key].slice(5);
-				if (this.source_refs.has(refKey)) event[key] = this.source_refs.get(refKey);
-			}
-		}
+	getEventContentInfo(event, key) {
+		if (!(key in event)) return getContentInfo(void 0);
+		const content = event[key];
+		const refKey = getContentRef(content);
+		if (refKey) return this.source_refs.get(refKey) ?? getContentInfo(void 0);
+		return typeof content === "string" ? getContentInfo(content) : getContentInfo(void 0);
 	}
 	recordBuildMetrics(event) {
-		if (MODULE_BUILD_START_HOOKS.includes(event.action)) this.module_build_hook_events.set(event.call_id, event);
-		else if (MODULE_BUILD_END_HOOKS.includes(event.action)) {
+		if (MODULE_BUILD_START_HOOKS.includes(event.action)) {
+			if (event.action === "HookResolveIdCallStart") this.module_build_hook_events.set(event.call_id, {
+				action: event.action,
+				timestamp: event.timestamp,
+				importer: event.importer,
+				module_request: event.module_request,
+				import_kind: event.import_kind
+			});
+			else if (event.action === "HookLoadCallStart") this.module_build_hook_events.set(event.call_id, {
+				action: event.action,
+				timestamp: event.timestamp
+			});
+			else if (event.action === "HookTransformCallStart") this.module_build_hook_events.set(event.call_id, {
+				action: event.action,
+				timestamp: event.timestamp,
+				contentInfo: this.getEventContentInfo(event, "content")
+			});
+		} else if (MODULE_BUILD_END_HOOKS.includes(event.action)) {
 			const start = this.module_build_hook_events.get(event.call_id);
+			this.module_build_hook_events.delete(event.call_id);
 			const module_id = event.action === "HookResolveIdCallEnd" ? event.resolved_id : event.module_id;
 			if (start) {
 				const pluginId = event.plugin_id;
@@ -156,6 +160,7 @@ var RolldownEventsManager = class {
 					calls: []
 				};
 				if (event.action === "HookResolveIdCallEnd") {
+					if (start.action !== "HookResolveIdCallStart") return;
 					module_build_metrics.resolve_ids.push({
 						...info,
 						type: "resolve",
@@ -170,10 +175,11 @@ var RolldownEventsManager = class {
 						module: start.module_request
 					});
 				} else if (event.action === "HookLoadCallEnd") {
+					if (start.action !== "HookLoadCallStart") return;
 					module_build_metrics.loads.push({
 						...info,
 						type: "load",
-						content: event.content
+						content: null
 					});
 					plugin_build_metrics.calls.push({
 						...info,
@@ -182,21 +188,21 @@ var RolldownEventsManager = class {
 						unchanged: !event.content
 					});
 				} else if (event.action === "HookTransformCallEnd") {
-					const _start = start;
-					const _end = event;
+					if (start.action !== "HookTransformCallStart") return;
+					const sourceContentInfo = start.contentInfo;
+					const transformedContentInfo = this.getEventContentInfo(event, "content");
 					module_build_metrics.transforms.push({
 						...info,
 						type: "transform",
-						content_from: _start.content,
-						content_to: _end.content,
-						source_code_size: getContentByteSize(_start.content),
-						transformed_code_size: getContentByteSize(_end.content)
+						content_from: null,
+						content_to: null,
+						source_code_size: sourceContentInfo.byteSize,
+						transformed_code_size: transformedContentInfo.byteSize
 					});
 					plugin_build_metrics.calls.push({
 						...info,
 						type: "transform",
-						module: event.module_id,
-						unchanged: _start.content === _end.content
+						module: event.module_id
 					});
 				}
 				this.plugin_build_metrics.set(pluginId, plugin_build_metrics);
@@ -205,15 +211,17 @@ var RolldownEventsManager = class {
 		}
 	}
 	handleEvent(raw) {
-		const event = {
-			...raw,
-			event_id: `${"timestamp" in raw ? raw.timestamp : "x"}#${this.events.length}`
-		};
-		this.events.push(event);
+		const event = raw;
+		event.event_id = getEventId(raw, this.eventCount);
+		this.eventCount += 1;
+		this.lastEvent = getLastEventSnapshot(event);
 		if (event.action === "BuildStart") this.build_start_time = +event.timestamp;
-		if (event.action === "BuildEnd") this.build_end_time = +event.timestamp;
+		if (event.action === "BuildEnd") {
+			this.build_end_time = +event.timestamp;
+			if (!this.module_build_hook_events.size) this.source_refs.clear();
+		}
 		if (event.action === "StringRef") {
-			this.source_refs.set(event.id, event.content);
+			this.source_refs.set(event.id, getContentInfo(event.content));
 			return;
 		}
 		if (event.action === "ChunkGraphReady") {
@@ -225,7 +233,6 @@ var RolldownEventsManager = class {
 			});
 			return;
 		}
-		this.interpretSourceRefs(event, "content");
 		this.recordBuildMetrics(event);
 		if ("module_id" in event) {
 			if (this.modules.has(event.module_id)) return;
@@ -243,6 +250,7 @@ var RolldownEventsManager = class {
 		}
 		if (event.action === "ModuleGraphReady") {
 			this.module_build_hook_events.clear();
+			this.source_refs.clear();
 			for (const module of event.modules) {
 				this.modules.set(module.id, {
 					...module,
@@ -262,51 +270,1371 @@ var RolldownEventsManager = class {
 		return event;
 	}
 	dispose() {
-		this.events = [];
+		this.eventCount = 0;
+		this.lastEvent = void 0;
+		this.chunks.clear();
+		this.assets.clear();
+		this.chunkAssetMap.clear();
+		this.modules.clear();
+		this.source_refs.clear();
+		this.module_build_hook_events.clear();
+		this.module_build_metrics.clear();
+		this.plugin_build_metrics.clear();
+		this.build_start_time = 0;
+		this.build_end_time = 0;
+	}
+	snapshot() {
+		return {
+			eventCount: this.eventCount,
+			lastEvent: this.lastEvent,
+			chunks: Array.from(this.chunks.entries()),
+			modules: Array.from(this.modules.entries()).map(([id, module]) => {
+				const { build_metrics, ...snapshot } = module;
+				return [id, snapshot];
+			}),
+			source_refs: Array.from(this.source_refs.entries()),
+			module_build_hook_events: Array.from(this.module_build_hook_events.entries()),
+			module_build_metrics: Array.from(this.module_build_metrics.entries()),
+			plugin_build_metrics: Array.from(this.plugin_build_metrics.entries()),
+			build_start_time: this.build_start_time,
+			build_end_time: this.build_end_time
+		};
+	}
+	restore(snapshot) {
+		this.eventCount = snapshot.eventCount;
+		this.lastEvent = snapshot.lastEvent;
+		this.chunks = new Map(snapshot.chunks);
+		this.assets.clear();
+		this.chunkAssetMap.clear();
+		this.source_refs = new Map(snapshot.source_refs);
+		this.module_build_hook_events = new Map(snapshot.module_build_hook_events);
+		this.module_build_metrics = new Map(snapshot.module_build_metrics);
+		this.modules = new Map(snapshot.modules.map(([id, module]) => [id, {
+			...module,
+			build_metrics: this.module_build_metrics.get(id)
+		}]));
+		this.plugin_build_metrics = new Map(snapshot.plugin_build_metrics);
+		this.build_start_time = snapshot.build_start_time;
+		this.build_end_time = snapshot.build_end_time;
 	}
 	[Symbol.dispose]() {
 		this.dispose();
 	}
 };
 //#endregion
+//#region src/node/rolldown/log-cache.ts
+const ROLLDOWN_LOG_CACHE_DIR = ".cache";
+const ROLLDOWN_LOG_SESSION_SUMMARY_CACHE_FILENAME = "session-summary.json";
+const ROLLDOWN_LOG_READER_INDEX_CACHE_FILENAME = "reader-index.json";
+const ROLLDOWN_LOG_PACKAGE_SUMMARY_CACHE_FILENAME = "package-summary.json";
+const ROLLDOWN_LOG_PLUGIN_SUMMARY_CACHE_FILENAME = "plugin-summary.json";
+const ROLLDOWN_LOG_MODULE_METRICS_SUMMARY_CACHE_FILENAME = "module-metrics-summary.json";
+const ROLLDOWN_LOG_CACHE_VERSION = 1;
+var RolldownLogCacheFile = class RolldownLogCacheFile {
+	filepath;
+	constructor(filepath) {
+		this.filepath = filepath;
+	}
+	static forLogFile(logFilepath, filename) {
+		if (basename(logFilepath) !== "logs.json") return void 0;
+		return new RolldownLogCacheFile(join(dirname(logFilepath), ROLLDOWN_LOG_CACHE_DIR, filename));
+	}
+	async read(stat) {
+		try {
+			const cache = JSON.parse(await fs$1.readFile(this.filepath, "utf8"));
+			if (!this.matches(stat, cache)) return void 0;
+			return cache.data;
+		} catch {
+			return;
+		}
+	}
+	async write(stat, data) {
+		try {
+			const temporaryFilepath = `${this.filepath}.tmp`;
+			await fs$1.mkdir(dirname(this.filepath), { recursive: true });
+			await fs$1.writeFile(temporaryFilepath, JSON.stringify(this.createFile(stat, data)), "utf8");
+			await fs$1.rename(temporaryFilepath, this.filepath);
+		} catch {}
+	}
+	createFile(stat, data) {
+		return {
+			version: ROLLDOWN_LOG_CACHE_VERSION,
+			log: {
+				size: stat.size,
+				mtime: stat.mtime.getTime()
+			},
+			data
+		};
+	}
+	matches(stat, cache) {
+		return cache.version === ROLLDOWN_LOG_CACHE_VERSION && cache.log.size === stat.size && cache.log.mtime === stat.mtime.getTime();
+	}
+};
+function createMetricSummary() {
+	return {
+		count: 0,
+		duration: 0
+	};
+}
+function addMetricSummary(summary, duration) {
+	summary.count += 1;
+	summary.duration += duration;
+}
+function compactModuleBuildMetrics(metrics) {
+	const resolveDuration = metrics.resolve_ids.reduce((total, item) => total + item.duration, 0);
+	const loadDuration = metrics.loads.reduce((total, item) => total + item.duration, 0);
+	const transformDuration = metrics.transforms.reduce((total, item) => total + item.duration, 0);
+	const resolve_ids = metrics.resolve_ids.length ? [{
+		...metrics.resolve_ids[0],
+		id: "",
+		duration: resolveDuration,
+		timestamp_start: metrics.resolve_ids[0].timestamp_start,
+		timestamp_end: metrics.resolve_ids.at(-1).timestamp_end
+	}] : [];
+	const loads = metrics.loads.length ? [{
+		...metrics.loads[0],
+		id: "",
+		content: null,
+		duration: loadDuration,
+		timestamp_start: metrics.loads[0].timestamp_start,
+		timestamp_end: metrics.loads.at(-1).timestamp_end
+	}] : [];
+	const transformsByPlugin = /* @__PURE__ */ new Map();
+	let finalTransformedCodeSize = 0;
+	for (const transform of metrics.transforms) {
+		if (transform.transformed_code_size) finalTransformedCodeSize = transform.transformed_code_size;
+		if (!transform.transformed_code_size || transform.source_code_size === transform.transformed_code_size) continue;
+		const item = transformsByPlugin.get(transform.plugin_id);
+		if (item) {
+			item.duration += transform.duration;
+			item.timestamp_end = transform.timestamp_end;
+			item.transformed_code_size = transform.transformed_code_size;
+			continue;
+		}
+		transformsByPlugin.set(transform.plugin_id, {
+			...transform,
+			id: "",
+			content_from: null,
+			content_to: null
+		});
+	}
+	const transforms = Array.from(transformsByPlugin.values());
+	const remainingDuration = transformDuration - transforms.reduce((total, item) => total + item.duration, 0);
+	if (remainingDuration > 0 && metrics.transforms.length) transforms.push({
+		...metrics.transforms[0],
+		id: "",
+		plugin_name: "",
+		plugin_id: 0,
+		content_from: null,
+		content_to: null,
+		source_code_size: 0,
+		transformed_code_size: 0,
+		duration: remainingDuration,
+		timestamp_start: metrics.transforms[0].timestamp_start,
+		timestamp_end: metrics.transforms.at(-1).timestamp_end
+	});
+	if (finalTransformedCodeSize && metrics.transforms.length) transforms.push({
+		...metrics.transforms.at(-1),
+		id: "",
+		plugin_name: "",
+		plugin_id: 0,
+		content_from: null,
+		content_to: null,
+		source_code_size: finalTransformedCodeSize,
+		transformed_code_size: finalTransformedCodeSize,
+		duration: 0
+	});
+	return {
+		resolve_ids,
+		loads,
+		transforms
+	};
+}
+function createPluginBuildMetricsSummary(metrics) {
+	const summary = {
+		plugin_id: metrics.plugin_id,
+		plugin_name: metrics.plugin_name,
+		total: createMetricSummary(),
+		resolve: createMetricSummary(),
+		load: createMetricSummary(),
+		transform: createMetricSummary()
+	};
+	for (const call of metrics.calls) {
+		addMetricSummary(summary.total, call.duration);
+		if (call.type === "resolve") addMetricSummary(summary.resolve, call.duration);
+		else if (call.type === "load") addMetricSummary(summary.load, call.duration);
+		else if (call.type === "transform") addMetricSummary(summary.transform, call.duration);
+	}
+	return summary;
+}
+var RolldownLogCache = class {
+	sessionSummaryCache;
+	moduleMetricsSummaryCache;
+	pluginSummaryCache;
+	readerIndexCache;
+	packageSummaryCache;
+	completeSessionWriteAttempted = false;
+	summaryWriteAttempted = false;
+	packageSummaryWriteAttempted = false;
+	constructor(logFilepath, options) {
+		if (options.completeSession) {
+			this.sessionSummaryCache = RolldownLogCacheFile.forLogFile(logFilepath, ROLLDOWN_LOG_SESSION_SUMMARY_CACHE_FILENAME);
+			this.moduleMetricsSummaryCache = RolldownLogCacheFile.forLogFile(logFilepath, ROLLDOWN_LOG_MODULE_METRICS_SUMMARY_CACHE_FILENAME);
+			this.pluginSummaryCache = RolldownLogCacheFile.forLogFile(logFilepath, ROLLDOWN_LOG_PLUGIN_SUMMARY_CACHE_FILENAME);
+			this.readerIndexCache = RolldownLogCacheFile.forLogFile(logFilepath, ROLLDOWN_LOG_READER_INDEX_CACHE_FILENAME);
+		}
+		this.packageSummaryCache = RolldownLogCacheFile.forLogFile(logFilepath, ROLLDOWN_LOG_PACKAGE_SUMMARY_CACHE_FILENAME);
+	}
+	shouldWriteCompleteSession() {
+		return !this.completeSessionWriteAttempted;
+	}
+	shouldWritePackageSummary() {
+		return !this.packageSummaryWriteAttempted;
+	}
+	shouldWriteSummary() {
+		return !this.summaryWriteAttempted;
+	}
+	resetCompleteSessionWriteAttempt() {
+		this.completeSessionWriteAttempted = false;
+		this.summaryWriteAttempted = false;
+	}
+	resetSummaryWriteAttempt() {
+		this.summaryWriteAttempted = false;
+	}
+	resetPackageSummaryWriteAttempt() {
+		this.packageSummaryWriteAttempted = false;
+	}
+	async restoreCompleteSession(stat, state) {
+		if (state.lastBytes || state.manager.eventCount) return false;
+		const [sessionSummaryCache, moduleMetricsCache, pluginSummaryCacheExists, indexCache] = await Promise.all([
+			this.sessionSummaryCache?.read(stat),
+			this.moduleMetricsSummaryCache?.read(stat),
+			this.pluginSummaryCache?.read(stat),
+			this.readerIndexCache?.read(stat)
+		]);
+		if (!sessionSummaryCache || !moduleMetricsCache || !pluginSummaryCacheExists || !indexCache) return false;
+		if (sessionSummaryCache.reader.lastBytes !== stat.size || indexCache.reader.lastBytes !== stat.size) return false;
+		this.restoreSessionSnapshot(sessionSummaryCache, state, moduleMetricsCache);
+		this.restoreReaderIndexSnapshot(indexCache, state);
+		this.completeSessionWriteAttempted = true;
+		this.summaryWriteAttempted = true;
+		return true;
+	}
+	async restoreSummary(stat, state) {
+		if (state.lastBytes || state.manager.eventCount) return false;
+		const [sessionSummaryCache, moduleMetricsCache, _pluginSummaryCache, indexCache] = await Promise.all([
+			this.sessionSummaryCache?.read(stat),
+			this.moduleMetricsSummaryCache?.read(stat),
+			this.pluginSummaryCache?.read(stat),
+			this.readerIndexCache?.read(stat)
+		]);
+		if (!sessionSummaryCache) return false;
+		if (sessionSummaryCache.reader.lastBytes !== stat.size) return false;
+		this.restoreSessionSnapshot(sessionSummaryCache, state, moduleMetricsCache);
+		const hasCompleteCache = !!moduleMetricsCache && !!_pluginSummaryCache && !!indexCache;
+		if (indexCache?.reader.lastBytes === stat.size) this.restoreReaderIndexSnapshot(indexCache, state);
+		else this.clearReaderIndexState(state);
+		this.summaryWriteAttempted = true;
+		this.completeSessionWriteAttempted = hasCompleteCache;
+		return hasCompleteCache ? "complete" : "summary";
+	}
+	async restorePackageSummary(stat, state) {
+		if (state.manager.eventCount) return false;
+		const cache = await this.packageSummaryCache?.read(stat);
+		if (!cache) return false;
+		if (cache.packageSummaryTimestamp !== stat.mtime.getTime()) return false;
+		this.restorePackageSummarySnapshot(cache, state);
+		this.packageSummaryWriteAttempted = true;
+		return true;
+	}
+	async writeCompleteSession(stat, state) {
+		this.completeSessionWriteAttempted = true;
+		this.summaryWriteAttempted = true;
+		await Promise.all([
+			this.sessionSummaryCache?.write(stat, this.createSessionSummarySnapshot(state)),
+			this.moduleMetricsSummaryCache?.write(stat, this.createModuleMetricsSummarySnapshot(state)),
+			this.pluginSummaryCache?.write(stat, this.createPluginSummarySnapshot(state)),
+			this.readerIndexCache?.write(stat, this.createReaderIndexSnapshot(state))
+		]);
+	}
+	async writeSummary(stat, state) {
+		this.summaryWriteAttempted = true;
+		await Promise.all([
+			this.sessionSummaryCache?.write(stat, this.createSessionSummarySnapshot(state)),
+			this.moduleMetricsSummaryCache?.write(stat, this.createModuleMetricsSummarySnapshot(state)),
+			this.pluginSummaryCache?.write(stat, this.createPluginSummarySnapshot(state)),
+			this.readerIndexCache?.write(stat, this.createReaderIndexSnapshot(state))
+		]);
+	}
+	async writePackageSummary(stat, state) {
+		this.packageSummaryWriteAttempted = true;
+		await this.packageSummaryCache?.write(stat, this.createPackageSummarySnapshot(state));
+	}
+	createSessionSummarySnapshot(state) {
+		const manager = state.manager.snapshot();
+		return {
+			reader: {
+				lastBytes: state.lastBytes,
+				lastTimestamp: state.lastTimestamp,
+				lineNumber: state.lineNumber
+			},
+			meta: state.meta,
+			manager: {
+				eventCount: manager.eventCount,
+				lastEvent: manager.lastEvent,
+				chunks: manager.chunks,
+				modules: manager.modules,
+				build_start_time: manager.build_start_time,
+				build_end_time: manager.build_end_time
+			}
+		};
+	}
+	createModuleMetricsSummarySnapshot(state) {
+		return { metrics: state.manager.snapshot().module_build_metrics.map(([module, metrics]) => [module, compactModuleBuildMetrics(metrics)]) };
+	}
+	createPluginSummarySnapshot(state) {
+		return { plugins: state.manager.snapshot().plugin_build_metrics.map(([pluginId, metrics]) => [pluginId, createPluginBuildMetricsSummary(metrics)]) };
+	}
+	createReaderIndexSnapshot(state) {
+		return { reader: {
+			lastBytes: state.lastBytes,
+			lastTimestamp: state.lastTimestamp,
+			moduleEventIndex: Array.from(state.moduleEventIndex.entries()).map(([module, index]) => [module, {
+				resolveIds: Array.from(index.resolveIds.entries()),
+				loads: Array.from(index.loads.entries()),
+				transforms: Array.from(index.transforms.entries())
+			}]),
+			stringRefIndex: Array.from(state.stringRefIndex.entries()),
+			pendingHookCallStarts: Array.from(state.pendingHookCallStarts.entries()),
+			assetsReadyLocations: state.assetsReadyLocations
+		} };
+	}
+	createPackageSummarySnapshot(state) {
+		return {
+			packageSummaryTimestamp: state.packageSummaryTimestamp,
+			manager: state.manager.snapshot()
+		};
+	}
+	restoreSessionSnapshot(session, state, moduleMetrics) {
+		state.lastBytes = session.reader.lastBytes;
+		state.lastTimestamp = session.reader.lastTimestamp;
+		state.lineNumber = session.reader.lineNumber;
+		state.meta = session.meta;
+		state.metricsSummaryOnly = true;
+		state.manager.restore({
+			eventCount: session.manager.eventCount,
+			lastEvent: session.manager.lastEvent,
+			chunks: session.manager.chunks,
+			modules: session.manager.modules,
+			source_refs: [],
+			module_build_hook_events: [],
+			module_build_metrics: moduleMetrics?.metrics ?? [],
+			plugin_build_metrics: [],
+			build_start_time: session.manager.build_start_time,
+			build_end_time: session.manager.build_end_time
+		});
+	}
+	restoreReaderIndexSnapshot(snapshot, state) {
+		state.moduleEventIndex = new Map(snapshot.reader.moduleEventIndex.map(([module, item]) => [module, {
+			resolveIds: new Map(item.resolveIds),
+			loads: new Map(item.loads),
+			transforms: new Map(item.transforms)
+		}]));
+		state.stringRefIndex = new Map(snapshot.reader.stringRefIndex);
+		state.pendingHookCallStarts = new Map(snapshot.reader.pendingHookCallStarts);
+		state.assetsReadyLocations = snapshot.reader.assetsReadyLocations;
+	}
+	restorePackageSummarySnapshot(snapshot, state) {
+		state.manager.restore(snapshot.manager);
+		state.packageSummaryTimestamp = snapshot.packageSummaryTimestamp;
+	}
+	clearReaderIndexState(state) {
+		state.moduleEventIndex = /* @__PURE__ */ new Map();
+		state.stringRefIndex = /* @__PURE__ */ new Map();
+		state.pendingHookCallStarts = /* @__PURE__ */ new Map();
+		state.assetsReadyLocations = [];
+	}
+};
+//#endregion
 //#region src/node/rolldown/events-reader.ts
 const readers = /* @__PURE__ */ new Map();
+const MAX_READERS = 32;
+const MAX_MODULE_METRICS_CACHE = 32;
+const MAX_MODULE_METRICS_CACHE_BYTES = 64 * 1024 * 1024;
+const READ_STREAM_HIGH_WATER_MARK = 1024 * 1024;
+const LINE_FEED = "\n".charCodeAt(0);
+const CARRIAGE_RETURN = "\r".charCodeAt(0);
+const ACTION_PREVIEW_BYTES = 512;
+const PACKAGE_SUMMARY_MAX_PARSED_LINE_BYTES = 1024 * 1024;
+const PACKAGE_SUMMARY_ACTIONS = new Set([
+	"ChunkGraphReady",
+	"HookTransformCallEnd",
+	"ModuleGraphReady",
+	"StringRef"
+]);
+const PACKAGE_SUMMARY_LARGE_LINE_ACTIONS = new Set(["HookTransformCallEnd", "StringRef"]);
+function getDeferredContent(event, refs) {
+	if (typeof event.content !== "string") return {
+		value: null,
+		ref: null
+	};
+	const ref = getContentRef(event.content);
+	if (ref) {
+		refs.add(ref);
+		return {
+			value: null,
+			ref
+		};
+	}
+	return {
+		value: event.content,
+		ref: null
+	};
+}
+function resolveDeferredContent(content, refs) {
+	if (content.ref) return refs.get(content.ref) ?? `$ref:${content.ref}`;
+	return content.value;
+}
+function cloneModuleBuildMetrics(metrics) {
+	return {
+		resolve_ids: metrics.resolve_ids.map((item) => ({ ...item })),
+		loads: metrics.loads.map((item) => ({ ...item })),
+		transforms: metrics.transforms.map((item) => ({ ...item }))
+	};
+}
+function getContentCacheBytes(content) {
+	return content ? getContentByteSize(content) : 0;
+}
+function getContentHash(content) {
+	return createHash("sha1").update(content ?? "").digest("hex");
+}
+function getModuleBuildMetricsCacheBytes(metrics) {
+	return metrics.loads.reduce((total, load) => total + getContentCacheBytes(load.content), 0) + metrics.transforms.reduce((total, transform) => total + getContentCacheBytes(transform.content_from) + getContentCacheBytes(transform.content_to), 0);
+}
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+function stripLineEnd(line) {
+	if (line.at(-1) === CARRIAGE_RETURN) return line.subarray(0, -1).toString("utf8");
+	return line.toString("utf8");
+}
+function appendPreview(preview, segment) {
+	if (preview.length >= ACTION_PREVIEW_BYTES || !segment.length) return preview;
+	const remaining = ACTION_PREVIEW_BYTES - preview.length;
+	const next = segment.subarray(0, Math.min(remaining, segment.length));
+	return preview.length ? Buffer$1.concat([preview, next], preview.length + next.length) : Buffer$1.from(next);
+}
+function getPreviewAction(preview) {
+	return preview.toString("utf8").match(/"action":"([^"]+)"/)?.[1];
+}
+function getReferencedContentByteSize(content, refs) {
+	if (typeof content !== "string") return 0;
+	const ref = getContentRef(content);
+	if (ref) return refs.get(ref) ?? 0;
+	return getContentByteSize(content);
+}
+function getPreviewStringValue(preview, key) {
+	const match = preview.toString("utf8").match(new RegExp(`"${key}":"((?:\\\\.|[^"])*)"`));
+	if (!match) return void 0;
+	try {
+		return JSON.parse(`"${match[1]}"`);
+	} catch {
+		return;
+	}
+}
+function estimateContentByteSizeFromLine(preview, location) {
+	const marker = Buffer$1.from("\"content\":\"");
+	const index = preview.indexOf(marker);
+	if (index === -1) return 0;
+	const contentStart = index + marker.length;
+	return Math.max(0, location.length - contentStart - 128);
+}
+function pruneReaders() {
+	if (readers.size <= MAX_READERS) return;
+	for (const reader of Array.from(readers.values())) {
+		if (readers.size <= MAX_READERS) return;
+		if (!reader.hasPendingRead()) reader.dispose();
+	}
+}
 var RolldownEventsReader = class RolldownEventsReader {
 	filepath;
+	cacheKey;
 	lastBytes = 0;
 	lastTimestamp = 0;
 	manager = new RolldownEventsManager();
 	meta;
 	pendingRead;
-	constructor(filepath) {
+	pendingSummaryRead;
+	lineNumber = 0;
+	moduleEventIndex = /* @__PURE__ */ new Map();
+	stringRefIndex = /* @__PURE__ */ new Map();
+	pendingHookCallStarts = /* @__PURE__ */ new Map();
+	moduleMetricsCache = /* @__PURE__ */ new Map();
+	moduleMetricsCacheBytes = 0;
+	pendingModuleMetrics = /* @__PURE__ */ new Map();
+	assetsReadyLocations = [];
+	assetsHydrated = false;
+	pendingPackageSummaryRead;
+	packageSummaryTimestamp = 0;
+	summaryOnly = false;
+	packageSummaryOnly = false;
+	metricsSummaryOnly = false;
+	logCache;
+	constructor(filepath, cacheKey = filepath) {
 		this.filepath = filepath;
-	}
-	static get(filepath) {
-		if (readers.has(filepath)) return readers.get(filepath);
-		const reader = new RolldownEventsReader(filepath);
-		readers.set(filepath, reader);
+		this.cacheKey = cacheKey;
+		this.logCache = new RolldownLogCache(filepath, { completeSession: cacheKey === filepath });
+	}
+	static get(filepath, cacheKey = filepath) {
+		if (readers.has(cacheKey)) {
+			const reader = readers.get(cacheKey);
+			readers.delete(cacheKey);
+			readers.set(cacheKey, reader);
+			return reader;
+		}
+		const reader = new RolldownEventsReader(filepath, cacheKey);
+		readers.set(cacheKey, reader);
+		pruneReaders();
 		return reader;
 	}
+	static peek(filepath, cacheKey = filepath) {
+		return readers.get(cacheKey);
+	}
 	async read() {
 		if (this.pendingRead) return this.pendingRead;
+		if (this.pendingSummaryRead) await this.pendingSummaryRead;
 		this.pendingRead = this.readChanges().finally(() => {
 			this.pendingRead = void 0;
 		});
 		return this.pendingRead;
 	}
+	async readSummary() {
+		if (this.pendingRead) return this.pendingRead;
+		if (this.pendingSummaryRead) return this.pendingSummaryRead;
+		this.pendingSummaryRead = this.readSummaryChanges().finally(() => {
+			this.pendingSummaryRead = void 0;
+		});
+		return this.pendingSummaryRead;
+	}
 	async readChanges() {
-		const { mtime, size } = await fs.promises.stat(this.filepath);
-		if (mtime.getTime() <= this.lastTimestamp) return;
-		await parseJsonStreamWithConcatArrays(fs.createReadStream(this.filepath, { start: this.lastBytes }), (event) => {
+		const stat = await fs.promises.stat(this.filepath);
+		const mtime = stat.mtime.getTime();
+		if (this.summaryOnly || this.packageSummaryOnly) this.resetReadState();
+		if (await this.logCache.restoreCompleteSession(stat, this.createLogCacheState())) {
+			this.clearModuleMetricsCache();
+			this.pendingModuleMetrics.clear();
+			this.summaryOnly = false;
+			this.packageSummaryOnly = false;
+			this.assetsHydrated = false;
+			return;
+		}
+		if (mtime <= this.lastTimestamp) {
+			if (this.hasCompleteSession() && this.logCache.shouldWriteCompleteSession()) await this.logCache.writeCompleteSession(stat, this.createLogCacheState());
+			return;
+		}
+		let changed = false;
+		await this.readEventLines(this.lastBytes, (event, location) => {
+			changed = true;
+			if (event.action === "SessionMeta") this.meta = event;
+			this.manager.handleEvent(event);
+			this.indexEvent(event, location);
+		}, {
+			skipAction: "AssetsReady",
+			onSkippedLine: (line) => this.recordAssetsReadyLocation(line)
+		});
+		if (changed) {
+			this.clearModuleMetricsCache();
+			this.pendingModuleMetrics.clear();
+			this.logCache.resetCompleteSessionWriteAttempt();
+		}
+		this.lastTimestamp = mtime;
+		this.lastBytes = stat.size;
+		this.metricsSummaryOnly = false;
+		await this.logCache.writeCompleteSession(stat, this.createLogCacheState());
+	}
+	async readSummaryChanges() {
+		const stat = await fs.promises.stat(this.filepath);
+		const mtime = stat.mtime.getTime();
+		if (this.manager.eventCount && mtime <= this.lastTimestamp) {
+			if (this.logCache.shouldWriteSummary()) await this.logCache.writeSummary(stat, this.createLogCacheState());
+			return;
+		}
+		const restoredSummary = await this.logCache.restoreSummary(stat, this.createLogCacheState());
+		if (restoredSummary) {
+			this.clearModuleMetricsCache();
+			this.pendingModuleMetrics.clear();
+			this.summaryOnly = restoredSummary !== "complete";
+			this.packageSummaryOnly = false;
+			this.assetsHydrated = false;
+			return;
+		}
+		if (this.manager.eventCount || this.lastBytes) this.resetReadState();
+		let changed = false;
+		await this.readEventLines(0, (event, location) => {
+			changed = true;
+			if (event.action === "SessionMeta") this.meta = event;
 			this.manager.handleEvent(event);
-			return event;
+			this.indexEvent(event, location);
+		}, {
+			skipAction: "AssetsReady",
+			onSkippedLine: (line) => this.recordAssetsReadyLocation(line)
+		});
+		if (changed) {
+			this.clearModuleMetricsCache();
+			this.pendingModuleMetrics.clear();
+			this.logCache.resetSummaryWriteAttempt();
+		}
+		this.lastTimestamp = mtime;
+		this.lastBytes = stat.size;
+		this.summaryOnly = false;
+		this.packageSummaryOnly = false;
+		this.metricsSummaryOnly = false;
+		await this.logCache.writeSummary(stat, this.createLogCacheState());
+	}
+	async readEventLines(start, processor, options = {}) {
+		const stream = fs.createReadStream(this.filepath, {
+			start,
+			highWaterMark: READ_STREAM_HIGH_WATER_MARK
+		});
+		let absoluteOffset = start;
+		let lineStartOffset = start;
+		let parts = [];
+		let partsLength = 0;
+		let preview = Buffer$1.alloc(0);
+		let skipCurrentLine = false;
+		let lineAction;
+		const processLine = async (line, location) => {
+			this.lineNumber += 1;
+			const text = stripLineEnd(line);
+			if (!text) return;
+			try {
+				const result = processor(parseToEvent(text), location);
+				if (isPromiseLike(result)) await result;
+			} catch (e) {
+				const preview = text.length > 256 ? `${text.slice(0, 256)}...` : text;
+				diagnostics.RDDT0002({
+					line: this.lineNumber,
+					error: e.message,
+					preview
+				});
+			}
+		};
+		const appendSegmentPreview = (segment) => {
+			if (skipCurrentLine) return;
+			preview = appendPreview(preview, segment);
+			lineAction = lineAction ?? getPreviewAction(preview);
+			const lineBytes = partsLength + segment.length;
+			if (lineAction && (options.skipAction === lineAction || options.onlyActions && !options.onlyActions.has(lineAction) || options.maxLineBytes != null && lineBytes > options.maxLineBytes && !!options.largeLineActions?.has(lineAction))) {
+				skipCurrentLine = true;
+				parts = [];
+				partsLength = 0;
+			}
+		};
+		const processSkippedLine = (location) => {
+			this.lineNumber += 1;
+			options.onSkippedLine?.({
+				action: lineAction,
+				location,
+				preview
+			});
+		};
+		const resetLine = (nextLineStartOffset) => {
+			parts = [];
+			partsLength = 0;
+			preview = Buffer$1.alloc(0);
+			skipCurrentLine = false;
+			lineAction = void 0;
+			lineStartOffset = nextLineStartOffset;
+		};
+		for await (const chunk of stream) {
+			const buffer = Buffer$1.isBuffer(chunk) ? chunk : Buffer$1.from(chunk);
+			let segmentStart = 0;
+			let newline = buffer.indexOf(LINE_FEED);
+			while (newline !== -1) {
+				const segment = buffer.subarray(segmentStart, newline);
+				if (!partsLength && !preview.length) lineStartOffset = absoluteOffset + segmentStart;
+				appendSegmentPreview(segment);
+				const location = {
+					offset: lineStartOffset,
+					length: absoluteOffset + newline + 1 - lineStartOffset
+				};
+				if (skipCurrentLine) processSkippedLine(location);
+				else {
+					let line = segment;
+					if (partsLength) {
+						parts.push(segment);
+						line = Buffer$1.concat(parts, partsLength + segment.length);
+					}
+					await processLine(line, location);
+				}
+				segmentStart = newline + 1;
+				resetLine(absoluteOffset + segmentStart);
+				newline = buffer.indexOf(LINE_FEED, segmentStart);
+			}
+			if (segmentStart < buffer.length) {
+				if (!partsLength && !preview.length) lineStartOffset = absoluteOffset + segmentStart;
+				const tail = buffer.subarray(segmentStart);
+				appendSegmentPreview(tail);
+				if (!skipCurrentLine) {
+					parts.push(tail);
+					partsLength += tail.length;
+				}
+			}
+			absoluteOffset += buffer.length;
+		}
+		if (skipCurrentLine) processSkippedLine({
+			offset: lineStartOffset,
+			length: absoluteOffset - lineStartOffset
+		});
+		else if (partsLength) await processLine(Buffer$1.concat(parts, partsLength), {
+			offset: lineStartOffset,
+			length: partsLength
 		});
-		this.lastTimestamp = mtime.getTime();
-		this.lastBytes = size;
+	}
+	async readAssets() {
+		await this.read();
+		if (this.assetsHydrated) return;
+		this.manager.assets.clear();
+		this.manager.chunkAssetMap.clear();
+		const events = await this.readEventsAt(this.assetsReadyLocations);
+		for (const event of events) if (event?.action === "AssetsReady") this.manager.handleEvent(event);
+		this.assetsHydrated = true;
+	}
+	recordAssetsReadyLocation(line) {
+		if (line.action !== "AssetsReady") return;
+		this.assetsReadyLocations.push(line.location);
+		this.assetsHydrated = false;
+	}
+	async readPackageSummary() {
+		if (this.pendingPackageSummaryRead) return this.pendingPackageSummaryRead;
+		this.pendingPackageSummaryRead = this.readPackageSummaryChanges().finally(() => {
+			this.pendingPackageSummaryRead = void 0;
+		});
+		return this.pendingPackageSummaryRead;
+	}
+	async ensurePackageSummaryCache() {
+		const stat = await fs.promises.stat(this.filepath);
+		this.packageSummaryTimestamp = stat.mtime.getTime();
+		if (this.logCache.shouldWritePackageSummary()) await this.logCache.writePackageSummary(stat, this.createLogCacheState());
+	}
+	async readPackageSummaryChanges() {
+		const stat = await fs.promises.stat(this.filepath);
+		const mtime = stat.mtime.getTime();
+		if (mtime <= this.packageSummaryTimestamp) {
+			if (this.packageSummaryOnly && this.logCache.shouldWritePackageSummary()) await this.logCache.writePackageSummary(stat, this.createLogCacheState());
+			return;
+		}
+		if (await this.logCache.restorePackageSummary(stat, this.createLogCacheState())) {
+			this.clearModuleMetricsCache();
+			this.pendingModuleMetrics.clear();
+			this.packageSummaryOnly = true;
+			this.summaryOnly = false;
+			return;
+		}
+		this.disposeData();
+		const sourceRefSizes = /* @__PURE__ */ new Map();
+		await this.readEventLines(0, (event) => {
+			if (event.action === "StringRef") {
+				sourceRefSizes.set(event.id, getContentByteSize(event.content));
+				return;
+			}
+			if (event.action === "HookTransformCallEnd") {
+				this.recordPackageTransformEnd(event, sourceRefSizes);
+				return;
+			}
+			if (event.action === "ChunkGraphReady" || event.action === "ModuleGraphReady") this.manager.handleEvent(event);
+		}, {
+			onlyActions: PACKAGE_SUMMARY_ACTIONS,
+			maxLineBytes: PACKAGE_SUMMARY_MAX_PARSED_LINE_BYTES,
+			largeLineActions: PACKAGE_SUMMARY_LARGE_LINE_ACTIONS,
+			onSkippedLine: (line) => this.recordPackageSummarySkippedLine(line, sourceRefSizes)
+		});
+		for (const [id, metrics] of this.manager.module_build_metrics) {
+			const module = this.manager.modules.get(id);
+			if (module) module.build_metrics = metrics;
+		}
+		this.packageSummaryTimestamp = mtime;
+		this.packageSummaryOnly = true;
+		this.summaryOnly = false;
+		this.logCache.resetPackageSummaryWriteAttempt();
+		await this.logCache.writePackageSummary(stat, this.createLogCacheState());
+	}
+	recordPackageSummarySkippedLine(line, sourceRefSizes) {
+		if (line.action === "StringRef") {
+			const id = getPreviewStringValue(line.preview, "id");
+			if (id) sourceRefSizes.set(id, estimateContentByteSizeFromLine(line.preview, line.location));
+			return;
+		}
+		if (line.action === "HookTransformCallEnd") {
+			const moduleId = getPreviewStringValue(line.preview, "module_id");
+			if (moduleId) this.recordPackageTransformSize(moduleId, estimateContentByteSizeFromLine(line.preview, line.location));
+		}
+	}
+	recordPackageTransformEnd(event, refs) {
+		if (!event.module_id) return;
+		this.recordPackageTransformSize(event.module_id, getReferencedContentByteSize(event.content, refs), event);
+	}
+	recordPackageTransformSize(moduleId, transformedCodeSize, event) {
+		const moduleBuildMetrics = this.manager.module_build_metrics.get(moduleId) ?? {
+			resolve_ids: [],
+			loads: [],
+			transforms: []
+		};
+		moduleBuildMetrics.transforms.push({
+			type: "transform",
+			id: "",
+			plugin_name: event?.plugin_name ?? "",
+			plugin_id: event?.plugin_id ?? 0,
+			content_from: null,
+			content_to: null,
+			source_code_size: 0,
+			transformed_code_size: transformedCodeSize,
+			timestamp_start: +(event?.timestamp ?? 0),
+			timestamp_end: +(event?.timestamp ?? 0),
+			duration: 0
+		});
+		this.manager.module_build_metrics.set(moduleId, moduleBuildMetrics);
+	}
+	getModuleEventIndex(module) {
+		let index = this.moduleEventIndex.get(module);
+		if (!index) {
+			index = {
+				resolveIds: /* @__PURE__ */ new Map(),
+				loads: /* @__PURE__ */ new Map(),
+				transforms: /* @__PURE__ */ new Map()
+			};
+			this.moduleEventIndex.set(module, index);
+		}
+		return index;
+	}
+	indexEvent(event, location) {
+		if (event.action === "StringRef") {
+			this.stringRefIndex.set(event.id, location);
+			return;
+		}
+		if (event.action === "HookResolveIdCallStart" && event.call_id) {
+			this.pendingHookCallStarts.set(event.call_id, { location });
+			return;
+		}
+		if (event.action === "HookResolveIdCallEnd" && event.call_id) {
+			const start = this.pendingHookCallStarts.get(event.call_id);
+			this.pendingHookCallStarts.delete(event.call_id);
+			if (!start || !event.event_id || !event.resolved_id) return;
+			this.getModuleEventIndex(event.resolved_id).resolveIds.set(event.event_id, {
+				start: start.location,
+				end: location
+			});
+			return;
+		}
+		if (event.action === "HookLoadCallStart" && event.call_id && event.module_id) {
+			this.pendingHookCallStarts.set(event.call_id, {
+				module: event.module_id,
+				location
+			});
+			return;
+		}
+		if (event.action === "HookLoadCallEnd" && event.module_id && event.event_id) {
+			const start = event.call_id ? this.pendingHookCallStarts.get(event.call_id) : void 0;
+			if (event.call_id) this.pendingHookCallStarts.delete(event.call_id);
+			if (!start) return;
+			this.getModuleEventIndex(event.module_id).loads.set(event.event_id, {
+				start: start.location,
+				end: location
+			});
+			return;
+		}
+		if (event.action === "HookTransformCallStart" && event.call_id && event.module_id) {
+			this.pendingHookCallStarts.set(event.call_id, {
+				module: event.module_id,
+				location
+			});
+			return;
+		}
+		if (event.action === "HookTransformCallEnd" && event.call_id) {
+			const start = this.pendingHookCallStarts.get(event.call_id);
+			this.pendingHookCallStarts.delete(event.call_id);
+			if (!start) return;
+			if (!event.event_id) return;
+			this.getModuleEventIndex(event.module_id ?? start.module).transforms.set(event.event_id, {
+				start: start.location,
+				end: location
+			});
+			return;
+		}
+		if (event.action === "ModuleGraphReady") this.pendingHookCallStarts.clear();
+	}
+	async readEventsAt(locations) {
+		if (!locations.length) return [];
+		const file = await fs.promises.open(this.filepath, "r");
+		try {
+			const events = [];
+			for (const location of locations) {
+				const buffer = Buffer$1.allocUnsafe(location.length);
+				const { bytesRead } = await file.read(buffer, 0, location.length, location.offset);
+				let end = bytesRead;
+				if (end > 0 && buffer[end - 1] === LINE_FEED) end -= 1;
+				if (end > 0 && buffer[end - 1] === CARRIAGE_RETURN) end -= 1;
+				const text = buffer.subarray(0, end).toString("utf8");
+				if (!text) {
+					events.push(void 0);
+					continue;
+				}
+				try {
+					events.push(parseToEvent(text));
+				} catch {
+					events.push(void 0);
+				}
+			}
+			return events;
+		} finally {
+			await file.close();
+		}
+	}
+	async readStringRefs(refs) {
+		const values = /* @__PURE__ */ new Map();
+		if (!refs.size) return values;
+		const ids = [];
+		const locations = [];
+		for (const id of refs) {
+			const location = this.stringRefIndex.get(id);
+			if (!location) continue;
+			ids.push(id);
+			locations.push(location);
+		}
+		const events = await this.readEventsAt(locations);
+		for (const [index, event] of events.entries()) if (event?.action === "StringRef") values.set(ids[index], event.content);
+		return values;
+	}
+	async readModuleBuildMetrics(module) {
+		await this.read();
+		const cached = this.moduleMetricsCache.get(module);
+		if (cached) {
+			this.moduleMetricsCache.delete(module);
+			this.moduleMetricsCache.set(module, cached);
+			return cloneModuleBuildMetrics(cached.metrics);
+		}
+		if (this.metricsSummaryOnly) {
+			const metrics = await this.hydrateModuleBuildMetricsFromIndex(module);
+			if (metrics) {
+				this.setCachedModuleBuildMetrics(module, metrics);
+				return cloneModuleBuildMetrics(metrics);
+			}
+		}
+		const pending = this.pendingModuleMetrics.get(module);
+		if (pending) return cloneModuleBuildMetrics(await pending);
+		const promise = this.hydrateModuleBuildMetrics(module);
+		this.pendingModuleMetrics.set(module, promise);
+		try {
+			const metrics = await promise;
+			this.setCachedModuleBuildMetrics(module, metrics);
+			return cloneModuleBuildMetrics(metrics);
+		} finally {
+			this.pendingModuleMetrics.delete(module);
+		}
+	}
+	async hydratePluginBuildMetrics(pluginId) {
+		await this.read();
+		let metrics = this.manager.plugin_build_metrics.get(pluginId);
+		if (!metrics && this.metricsSummaryOnly) {
+			metrics = await this.hydratePluginBuildMetricsFromIndex(pluginId);
+			if (metrics) this.manager.plugin_build_metrics.set(pluginId, metrics);
+		}
+		if (!metrics) return;
+		const transformCalls = metrics.calls.filter((call) => call.type === "transform" && call.unchanged == null);
+		if (!transformCalls.length) return;
+		const refs = /* @__PURE__ */ new Set();
+		const transformEventIndexes = [];
+		const locations = [];
+		for (const call of transformCalls) {
+			const location = this.moduleEventIndex.get(call.module)?.transforms.get(call.id);
+			if (!location) {
+				transformEventIndexes.push(void 0);
+				continue;
+			}
+			transformEventIndexes.push(locations.length);
+			locations.push(location.start, location.end);
+		}
+		const events = await this.readEventsAt(locations);
+		const contents = transformCalls.map((call, index) => {
+			const eventIndex = transformEventIndexes[index];
+			if (eventIndex == null) return {
+				call,
+				content_from: void 0,
+				content_to: void 0
+			};
+			const start = events[eventIndex];
+			const end = events[eventIndex + 1];
+			return {
+				call,
+				content_from: start?.action === "HookTransformCallStart" ? getDeferredContent(start, refs) : {
+					value: null,
+					ref: null
+				},
+				content_to: end?.action === "HookTransformCallEnd" ? getDeferredContent(end, refs) : {
+					value: null,
+					ref: null
+				}
+			};
+		});
+		const refValues = await this.readStringRefs(refs);
+		for (const item of contents) {
+			if (!item.content_from || !item.content_to) {
+				item.call.unchanged = false;
+				continue;
+			}
+			const contentFrom = resolveDeferredContent(item.content_from, refValues);
+			const contentTo = resolveDeferredContent(item.content_to, refValues);
+			item.call.unchanged = getContentHash(contentFrom) === getContentHash(contentTo);
+		}
+	}
+	clearModuleMetricsCache() {
+		this.moduleMetricsCache.clear();
+		this.moduleMetricsCacheBytes = 0;
+	}
+	setCachedModuleBuildMetrics(module, metrics) {
+		const bytes = getModuleBuildMetricsCacheBytes(metrics);
+		const previous = this.moduleMetricsCache.get(module);
+		if (previous) {
+			this.moduleMetricsCacheBytes -= previous.bytes;
+			this.moduleMetricsCache.delete(module);
+		}
+		if (bytes > MAX_MODULE_METRICS_CACHE_BYTES) return;
+		this.moduleMetricsCache.set(module, {
+			metrics,
+			bytes
+		});
+		this.moduleMetricsCacheBytes += bytes;
+		while (this.moduleMetricsCache.size > MAX_MODULE_METRICS_CACHE || this.moduleMetricsCacheBytes > MAX_MODULE_METRICS_CACHE_BYTES) {
+			const firstKey = this.moduleMetricsCache.keys().next().value;
+			if (firstKey == null) break;
+			const deleted = this.moduleMetricsCache.get(firstKey);
+			this.moduleMetricsCache.delete(firstKey);
+			if (deleted) this.moduleMetricsCacheBytes -= deleted.bytes;
+		}
+	}
+	async readIndexedHookEvents(calls) {
+		const locations = calls.flatMap(([, call]) => [call.start, call.end]);
+		const events = await this.readEventsAt(locations);
+		return calls.map(([id], index) => ({
+			id,
+			start: events[index * 2],
+			end: events[index * 2 + 1]
+		}));
+	}
+	async hydrateModuleBuildMetricsFromIndex(module) {
+		const index = this.moduleEventIndex.get(module);
+		if (!index) return void 0;
+		const [resolveEvents, loadEvents, transformEvents] = await Promise.all([
+			this.readIndexedHookEvents(Array.from(index.resolveIds.entries())),
+			this.readIndexedHookEvents(Array.from(index.loads.entries())),
+			this.readIndexedHookEvents(Array.from(index.transforms.entries()))
+		]);
+		const refs = /* @__PURE__ */ new Set();
+		const resolve_ids = [];
+		for (const item of resolveEvents) {
+			const start = item.start;
+			const end = item.end;
+			if (start?.action !== "HookResolveIdCallStart" || end?.action !== "HookResolveIdCallEnd") continue;
+			resolve_ids.push({
+				type: "resolve",
+				id: item.id,
+				plugin_name: end.plugin_name,
+				plugin_id: end.plugin_id,
+				importer: start.importer,
+				module_request: start.module_request,
+				import_kind: start.import_kind,
+				resolved_id: end.resolved_id,
+				timestamp_start: +start.timestamp,
+				timestamp_end: +end.timestamp,
+				duration: +end.timestamp - +start.timestamp
+			});
+		}
+		const loads = [];
+		for (const item of loadEvents) {
+			const start = item.start;
+			const end = item.end;
+			if (start?.action !== "HookLoadCallStart" || end?.action !== "HookLoadCallEnd") continue;
+			loads.push({
+				type: "load",
+				id: item.id,
+				plugin_name: end.plugin_name,
+				plugin_id: end.plugin_id,
+				content: getDeferredContent(end, refs),
+				timestamp_start: +start.timestamp,
+				timestamp_end: +end.timestamp,
+				duration: +end.timestamp - +start.timestamp
+			});
+		}
+		const transforms = [];
+		for (const item of transformEvents) {
+			const start = item.start;
+			const end = item.end;
+			if (start?.action !== "HookTransformCallStart" || end?.action !== "HookTransformCallEnd") continue;
+			transforms.push({
+				type: "transform",
+				id: item.id,
+				plugin_name: end.plugin_name,
+				plugin_id: end.plugin_id,
+				content_from: getDeferredContent(start, refs),
+				content_to: getDeferredContent(end, refs),
+				timestamp_start: +start.timestamp,
+				timestamp_end: +end.timestamp,
+				duration: +end.timestamp - +start.timestamp,
+				source_code_size: 0,
+				transformed_code_size: 0
+			});
+		}
+		const refValues = await this.readStringRefs(refs);
+		return {
+			resolve_ids,
+			loads: loads.map((load) => ({
+				...load,
+				content: resolveDeferredContent(load.content, refValues)
+			})),
+			transforms: transforms.map((transform) => {
+				const content_from = resolveDeferredContent(transform.content_from, refValues);
+				const content_to = resolveDeferredContent(transform.content_to, refValues);
+				return {
+					...transform,
+					content_from,
+					content_to,
+					source_code_size: getContentByteSize(content_from ?? ""),
+					transformed_code_size: getContentByteSize(content_to ?? "")
+				};
+			})
+		};
+	}
+	async hydratePluginBuildMetricsFromIndex(pluginId) {
+		const calls = [];
+		for (const [module, index] of this.moduleEventIndex) {
+			for (const [id, location] of index.resolveIds) calls.push({
+				module,
+				type: "resolve",
+				id,
+				location
+			});
+			for (const [id, location] of index.loads) calls.push({
+				module,
+				type: "load",
+				id,
+				location
+			});
+			for (const [id, location] of index.transforms) calls.push({
+				module,
+				type: "transform",
+				id,
+				location
+			});
+		}
+		const events = await this.readIndexedHookEvents(calls.map((call) => [call.id, call.location]));
+		const metrics = {
+			plugin_id: pluginId,
+			plugin_name: "",
+			calls: []
+		};
+		for (const [index, item] of events.entries()) {
+			const call = calls[index];
+			const start = item.start;
+			const end = item.end;
+			if (!start || !end || !("plugin_id" in end) || end.plugin_id !== pluginId) continue;
+			const timestamp_start = "timestamp" in start ? +start.timestamp : 0;
+			const timestamp_end = "timestamp" in end ? +end.timestamp : 0;
+			metrics.plugin_name = end.plugin_name;
+			metrics.calls.push({
+				type: call.type,
+				id: call.id,
+				duration: timestamp_end - timestamp_start,
+				plugin_id: pluginId,
+				plugin_name: end.plugin_name,
+				module: call.type === "resolve" && start.action === "HookResolveIdCallStart" ? start.module_request : call.module,
+				timestamp_start,
+				timestamp_end,
+				unchanged: call.type === "load" && end.action === "HookLoadCallEnd" ? !end.content : void 0
+			});
+		}
+		metrics.calls.sort((a, b) => a.timestamp_start - b.timestamp_start);
+		return metrics.calls.length ? metrics : void 0;
+	}
+	async hydrateModuleBuildMetrics(module) {
+		const summary = this.manager.module_build_metrics.get(module) ?? {
+			resolve_ids: [],
+			loads: [],
+			transforms: []
+		};
+		const index = this.moduleEventIndex.get(module);
+		const refs = /* @__PURE__ */ new Set();
+		const loadEventIndexes = [];
+		const loadLocations = [];
+		for (const load of summary.loads) {
+			const location = index?.loads.get(load.id)?.end;
+			if (!location) {
+				loadEventIndexes.push(void 0);
+				continue;
+			}
+			loadEventIndexes.push(loadLocations.length);
+			loadLocations.push(location);
+		}
+		const transformEventIndexes = [];
+		const transformLocations = [];
+		for (const transform of summary.transforms) {
+			const location = index?.transforms.get(transform.id);
+			if (!location) {
+				transformEventIndexes.push(void 0);
+				continue;
+			}
+			transformEventIndexes.push(transformLocations.length);
+			transformLocations.push(location.start, location.end);
+		}
+		const loadEvents = await this.readEventsAt(loadLocations);
+		const transformEvents = await this.readEventsAt(transformLocations);
+		const loads = summary.loads.map((load, index) => {
+			const eventIndex = loadEventIndexes[index];
+			const event = eventIndex == null ? void 0 : loadEvents[eventIndex];
+			return {
+				...load,
+				content: event?.action === "HookLoadCallEnd" ? getDeferredContent(event, refs) : {
+					value: load.content,
+					ref: null
+				}
+			};
+		});
+		const transforms = summary.transforms.map((transform, index) => {
+			const eventIndex = transformEventIndexes[index];
+			const start = eventIndex == null ? void 0 : transformEvents[eventIndex];
+			const end = eventIndex == null ? void 0 : transformEvents[eventIndex + 1];
+			return {
+				...transform,
+				content_from: start?.action === "HookTransformCallStart" ? getDeferredContent(start, refs) : {
+					value: transform.content_from,
+					ref: null
+				},
+				content_to: end?.action === "HookTransformCallEnd" ? getDeferredContent(end, refs) : {
+					value: transform.content_to,
+					ref: null
+				}
+			};
+		});
+		const refValues = await this.readStringRefs(refs);
+		return {
+			resolve_ids: summary.resolve_ids.map((resolve) => ({ ...resolve })),
+			loads: loads.map((load) => ({
+				...load,
+				content: resolveDeferredContent(load.content, refValues)
+			})),
+			transforms: transforms.map((transform) => {
+				const content_from = resolveDeferredContent(transform.content_from, refValues);
+				const content_to = resolveDeferredContent(transform.content_to, refValues);
+				return {
+					...transform,
+					content_from,
+					content_to,
+					source_code_size: getContentByteSize(content_from ?? ""),
+					transformed_code_size: getContentByteSize(content_to ?? "")
+				};
+			})
+		};
+	}
+	hasPendingRead() {
+		return !!this.pendingRead || !!this.pendingSummaryRead || !!this.pendingPackageSummaryRead;
+	}
+	hasReadData() {
+		return this.lastBytes > 0 || this.manager.eventCount > 0;
+	}
+	createLogCacheState() {
+		return Object.defineProperties({}, {
+			lastBytes: {
+				get: () => this.lastBytes,
+				set: (value) => {
+					this.lastBytes = value;
+				}
+			},
+			lastTimestamp: {
+				get: () => this.lastTimestamp,
+				set: (value) => {
+					this.lastTimestamp = value;
+				}
+			},
+			lineNumber: {
+				get: () => this.lineNumber,
+				set: (value) => {
+					this.lineNumber = value;
+				}
+			},
+			moduleEventIndex: {
+				get: () => this.moduleEventIndex,
+				set: (value) => {
+					this.moduleEventIndex = value;
+				}
+			},
+			stringRefIndex: {
+				get: () => this.stringRefIndex,
+				set: (value) => {
+					this.stringRefIndex = value;
+				}
+			},
+			pendingHookCallStarts: {
+				get: () => this.pendingHookCallStarts,
+				set: (value) => {
+					this.pendingHookCallStarts = value;
+				}
+			},
+			assetsReadyLocations: {
+				get: () => this.assetsReadyLocations,
+				set: (value) => {
+					this.assetsReadyLocations = value;
+				}
+			},
+			meta: {
+				get: () => this.meta,
+				set: (value) => {
+					this.meta = value;
+				}
+			},
+			manager: { get: () => this.manager },
+			packageSummaryTimestamp: {
+				get: () => this.packageSummaryTimestamp,
+				set: (value) => {
+					this.packageSummaryTimestamp = value;
+				}
+			},
+			metricsSummaryOnly: {
+				get: () => this.metricsSummaryOnly,
+				set: (value) => {
+					this.metricsSummaryOnly = value;
+				}
+			}
+		});
+	}
+	hasCompleteSession() {
+		return this.hasReadData() && !this.summaryOnly && !this.packageSummaryOnly;
+	}
+	isReadingCompleteSession() {
+		return !!this.pendingRead;
 	}
 	dispose() {
-		readers.delete(this.filepath);
+		readers.delete(this.cacheKey);
+		this.disposeData();
+	}
+	resetReadState() {
+		this.lastBytes = 0;
+		this.lastTimestamp = 0;
+		this.disposeData();
+	}
+	disposeData() {
 		this.manager.dispose();
+		this.lineNumber = 0;
+		this.moduleEventIndex.clear();
+		this.stringRefIndex.clear();
+		this.pendingHookCallStarts.clear();
+		this.clearModuleMetricsCache();
+		this.pendingModuleMetrics.clear();
+		this.assetsReadyLocations = [];
+		this.assetsHydrated = false;
+		this.summaryOnly = false;
+		this.packageSummaryOnly = false;
+		this.metricsSummaryOnly = false;
+		this.logCache.resetCompleteSessionWriteAttempt();
+		this.logCache.resetPackageSummaryWriteAttempt();
 	}
 	[Symbol.dispose]() {
 		this.dispose();
@@ -322,16 +1650,17 @@ var RolldownLogsManager = class {
 	async list() {
 		if (!existsSync(this.dir)) return [];
 		const sessions = await fs$1.readdir(this.dir, { withFileTypes: true });
-		return await Promise.all(sessions.filter((d) => d.isDirectory()).filter((d) => existsSync(join(this.dir, d.name, "meta.json"))).map(async (d) => {
+		return (await Promise.all(sessions.filter((d) => d.isDirectory()).filter((d) => existsSync(join(this.dir, d.name, "meta.json"))).map(async (d) => {
 			const reader = RolldownEventsReader.get(join(this.dir, d.name, "meta.json"));
 			await reader.read();
-			const meta = reader.manager.events.at(-1);
+			const meta = reader.meta;
+			if (!meta) return;
 			return {
 				id: d.name,
 				timestamp: meta.timestamp,
 				meta
 			};
-		}));
+		}))).filter((entry) => !!entry);
 	}
 	async loadSession(session) {
 		const reader = RolldownEventsReader.get(join(this.dir, session, "logs.json"));
@@ -339,7 +1668,44 @@ var RolldownLogsManager = class {
 		if (!reader.meta) {
 			const metaReader = RolldownEventsReader.get(join(this.dir, session, "meta.json"));
 			await metaReader.read();
-			reader.meta = metaReader.manager.events.at(-1);
+			reader.meta = metaReader.meta;
+		}
+		return reader;
+	}
+	async loadSessionSummary(session) {
+		const reader = RolldownEventsReader.get(join(this.dir, session, "logs.json"));
+		await reader.readSummary();
+		if (!reader.meta) {
+			const metaReader = RolldownEventsReader.get(join(this.dir, session, "meta.json"));
+			await metaReader.read();
+			reader.meta = metaReader.meta;
+		}
+		return reader;
+	}
+	async loadAssetSession(session) {
+		const reader = await this.loadSession(session);
+		await reader.readAssets();
+		return reader;
+	}
+	async loadPackageSession(session) {
+		const filepath = join(this.dir, session, "logs.json");
+		const loadedReader = RolldownEventsReader.peek(filepath);
+		if (loadedReader?.hasCompleteSession() || loadedReader?.isReadingCompleteSession()) {
+			await loadedReader.read();
+			await loadedReader.ensurePackageSummaryCache();
+			if (!loadedReader.meta) {
+				const metaReader = RolldownEventsReader.get(join(this.dir, session, "meta.json"));
+				await metaReader.read();
+				loadedReader.meta = metaReader.meta;
+			}
+			return loadedReader;
+		}
+		const reader = RolldownEventsReader.get(filepath, `${filepath}:package-summary`);
+		await reader.readPackageSummary();
+		if (!reader.meta) {
+			const metaReader = RolldownEventsReader.get(join(this.dir, session, "meta.json"));
+			await metaReader.read();
+			reader.meta = metaReader.meta;
 		}
 		return reader;
 	}
@@ -352,7 +1718,7 @@ function getLogsManager(context) {
 	if (!manager) {
 		const dirs = [join(context.cwd, "node_modules", ".rolldown"), join(process$1.cwd(), "node_modules", ".rolldown")];
 		const dir = dirs.find((dir) => existsSync(dir));
-		if (!dir) logger.RDDT0001().log();
+		if (!dir) diagnostics.RDDT0001();
 		manager = new RolldownLogsManager(dir ?? dirs[0]);
 	}
 	return manager;
@@ -367,7 +1733,7 @@ const rolldownGetAssetDetails = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, id }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadAssetSession(session);
 			const assets = reader.manager.assets;
 			const chunks = reader.manager.chunks;
 			const asset = assets.get(id);
@@ -395,7 +1761,7 @@ const rolldownGetAssetsList = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadAssetSession(session);
 			return Array.from(reader.manager.assets.values());
 		} };
 	}
@@ -410,7 +1776,7 @@ const rolldownGetChunkInfo = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, id }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadAssetSession(session);
 			const chunk = reader.manager.chunks.get(id);
 			chunk.asset = reader.manager.chunkAssetMap.get(chunk.chunk_id);
 			return chunk;
@@ -427,7 +1793,7 @@ const rolldownGetChunksGraph = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadAssetSession(session);
 			const chunks = Array.from(reader.manager.chunks.values());
 			chunks.forEach((chunk) => {
 				chunk.asset = reader.manager.chunkAssetMap.get(chunk.chunk_id);
@@ -446,9 +1812,10 @@ const rolldownGetModuleInfo = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, module }) => {
-			const reader = await manager.loadSession(session);
-			if (!reader.manager.events.length) return null;
+			const reader = await manager.loadAssetSession(session);
+			if (!reader.manager.eventCount) return null;
 			const moduleInfo = reader.manager.modules.get(module);
+			const moduleMetrics = await reader.readModuleBuildMetrics(module);
 			const info = {
 				id: module,
 				imports: [],
@@ -461,8 +1828,8 @@ const rolldownGetModuleInfo = defineRpcFunction({
 					transforms: []
 				},
 				...moduleInfo || {},
-				loads: moduleInfo?.build_metrics?.loads ?? [],
-				resolve_ids: moduleInfo?.build_metrics?.resolve_ids ?? []
+				loads: moduleMetrics.loads,
+				resolve_ids: moduleMetrics.resolve_ids
 			};
 			info.chunks = Array.from(reader.manager.chunks.values()).filter((chunk) => chunk.modules.includes(module)).map((chunk) => ({
 				type: "chunk",
@@ -479,19 +1846,6 @@ const rolldownGetModuleInfo = defineRpcFunction({
 	}
 });
 //#endregion
-//#region src/node/rpc/functions/rolldown-get-module-raw-events.ts
-const rolldownGetModuleRawEvents = defineRpcFunction({
-	name: "vite:rolldown:get-module-raw-events",
-	type: "query",
-	jsonSerializable: true,
-	setup: (context) => {
-		const manager = getLogsManager(context);
-		return { handler: async ({ session, module }) => {
-			return { events: (await manager.loadSession(session)).manager.events.filter((event) => "module_id" in event && event.module_id !== module) };
-		} };
-	}
-});
-//#endregion
 //#region src/node/rpc/functions/rolldown-get-module-transforms.ts
 const rolldownGetModuleTransforms = defineRpcFunction({
 	name: "vite:rolldown:get-module-transforms",
@@ -501,9 +1855,8 @@ const rolldownGetModuleTransforms = defineRpcFunction({
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, module }) => {
 			const reader = await manager.loadSession(session);
-			const events = reader.manager.events;
-			const transforms = reader.manager.modules.get(module)?.build_metrics?.transforms ?? [];
-			if (!events.length) return transforms.map((transform) => ({
+			const { transforms } = await reader.readModuleBuildMetrics(module);
+			if (!reader.manager.eventCount) return transforms.map((transform) => ({
 				...transform,
 				diff_added: 0,
 				diff_removed: 0
@@ -1033,6 +2386,96 @@ var require_logger = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 //#endregion
+//#region ../../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js
+var require_split2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { Transform } = __require("stream");
+	const { StringDecoder } = __require("string_decoder");
+	const kLast = Symbol("last");
+	const kDecoder = Symbol("decoder");
+	function transform(chunk, enc, cb) {
+		let list;
+		if (this.overflow) {
+			list = this[kDecoder].write(chunk).split(this.matcher);
+			if (list.length === 1) return cb();
+			list.shift();
+			this.overflow = false;
+		} else {
+			this[kLast] += this[kDecoder].write(chunk);
+			list = this[kLast].split(this.matcher);
+		}
+		this[kLast] = list.pop();
+		for (let i = 0; i < list.length; i++) try {
+			push(this, this.mapper(list[i]));
+		} catch (error) {
+			return cb(error);
+		}
+		this.overflow = this[kLast].length > this.maxLength;
+		if (this.overflow && !this.skipOverflow) {
+			cb(/* @__PURE__ */ new Error("maximum buffer reached"));
+			return;
+		}
+		cb();
+	}
+	function flush(cb) {
+		this[kLast] += this[kDecoder].end();
+		if (this[kLast]) try {
+			push(this, this.mapper(this[kLast]));
+		} catch (error) {
+			return cb(error);
+		}
+		cb();
+	}
+	function push(self, val) {
+		if (val !== void 0) self.push(val);
+	}
+	function noop(incoming) {
+		return incoming;
+	}
+	function split(matcher, mapper, options) {
+		matcher = matcher || /\r?\n/;
+		mapper = mapper || noop;
+		options = options || {};
+		switch (arguments.length) {
+			case 1:
+				if (typeof matcher === "function") {
+					mapper = matcher;
+					matcher = /\r?\n/;
+				} else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
+					options = matcher;
+					matcher = /\r?\n/;
+				}
+				break;
+			case 2: if (typeof matcher === "function") {
+				options = mapper;
+				mapper = matcher;
+				matcher = /\r?\n/;
+			} else if (typeof mapper === "object") {
+				options = mapper;
+				mapper = noop;
+			}
+		}
+		options = Object.assign({}, options);
+		options.autoDestroy = true;
+		options.transform = transform;
+		options.flush = flush;
+		options.readableObjectMode = true;
+		const stream = new Transform(options);
+		stream[kLast] = "";
+		stream[kDecoder] = new StringDecoder("utf8");
+		stream.matcher = matcher;
+		stream.mapper = mapper;
+		stream.maxLength = options.maxLength;
+		stream.skipOverflow = options.skipOverflow || false;
+		stream.overflow = false;
+		stream._destroy = function(err, cb) {
+			this._writableState.errorEmitted = false;
+			cb(err);
+		};
+		return stream;
+	}
+	module.exports = split;
+}));
+//#endregion
 //#region ../../node_modules/.pnpm/@pnpm+logger@1001.0.1/node_modules/@pnpm/logger/lib/ndjsonParse.js
 var require_ndjsonParse = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var __importDefault = exports && exports.__importDefault || function(mod) {
@@ -1040,7 +2483,7 @@ var require_ndjsonParse = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.parse = parse;
-	const split2_1 = __importDefault(__require("split2"));
+	const split2_1 = __importDefault(require_split2());
 	const opts = { strict: true };
 	function parse() {
 		function parseRow(row) {
@@ -9893,66 +11336,84 @@ function getPackageDirPath(path) {
 }
 //#endregion
 //#region src/node/rpc/functions/rolldown-get-packages.ts
-async function getPackagesManifest(reader) {
-	const modulesMap = reader.manager.modules;
-	const chunks = Array.from(reader.manager.chunks.values());
-	const packagesManifest = /* @__PURE__ */ new Map();
-	const getImporters = (path, packageDir, visited = /* @__PURE__ */ new Set()) => {
-		const importers = modulesMap.get(path)?.importers || [];
-		const result = [];
-		for (const importer of importers) {
-			if (visited.has(importer)) continue;
-			visited.add(importer);
-			if ((modulesMap.get(importer)?.imports?.map((i) => i.module_id) || []).some((i) => getPackageDirPath(i) === packageDir)) result.push(importer);
-			result.push(...getImporters(importer, packageDir, visited));
+function createPackageManifestReader() {
+	const manifestCache = /* @__PURE__ */ new Map();
+	return (dir) => {
+		let promise = manifestCache.get(dir);
+		if (!promise) {
+			promise = (0, import_lib.readProjectManifestOnly)(dir).catch((err) => {
+				if (err?.code === "ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND") return null;
+				throw err;
+			});
+			manifestCache.set(dir, promise);
 		}
-		return result;
+		return promise;
 	};
-	const packages = chunks.map((chunk) => chunk.modules.map((module) => module)).flat().filter(isNodeModulePath).map((p) => {
-		const moduleBuildMetrics = modulesMap.get(p)?.build_metrics;
+}
+async function getPackagesManifest(reader, readPackageManifest = createPackageManifestReader()) {
+	const modulesMap = reader.manager.modules;
+	const chunks = Array.from(reader.manager.chunks.values());
+	const packagesMap = /* @__PURE__ */ new Map();
+	const packageImportersMap = /* @__PURE__ */ new Map();
+	const packageModules = chunks.flatMap((chunk) => chunk.modules).filter(isNodeModulePath).map((path) => {
+		const moduleBuildMetrics = modulesMap.get(path)?.build_metrics;
 		return {
-			path: p,
-			dir: getPackageDirPath(p),
-			transformedCodeSize: moduleBuildMetrics?.transforms[moduleBuildMetrics?.transforms.length - 1]?.transformed_code_size ?? 0
+			path,
+			dir: getPackageDirPath(path),
+			transformedCodeSize: moduleBuildMetrics?.transforms[moduleBuildMetrics.transforms.length - 1]?.transformed_code_size ?? 0
 		};
 	});
-	await Promise.all(packages.map(async (p) => {
-		let packageKey = "";
-		let manifest = null;
-		try {
-			manifest = await (0, import_lib.readProjectManifestOnly)(p.dir);
-			packageKey = `${manifest.name}@${manifest.version}`;
-		} catch (err) {
-			if (err?.code === "ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND") packageKey = `${p.dir}`;
-			else throw err;
-		}
-		const packageInfo = packagesManifest.get(packageKey);
-		const importers = getImporters(p.path, p.dir).map((i) => ({
-			path: i,
+	const packageModulePaths = /* @__PURE__ */ new Map();
+	for (const item of packageModules) {
+		let paths = packageModulePaths.get(item.dir);
+		if (!paths) {
+			paths = /* @__PURE__ */ new Set();
+			packageModulePaths.set(item.dir, paths);
+		}
+		paths.add(item.path);
+	}
+	const getPackageImporters = (packageDir) => {
+		const cached = packageImportersMap.get(packageDir);
+		if (cached) return cached;
+		const importers = /* @__PURE__ */ new Set();
+		for (const path of packageModulePaths.get(packageDir) ?? []) for (const importer of modulesMap.get(path)?.importers ?? []) {
+			if (importer.startsWith(packageDir)) continue;
+			if (modulesMap.get(importer)?.imports?.some((i) => getPackageDirPath(i.module_id) === packageDir)) importers.add(importer);
+		}
+		const result = Array.from(importers).sort((a, b) => a.localeCompare(b));
+		packageImportersMap.set(packageDir, result);
+		return result;
+	};
+	const manifests = await Promise.all(packageModules.map(async (item) => ({
+		item,
+		manifest: await readPackageManifest(item.dir)
+	})));
+	for (const { item, manifest } of manifests) {
+		const packageKey = manifest ? `${manifest.name}@${manifest.version}` : `${item.dir}`;
+		const packageInfo = packagesMap.get(packageKey);
+		const importers = packageInfo ? [] : getPackageImporters(item.dir).map((path) => ({
+			path,
 			version: ""
 		}));
-		if (packageInfo) packagesManifest.set(packageKey, {
-			...packageInfo,
-			files: [...packageInfo.files, {
-				path: p.path,
-				transformedCodeSize: p.transformedCodeSize,
-				importers
-			}],
-			transformedCodeSize: packageInfo.transformedCodeSize + p.transformedCodeSize
-		});
-		else packagesManifest.set(packageKey, {
-			name: manifest?.name || p.dir,
+		const file = {
+			path: item.path,
+			transformedCodeSize: item.transformedCodeSize,
+			importers
+		};
+		if (packageInfo) {
+			packageInfo.files.push(file);
+			packageInfo.transformedCodeSize += item.transformedCodeSize;
+			continue;
+		}
+		packagesMap.set(packageKey, {
+			name: manifest?.name || item.dir,
 			version: manifest?.version || "(unknown)",
-			dir: p.dir,
-			files: [{
-				path: p.path,
-				transformedCodeSize: p.transformedCodeSize,
-				importers
-			}],
-			transformedCodeSize: p.transformedCodeSize
+			dir: item.dir,
+			files: [file],
+			transformedCodeSize: item.transformedCodeSize
 		});
-	}));
-	return packagesManifest;
+	}
+	return packagesMap;
 }
 const rolldownGetPackages = defineRpcFunction({
 	name: "vite:rolldown:get-packages",
@@ -9962,41 +11423,34 @@ const rolldownGetPackages = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadPackageSession(session);
 			const modulesMap = reader.manager.modules;
-			const duplicatePackagesMap = /* @__PURE__ */ new Map();
-			const packagesManifest = await getPackagesManifest(reader);
-			return (await Promise.all(Array.from(packagesManifest.values()).map((p) => {
-				duplicatePackagesMap.set(p.name, (duplicatePackagesMap.get(p.name) ?? 0) + 1);
-				return {
-					...p,
-					type: p.files.some((f) => modulesMap.get(f.path)?.importers?.some((i) => i.includes(reader.meta.cwd))) ? "direct" : "transitive"
-				};
-			}).map(async (p) => {
-				const duplicated = duplicatePackagesMap.get(p.name) > 1;
-				let files = p.files;
-				if (duplicated) files = await Promise.all(files.map(async (f) => {
-					const importers = await Promise.all(f.importers.map(async (i) => {
-						let manifest = null;
-						try {
-							if (isNodeModulePath(i.path)) manifest = await (0, import_lib.readProjectManifestOnly)(getPackageDirPath(i.path));
-						} catch (err) {
-							if (err?.code !== "ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND") throw err;
-						}
+			const packageNameCounts = /* @__PURE__ */ new Map();
+			const readPackageManifest = createPackageManifestReader();
+			const packagesMap = await getPackagesManifest(reader, readPackageManifest);
+			const packages = Array.from(packagesMap.values());
+			for (const item of packages) packageNameCounts.set(item.name, (packageNameCounts.get(item.name) ?? 0) + 1);
+			return (await Promise.all(packages.map(async (item) => {
+				const duplicated = (packageNameCounts.get(item.name) ?? 0) > 1;
+				const files = duplicated ? await Promise.all(item.files.map(async (file) => {
+					const importers = await Promise.all(file.importers.map(async (importer) => {
+						if (!isNodeModulePath(importer.path)) return importer;
+						const manifest = await readPackageManifest(getPackageDirPath(importer.path));
 						return {
-							...i,
+							...importer,
 							version: manifest?.version ?? ""
 						};
 					}));
 					return {
-						...f,
+						...file,
 						importers
 					};
-				}));
+				})) : item.files;
 				return {
-					...p,
+					...item,
 					duplicated,
-					files
+					files,
+					type: item.files.some((f) => modulesMap.get(f.path)?.importers?.some((i) => i.includes(reader.meta.cwd))) ? "direct" : "transitive"
 				};
 			}))).filter((i) => !!i.transformedCodeSize);
 		} };
@@ -10012,7 +11466,7 @@ const rolldownGetPackageDetails = defineRpcFunction({
 	setup: (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, id }) => {
-			return (await getPackagesManifest(await manager.loadSession(session))).get(id);
+			return (await getPackagesManifest(await manager.loadPackageSession(session))).get(id);
 		} };
 	}
 });
@@ -10027,6 +11481,7 @@ const rolldownGetPluginDetails = defineRpcFunction({
 		const manager = getLogsManager(context);
 		return { handler: async ({ session, id }) => {
 			const reader = await manager.loadSession(session);
+			await reader.hydratePluginBuildMetrics(+id);
 			const pluginBuildMetrics = reader.manager.plugin_build_metrics.get(+id);
 			if (!pluginBuildMetrics) return {
 				plugin_name: reader.meta.plugins.find((p) => p.plugin_id === +id)?.name,
@@ -10049,19 +11504,6 @@ const rolldownGetPluginDetails = defineRpcFunction({
 	}
 });
 //#endregion
-//#region src/node/rpc/functions/rolldown-get-raw-events.ts
-const rolldownGetRawEvents = defineRpcFunction({
-	name: "vite:rolldown:get-raw-events",
-	type: "query",
-	jsonSerializable: true,
-	setup: (context) => {
-		const manager = getLogsManager(context);
-		return { handler: async ({ session }) => {
-			return (await manager.loadSession(session)).manager.events;
-		} };
-	}
-});
-//#endregion
 //#region src/node/rpc/functions/rolldown-get-session-compare-summary.ts
 const rolldownGetSessionCompareSummary = defineRpcFunction({
 	name: "vite:rolldown:get-session-compare-summary",
@@ -10071,7 +11513,7 @@ const rolldownGetSessionCompareSummary = defineRpcFunction({
 	setup: async (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ sessions }) => {
-			const reader = await Promise.all(sessions.map((s) => manager.loadSession(s)));
+			const reader = await Promise.all(sessions.map((s) => manager.loadAssetSession(s)));
 			return sessions.map((s, index) => {
 				const _reader = reader[index];
 				const assets = Array.from(_reader.manager.assets.values());
@@ -10104,7 +11546,7 @@ const rolldownGetSessionSummary = defineRpcFunction({
 	setup: async (context) => {
 		const manager = getLogsManager(context);
 		return { handler: async ({ session }) => {
-			const reader = await manager.loadSession(session);
+			const reader = await manager.loadSessionSummary(session);
 			return {
 				id: session,
 				meta: reader.meta,
@@ -10129,10 +11571,8 @@ const rpcFunctions = [
 			} };
 		}
 	}),
-	rolldownGetRawEvents,
 	rolldownGetSessionSummary,
 	rolldownGetModuleInfo,
-	rolldownGetModuleRawEvents,
 	rolldownGetModuleTransforms,
 	rolldownGetChunksGraph,
 	rolldownGetAssetsList,