@vitejs/devtools-vite 0.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1463 @@
+import { clientPublicDir } from "./dirs-Z7VQHyIZ.js";
+import { createRequire } from "node:module";
+import { defineRpcFunction } from "@vitejs/devtools-kit";
+import fs, { existsSync } from "node:fs";
+import process from "node:process";
+import { join } from "pathe";
+import fs$1 from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import split2 from "split2";
+import { diffLines } from "diff";
+import { readProjectManifestOnly } from "@pnpm/read-project-manifest";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/node/rpc/functions/get-payload.ts
+const getPayload = defineRpcFunction({
+	name: "vite:get-payload",
+	type: "static",
+	setup: () => {
+		return { handler: async () => ({ timestamp: Date.now() }) };
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/Utf8Stream.js
+var require_Utf8Stream = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/Utf8Stream.js": ((exports, module) => {
+	const { Transform } = __require("stream");
+	const { StringDecoder } = __require("string_decoder");
+	var Utf8Stream$1 = class extends Transform {
+		constructor(options) {
+			super(Object.assign({}, options, { writableObjectMode: false }));
+			this._buffer = "";
+		}
+		_transform(chunk, encoding, callback) {
+			if (typeof chunk == "string") this._transform = this._transformString;
+			else {
+				this._stringDecoder = new StringDecoder();
+				this._transform = this._transformBuffer;
+			}
+			this._transform(chunk, encoding, callback);
+		}
+		_transformBuffer(chunk, _, callback) {
+			this._buffer += this._stringDecoder.write(chunk);
+			this._processBuffer(callback);
+		}
+		_transformString(chunk, _, callback) {
+			this._buffer += chunk.toString();
+			this._processBuffer(callback);
+		}
+		_processBuffer(callback) {
+			if (this._buffer) {
+				this.push(this._buffer, "utf8");
+				this._buffer = "";
+			}
+			callback(null);
+		}
+		_flushInput() {
+			if (this._stringDecoder) this._buffer += this._stringDecoder.end();
+		}
+		_flush(callback) {
+			this._flushInput();
+			this._processBuffer(callback);
+		}
+	};
+	module.exports = Utf8Stream$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Parser.js
+var require_Parser = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Parser.js": ((exports, module) => {
+	const Utf8Stream = require_Utf8Stream();
+	const patterns = {
+		value1: /^(?:[\"\{\[\]\-\d]|true\b|false\b|null\b|\s{1,256})/,
+		string: /^(?:[^\x00-\x1f\"\\]{1,256}|\\[bfnrt\"\\\/]|\\u[\da-fA-F]{4}|\")/,
+		key1: /^(?:[\"\}]|\s{1,256})/,
+		colon: /^(?:\:|\s{1,256})/,
+		comma: /^(?:[\,\]\}]|\s{1,256})/,
+		ws: /^\s{1,256}/,
+		numberStart: /^\d/,
+		numberDigit: /^\d{0,256}/,
+		numberFraction: /^[\.eE]/,
+		numberExponent: /^[eE]/,
+		numberExpSign: /^[-+]/
+	};
+	const MAX_PATTERN_SIZE = 16;
+	let noSticky = true;
+	try {
+		new RegExp(".", "y");
+		noSticky = false;
+	} catch (e) {}
+	!noSticky && Object.keys(patterns).forEach((key) => {
+		let src = patterns[key].source.slice(1);
+		if (src.slice(0, 3) === "(?:" && src.slice(-1) === ")") src = src.slice(3, -1);
+		patterns[key] = new RegExp(src, "y");
+	});
+	patterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;
+	patterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;
+	const values = {
+		true: true,
+		false: false,
+		null: null
+	}, expected = {
+		object: "objectStop",
+		array: "arrayStop",
+		"": "done"
+	};
+	const fromHex = (s) => String.fromCharCode(parseInt(s.slice(2), 16));
+	const codes = {
+		b: "\b",
+		f: "\f",
+		n: "\n",
+		r: "\r",
+		t: "	",
+		"\"": "\"",
+		"\\": "\\",
+		"/": "/"
+	};
+	var Parser$1 = class Parser$1 extends Utf8Stream {
+		static make(options) {
+			return new Parser$1(options);
+		}
+		constructor(options) {
+			super(Object.assign({}, options, { readableObjectMode: true }));
+			this._packKeys = this._packStrings = this._packNumbers = this._streamKeys = this._streamStrings = this._streamNumbers = true;
+			if (options) {
+				"packValues" in options && (this._packKeys = this._packStrings = this._packNumbers = options.packValues);
+				"packKeys" in options && (this._packKeys = options.packKeys);
+				"packStrings" in options && (this._packStrings = options.packStrings);
+				"packNumbers" in options && (this._packNumbers = options.packNumbers);
+				"streamValues" in options && (this._streamKeys = this._streamStrings = this._streamNumbers = options.streamValues);
+				"streamKeys" in options && (this._streamKeys = options.streamKeys);
+				"streamStrings" in options && (this._streamStrings = options.streamStrings);
+				"streamNumbers" in options && (this._streamNumbers = options.streamNumbers);
+				this._jsonStreaming = options.jsonStreaming;
+			}
+			!this._packKeys && (this._streamKeys = true);
+			!this._packStrings && (this._streamStrings = true);
+			!this._packNumbers && (this._streamNumbers = true);
+			this._done = false;
+			this._expect = this._jsonStreaming ? "done" : "value";
+			this._stack = [];
+			this._parent = "";
+			this._open_number = false;
+			this._accumulator = "";
+		}
+		_flush(callback) {
+			this._done = true;
+			super._flush((error) => {
+				if (error) return callback(error);
+				if (this._open_number) {
+					if (this._streamNumbers) this.push({ name: "endNumber" });
+					this._open_number = false;
+					if (this._packNumbers) {
+						this.push({
+							name: "numberValue",
+							value: this._accumulator
+						});
+						this._accumulator = "";
+					}
+				}
+				callback(null);
+			});
+		}
+		_processBuffer(callback) {
+			let match, value, index = 0;
+			main: for (;;) switch (this._expect) {
+				case "value1":
+				case "value":
+					patterns.value1.lastIndex = index;
+					match = patterns.value1.exec(this._buffer);
+					if (!match) {
+						if (this._done || index + MAX_PATTERN_SIZE < this._buffer.length) {
+							if (index < this._buffer.length) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected a value"));
+							return callback(/* @__PURE__ */ new Error("Parser has expected a value"));
+						}
+						break main;
+					}
+					value = match[0];
+					switch (value) {
+						case "\"":
+							this._streamStrings && this.push({ name: "startString" });
+							this._expect = "string";
+							break;
+						case "{":
+							this.push({ name: "startObject" });
+							this._stack.push(this._parent);
+							this._parent = "object";
+							this._expect = "key1";
+							break;
+						case "[":
+							this.push({ name: "startArray" });
+							this._stack.push(this._parent);
+							this._parent = "array";
+							this._expect = "value1";
+							break;
+						case "]":
+							if (this._expect !== "value1") return callback(/* @__PURE__ */ new Error("Parser cannot parse input: unexpected token ']'"));
+							if (this._open_number) {
+								this._streamNumbers && this.push({ name: "endNumber" });
+								this._open_number = false;
+								if (this._packNumbers) {
+									this.push({
+										name: "numberValue",
+										value: this._accumulator
+									});
+									this._accumulator = "";
+								}
+							}
+							this.push({ name: "endArray" });
+							this._parent = this._stack.pop();
+							this._expect = expected[this._parent];
+							break;
+						case "-":
+							this._open_number = true;
+							if (this._streamNumbers) {
+								this.push({ name: "startNumber" });
+								this.push({
+									name: "numberChunk",
+									value: "-"
+								});
+							}
+							this._packNumbers && (this._accumulator = "-");
+							this._expect = "numberStart";
+							break;
+						case "0":
+							this._open_number = true;
+							if (this._streamNumbers) {
+								this.push({ name: "startNumber" });
+								this.push({
+									name: "numberChunk",
+									value: "0"
+								});
+							}
+							this._packNumbers && (this._accumulator = "0");
+							this._expect = "numberFraction";
+							break;
+						case "1":
+						case "2":
+						case "3":
+						case "4":
+						case "5":
+						case "6":
+						case "7":
+						case "8":
+						case "9":
+							this._open_number = true;
+							if (this._streamNumbers) {
+								this.push({ name: "startNumber" });
+								this.push({
+									name: "numberChunk",
+									value
+								});
+							}
+							this._packNumbers && (this._accumulator = value);
+							this._expect = "numberDigit";
+							break;
+						case "true":
+						case "false":
+						case "null":
+							if (this._buffer.length - index === value.length && !this._done) break main;
+							this.push({
+								name: value + "Value",
+								value: values[value]
+							});
+							this._expect = expected[this._parent];
+							break;
+					}
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "keyVal":
+				case "string":
+					patterns.string.lastIndex = index;
+					match = patterns.string.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length && (this._done || this._buffer.length - index >= 6)) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: escaped characters"));
+						if (this._done) return callback(/* @__PURE__ */ new Error("Parser has expected a string value"));
+						break main;
+					}
+					value = match[0];
+					if (value === "\"") if (this._expect === "keyVal") {
+						this._streamKeys && this.push({ name: "endKey" });
+						if (this._packKeys) {
+							this.push({
+								name: "keyValue",
+								value: this._accumulator
+							});
+							this._accumulator = "";
+						}
+						this._expect = "colon";
+					} else {
+						this._streamStrings && this.push({ name: "endString" });
+						if (this._packStrings) {
+							this.push({
+								name: "stringValue",
+								value: this._accumulator
+							});
+							this._accumulator = "";
+						}
+						this._expect = expected[this._parent];
+					}
+					else if (value.length > 1 && value.charAt(0) === "\\") {
+						const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);
+						if (this._expect === "keyVal" ? this._streamKeys : this._streamStrings) this.push({
+							name: "stringChunk",
+							value: t
+						});
+						if (this._expect === "keyVal" ? this._packKeys : this._packStrings) this._accumulator += t;
+					} else {
+						if (this._expect === "keyVal" ? this._streamKeys : this._streamStrings) this.push({
+							name: "stringChunk",
+							value
+						});
+						if (this._expect === "keyVal" ? this._packKeys : this._packStrings) this._accumulator += value;
+					}
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "key1":
+				case "key":
+					patterns.key1.lastIndex = index;
+					match = patterns.key1.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected an object key"));
+						break main;
+					}
+					value = match[0];
+					if (value === "\"") {
+						this._streamKeys && this.push({ name: "startKey" });
+						this._expect = "keyVal";
+					} else if (value === "}") {
+						if (this._expect !== "key1") return callback(/* @__PURE__ */ new Error("Parser cannot parse input: unexpected token '}'"));
+						this.push({ name: "endObject" });
+						this._parent = this._stack.pop();
+						this._expect = expected[this._parent];
+					}
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "colon":
+					patterns.colon.lastIndex = index;
+					match = patterns.colon.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected ':'"));
+						break main;
+					}
+					value = match[0];
+					value === ":" && (this._expect = "value");
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "arrayStop":
+				case "objectStop":
+					patterns.comma.lastIndex = index;
+					match = patterns.comma.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected ','"));
+						break main;
+					}
+					if (this._open_number) {
+						this._streamNumbers && this.push({ name: "endNumber" });
+						this._open_number = false;
+						if (this._packNumbers) {
+							this.push({
+								name: "numberValue",
+								value: this._accumulator
+							});
+							this._accumulator = "";
+						}
+					}
+					value = match[0];
+					if (value === ",") this._expect = this._expect === "arrayStop" ? "value" : "key";
+					else if (value === "}" || value === "]") {
+						if (value === "}" ? this._expect === "arrayStop" : this._expect !== "arrayStop") return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected '" + (this._expect === "arrayStop" ? "]" : "}") + "'"));
+						this.push({ name: value === "}" ? "endObject" : "endArray" });
+						this._parent = this._stack.pop();
+						this._expect = expected[this._parent];
+					}
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberStart":
+					patterns.numberStart.lastIndex = index;
+					match = patterns.numberStart.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected a starting digit"));
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = value === "0" ? "numberFraction" : "numberDigit";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberDigit":
+					patterns.numberDigit.lastIndex = index;
+					match = patterns.numberDigit.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected a digit"));
+						break main;
+					}
+					value = match[0];
+					if (value) {
+						this._streamNumbers && this.push({
+							name: "numberChunk",
+							value
+						});
+						this._packNumbers && (this._accumulator += value);
+						if (noSticky) this._buffer = this._buffer.slice(value.length);
+						else index += value.length;
+					} else {
+						if (index < this._buffer.length) {
+							this._expect = "numberFraction";
+							break;
+						}
+						if (this._done) {
+							this._expect = expected[this._parent];
+							break;
+						}
+						break main;
+					}
+					break;
+				case "numberFraction":
+					patterns.numberFraction.lastIndex = index;
+					match = patterns.numberFraction.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) {
+							this._expect = expected[this._parent];
+							break;
+						}
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = value === "." ? "numberFracStart" : "numberExpSign";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberFracStart":
+					patterns.numberFracStart.lastIndex = index;
+					match = patterns.numberFracStart.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected a fractional part of a number"));
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = "numberFracDigit";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberFracDigit":
+					patterns.numberFracDigit.lastIndex = index;
+					match = patterns.numberFracDigit.exec(this._buffer);
+					value = match[0];
+					if (value) {
+						this._streamNumbers && this.push({
+							name: "numberChunk",
+							value
+						});
+						this._packNumbers && (this._accumulator += value);
+						if (noSticky) this._buffer = this._buffer.slice(value.length);
+						else index += value.length;
+					} else {
+						if (index < this._buffer.length) {
+							this._expect = "numberExponent";
+							break;
+						}
+						if (this._done) {
+							this._expect = expected[this._parent];
+							break;
+						}
+						break main;
+					}
+					break;
+				case "numberExponent":
+					patterns.numberExponent.lastIndex = index;
+					match = patterns.numberExponent.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length) {
+							this._expect = expected[this._parent];
+							break;
+						}
+						if (this._done) {
+							this._expect = "done";
+							break;
+						}
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = "numberExpSign";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberExpSign":
+					patterns.numberExpSign.lastIndex = index;
+					match = patterns.numberExpSign.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length) {
+							this._expect = "numberExpStart";
+							break;
+						}
+						if (this._done) return callback(/* @__PURE__ */ new Error("Parser has expected an exponent value of a number"));
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = "numberExpStart";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberExpStart":
+					patterns.numberExpStart.lastIndex = index;
+					match = patterns.numberExpStart.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length || this._done) return callback(/* @__PURE__ */ new Error("Parser cannot parse input: expected an exponent part of a number"));
+						break main;
+					}
+					value = match[0];
+					this._streamNumbers && this.push({
+						name: "numberChunk",
+						value
+					});
+					this._packNumbers && (this._accumulator += value);
+					this._expect = "numberExpDigit";
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+				case "numberExpDigit":
+					patterns.numberExpDigit.lastIndex = index;
+					match = patterns.numberExpDigit.exec(this._buffer);
+					value = match[0];
+					if (value) {
+						this._streamNumbers && this.push({
+							name: "numberChunk",
+							value
+						});
+						this._packNumbers && (this._accumulator += value);
+						if (noSticky) this._buffer = this._buffer.slice(value.length);
+						else index += value.length;
+					} else {
+						if (index < this._buffer.length || this._done) {
+							this._expect = expected[this._parent];
+							break;
+						}
+						break main;
+					}
+					break;
+				case "done":
+					patterns.ws.lastIndex = index;
+					match = patterns.ws.exec(this._buffer);
+					if (!match) {
+						if (index < this._buffer.length) {
+							if (this._jsonStreaming) {
+								this._expect = "value";
+								break;
+							}
+							return callback(/* @__PURE__ */ new Error("Parser cannot parse input: unexpected characters"));
+						}
+						break main;
+					}
+					value = match[0];
+					if (this._open_number) {
+						this._streamNumbers && this.push({ name: "endNumber" });
+						this._open_number = false;
+						if (this._packNumbers) {
+							this.push({
+								name: "numberValue",
+								value: this._accumulator
+							});
+							this._accumulator = "";
+						}
+					}
+					if (noSticky) this._buffer = this._buffer.slice(value.length);
+					else index += value.length;
+					break;
+			}
+			!noSticky && (this._buffer = this._buffer.slice(index));
+			callback(null);
+		}
+	};
+	Parser$1.parser = Parser$1.make;
+	Parser$1.make.Constructor = Parser$1;
+	module.exports = Parser$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/emit.js
+var require_emit = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/utils/emit.js": ((exports, module) => {
+	const emit$1 = (stream) => stream.on("data", (item) => stream.emit(item.name, item.value));
+	module.exports = emit$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/index.js
+var require_stream_json = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/index.js": ((exports, module) => {
+	const Parser = require_Parser();
+	const emit = require_emit();
+	const make = (options) => emit(new Parser(options));
+	make.Parser = Parser;
+	make.parser = Parser.parser;
+	module.exports = make;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Assembler.js
+var require_Assembler = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/stream-json@1.9.1/node_modules/stream-json/Assembler.js": ((exports, module) => {
+	const EventEmitter = __require("events");
+	const startObject = (Ctr) => function() {
+		if (this.done) this.done = false;
+		else this.stack.push(this.current, this.key);
+		this.current = new Ctr();
+		this.key = null;
+	};
+	var Assembler$1 = class Assembler$1 extends EventEmitter {
+		static connectTo(stream, options) {
+			return new Assembler$1(options).connectTo(stream);
+		}
+		constructor(options) {
+			super();
+			this.stack = [];
+			this.current = this.key = null;
+			this.done = true;
+			if (options) {
+				this.reviver = typeof options.reviver == "function" && options.reviver;
+				if (this.reviver) this.stringValue = this._saveValue = this._saveValueWithReviver;
+				if (options.numberAsString) this.numberValue = this.stringValue;
+			}
+		}
+		connectTo(stream) {
+			stream.on("data", (chunk) => {
+				if (this[chunk.name]) {
+					this[chunk.name](chunk.value);
+					if (this.done) this.emit("done", this);
+				}
+			});
+			return this;
+		}
+		get depth() {
+			return (this.stack.length >> 1) + (this.done ? 0 : 1);
+		}
+		get path() {
+			const path = [];
+			for (let i = 0; i < this.stack.length; i += 2) {
+				const key = this.stack[i + 1];
+				path.push(key === null ? this.stack[i].length : key);
+			}
+			return path;
+		}
+		dropToLevel(level) {
+			if (level < this.depth) if (level) {
+				const index = level - 1 << 1;
+				this.current = this.stack[index];
+				this.key = this.stack[index + 1];
+				this.stack.splice(index);
+			} else {
+				this.stack = [];
+				this.current = this.key = null;
+				this.done = true;
+			}
+			return this;
+		}
+		consume(chunk) {
+			this[chunk.name] && this[chunk.name](chunk.value);
+			return this;
+		}
+		keyValue(value) {
+			this.key = value;
+		}
+		numberValue(value) {
+			this._saveValue(parseFloat(value));
+		}
+		nullValue() {
+			this._saveValue(null);
+		}
+		trueValue() {
+			this._saveValue(true);
+		}
+		falseValue() {
+			this._saveValue(false);
+		}
+		endObject() {
+			if (this.stack.length) {
+				const value = this.current;
+				this.key = this.stack.pop();
+				this.current = this.stack.pop();
+				this._saveValue(value);
+			} else this.done = true;
+		}
+		_saveValue(value) {
+			if (this.done) this.current = value;
+			else if (this.current instanceof Array) this.current.push(value);
+			else {
+				this.current[this.key] = value;
+				this.key = null;
+			}
+		}
+		_saveValueWithReviver(value) {
+			if (this.done) this.current = this.reviver("", value);
+			else if (this.current instanceof Array) {
+				value = this.reviver("" + this.current.length, value);
+				this.current.push(value);
+				if (value === void 0) delete this.current[this.current.length - 1];
+			} else {
+				value = this.reviver(this.key, value);
+				if (value !== void 0) this.current[this.key] = value;
+				this.key = null;
+			}
+		}
+	};
+	Assembler$1.prototype.stringValue = Assembler$1.prototype._saveValue;
+	Assembler$1.prototype.startObject = startObject(Object);
+	Assembler$1.prototype.startArray = startObject(Array);
+	Assembler$1.prototype.endArray = Assembler$1.prototype.endObject;
+	module.exports = Assembler$1;
+}) });
+
+//#endregion
+//#region src/node/utils/json-parse-stream.ts
+var import_stream_json = /* @__PURE__ */ __toESM(require_stream_json(), 1);
+var import_Assembler = /* @__PURE__ */ __toESM(require_Assembler(), 1);
+async function parseJsonStreamWithConcatArrays(stream, processor) {
+	const values$1 = [];
+	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$1.push(result);
+			} catch (e) {
+				const preview = line.length > 256 ? `${line.slice(0, 256)}...` : line;
+				console.warn(`[vite-devtools] JSON parse stream skip bad line ${lineNumber}: ${e.message}\n${preview}`);
+			}
+		}
+	});
+	return values$1;
+}
+
+//#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 DURATION_THRESHOLD = 10;
+const MODULE_BUILD_START_HOOKS = [
+	"HookResolveIdCallStart",
+	"HookLoadCallStart",
+	"HookTransformCallStart"
+];
+const MODULE_BUILD_END_HOOKS = [
+	"HookResolveIdCallEnd",
+	"HookLoadCallEnd",
+	"HookTransformCallEnd"
+];
+var RolldownEventsManager = class {
+	events = [];
+	chunks = /* @__PURE__ */ new Map();
+	assets = /* @__PURE__ */ new Map();
+	modules = /* @__PURE__ */ new Map();
+	source_refs = /* @__PURE__ */ new Map();
+	module_build_hook_events = /* @__PURE__ */ new Map();
+	module_build_metrics = /* @__PURE__ */ new Map();
+	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);
+			}
+		}
+	}
+	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)) {
+			const start = this.module_build_hook_events.get(event.call_id);
+			const module_id = event.action === "HookResolveIdCallEnd" ? event.resolved_id : event.module_id;
+			if (start) {
+				const pluginId = event.plugin_id;
+				const info = {
+					id: event.event_id,
+					timestamp_start: +start.timestamp,
+					timestamp_end: +event.timestamp,
+					duration: +event.timestamp - +start.timestamp,
+					plugin_id: pluginId,
+					plugin_name: event.plugin_name
+				};
+				const module_build_metrics = this.module_build_metrics.get(module_id) ?? {
+					resolve_ids: [],
+					loads: [],
+					transforms: []
+				};
+				const plugin_build_metrics = this.plugin_build_metrics.get(pluginId) ?? {
+					plugin_id: pluginId,
+					plugin_name: event.plugin_name,
+					calls: []
+				};
+				if (event.action === "HookResolveIdCallEnd") {
+					module_build_metrics.resolve_ids.push({
+						...info,
+						type: "resolve",
+						importer: start.importer,
+						module_request: start.module_request,
+						import_kind: start.import_kind,
+						resolved_id: event.resolved_id
+					});
+					plugin_build_metrics.calls.push({
+						...info,
+						type: "resolve",
+						module: start.module_request
+					});
+				} else if (event.action === "HookLoadCallEnd") {
+					if (!event.content && info.duration < DURATION_THRESHOLD) return;
+					module_build_metrics.loads.push({
+						...info,
+						type: "load",
+						content: event.content
+					});
+					plugin_build_metrics.calls.push({
+						...info,
+						type: "load",
+						module: event.module_id,
+						unchanged: !event.content
+					});
+				} else if (event.action === "HookTransformCallEnd") {
+					const _start = start;
+					const _end = event;
+					if (_start.content === _end.content && info.duration < DURATION_THRESHOLD) return;
+					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)
+					});
+					plugin_build_metrics.calls.push({
+						...info,
+						type: "transform",
+						module: event.module_id,
+						unchanged: _start.content === _end.content
+					});
+				}
+				this.plugin_build_metrics.set(pluginId, plugin_build_metrics);
+				this.module_build_metrics.set(module_id, module_build_metrics);
+			}
+		}
+	}
+	handleEvent(raw) {
+		const event = {
+			...raw,
+			event_id: `${"timestamp" in raw ? raw.timestamp : "x"}#${this.events.length}`
+		};
+		this.events.push(event);
+		if (event.action === "BuildStart") this.build_start_time = +event.timestamp;
+		if (event.action === "BuildEnd") this.build_end_time = +event.timestamp;
+		if (event.action === "StringRef") {
+			this.source_refs.set(event.id, event.content);
+			return;
+		}
+		if (event.action === "ChunkGraphReady") {
+			for (const chunk of event.chunks) this.chunks.set(chunk.chunk_id, chunk);
+			return;
+		}
+		this.interpretSourceRefs(event, "content");
+		this.recordBuildMetrics(event);
+		if ("module_id" in event) {
+			if (this.modules.has(event.module_id)) return;
+			this.modules.set(event.module_id, {
+				id: event.module_id,
+				is_external: false,
+				imports: [],
+				importers: [],
+				build_metrics: {
+					resolve_ids: [],
+					loads: [],
+					transforms: []
+				}
+			});
+		}
+		if (event.action === "ModuleGraphReady") {
+			this.module_build_hook_events.clear();
+			for (const module$1 of event.modules) {
+				this.modules.set(module$1.id, {
+					...module$1,
+					build_metrics: this.module_build_metrics.get(module$1.id)
+				});
+				module$1.importers = Array.from(new Set(module$1.importers || [])).sort((a, b) => a.localeCompare(b));
+				module$1.imports = Array.from(new Set(module$1.imports || [])).sort((a, b) => a.module_id.localeCompare(b.module_id));
+			}
+		}
+		if (event.action === "AssetsReady") for (const asset of event.assets) this.assets.set(asset.filename, asset);
+		return event;
+	}
+	dispose() {
+		this.events = [];
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+
+//#endregion
+//#region src/node/rolldown/events-reader.ts
+const readers = /* @__PURE__ */ new Map();
+var RolldownEventsReader = class RolldownEventsReader {
+	lastBytes = 0;
+	lastTimestamp = 0;
+	manager = new RolldownEventsManager();
+	meta;
+	constructor(filepath) {
+		this.filepath = filepath;
+	}
+	static get(filepath) {
+		if (readers.has(filepath)) return readers.get(filepath);
+		const reader = new RolldownEventsReader(filepath);
+		readers.set(filepath, reader);
+		return reader;
+	}
+	async read() {
+		const { mtime, size } = await fs.promises.stat(this.filepath);
+		if (mtime.getTime() <= this.lastTimestamp) return;
+		const stream = fs.createReadStream(this.filepath, { start: this.lastBytes });
+		await parseJsonStreamWithConcatArrays(stream, (event) => {
+			this.manager.handleEvent(event);
+			return event;
+		});
+		this.lastTimestamp = mtime.getTime();
+		this.lastBytes = size;
+	}
+	dispose() {
+		readers.delete(this.filepath);
+		this.manager.dispose();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+
+//#endregion
+//#region src/node/rolldown/logs-manager.ts
+var RolldownLogsManager = class {
+	constructor(dir) {
+		this.dir = dir;
+	}
+	async list() {
+		const sessions = await fs$1.readdir(this.dir, { withFileTypes: true });
+		return await Promise.all(sessions.filter((d) => d.isDirectory()).map(async (d) => {
+			const reader = RolldownEventsReader.get(join(this.dir, d.name, "meta.json"));
+			await reader.read();
+			const meta = reader.manager.events[reader.manager.events.length - 1];
+			return {
+				id: d.name,
+				timestamp: meta.timestamp,
+				meta
+			};
+		}));
+	}
+	async loadSession(session) {
+		const reader = RolldownEventsReader.get(join(this.dir, session, "logs.json"));
+		await reader.read();
+		if (!reader.meta) {
+			const metaReader = RolldownEventsReader.get(join(this.dir, session, "meta.json"));
+			await metaReader.read();
+			reader.meta = metaReader.manager.events.at(-1);
+		}
+		return reader;
+	}
+};
+
+//#endregion
+//#region src/node/rpc/utils.ts
+const weakMap = /* @__PURE__ */ new WeakMap();
+function getLogsManager(context) {
+	let manager = weakMap.get(context);
+	if (!manager) {
+		const dir = [join(context.cwd, ".rolldown"), join(process.cwd(), ".rolldown")].find((dir$1) => existsSync(dir$1));
+		if (!dir) throw new Error("Rolldown logs directory not found");
+		manager = new RolldownLogsManager(dir);
+	}
+	return manager;
+}
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-asset-details.ts
+const rolldownGetAssetDetails = defineRpcFunction({
+	name: "vite:rolldown:get-asset-details",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, id }) => {
+			const reader = await manager.loadSession(session);
+			const assets = reader.manager.assets;
+			const chunks = reader.manager.chunks;
+			const asset = assets.get(id);
+			const assetList = Array.from(assets.values());
+			const chunkList = Array.from(chunks.values());
+			if (asset.chunk_id === null) return { asset };
+			const assetChunkId = asset.chunk_id;
+			const chunk = chunks.get(assetChunkId);
+			const importers = chunkList.filter((mod) => mod.imports.some((i) => i.chunk_id === assetChunkId)).map((c) => assetList.find((a) => a.chunk_id === c.chunk_id));
+			const imports = chunk.imports.map((c) => assetList.find((a) => a.chunk_id === c.chunk_id));
+			return {
+				asset,
+				chunk,
+				importers,
+				imports
+			};
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-assets-list.ts
+const rolldownGetAssetsList = defineRpcFunction({
+	name: "vite:rolldown:get-assets-list",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session }) => {
+			const reader = await manager.loadSession(session);
+			return Array.from(reader.manager.assets.values());
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-chunk-info.ts
+const rolldownGetChunkInfo = defineRpcFunction({
+	name: "vite:rolldown:get-chunk-info",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, id }) => {
+			return (await manager.loadSession(session)).manager.chunks.get(id);
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-chunks-graph.ts
+const rolldownGetChunksGraph = defineRpcFunction({
+	name: "vite:rolldown:get-chunks-graph",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session }) => {
+			const reader = await manager.loadSession(session);
+			return Array.from(reader.manager.chunks.values());
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-module-info.ts
+const rolldownGetModuleInfo = defineRpcFunction({
+	name: "vite:rolldown:get-module-info",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, module: module$1 }) => {
+			const reader = await manager.loadSession(session);
+			if (!reader.manager.events.length) return null;
+			const moduleInfo = reader.manager.modules.get(module$1);
+			const info = {
+				id: module$1,
+				imports: [],
+				importers: [],
+				chunks: [],
+				assets: [],
+				build_metrics: {
+					resolve_ids: [],
+					loads: [],
+					transforms: []
+				},
+				...moduleInfo || {},
+				loads: moduleInfo?.build_metrics?.loads ?? [],
+				resolve_ids: moduleInfo?.build_metrics?.resolve_ids ?? []
+			};
+			info.chunks = Array.from(reader.manager.chunks.values()).filter((chunk) => chunk.modules.includes(module$1)).map((chunk) => ({
+				type: "chunk",
+				...chunk
+			}));
+			info.assets = Array.from(reader.manager.assets.values()).filter((asset) => info.chunks.some((chunk) => chunk.chunk_id === asset.chunk_id)).map((asset) => ({
+				type: "asset",
+				...asset
+			}));
+			info.loads.sort((a, b) => a.plugin_id - b.plugin_id);
+			info.resolve_ids.sort((a, b) => a.plugin_id - b.plugin_id);
+			return info;
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-module-raw-events.ts
+const rolldownGetModuleRawEvents = defineRpcFunction({
+	name: "vite:rolldown:get-module-raw-events",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, module: module$1 }) => {
+			return { events: (await manager.loadSession(session)).manager.events.filter((event) => "module_id" in event && event.module_id !== module$1) };
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-module-transforms.ts
+const rolldownGetModuleTransforms = defineRpcFunction({
+	name: "vite:rolldown:get-module-transforms",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, module: module$1 }) => {
+			const reader = await manager.loadSession(session);
+			const events = reader.manager.events;
+			const transforms = reader.manager.modules.get(module$1)?.build_metrics?.transforms ?? [];
+			if (!events.length) return transforms.map((transform) => ({
+				...transform,
+				diff_added: 0,
+				diff_removed: 0
+			}));
+			return transforms.map((transform) => {
+				let diff_added = 0;
+				let diff_removed = 0;
+				if (transform.content_from !== transform.content_to && transform.content_from != null && transform.content_to != null) {
+					const delta = diffLines(transform.content_from, transform.content_to);
+					diff_added = delta.filter((d) => d.added).map((d) => d.value).join("").split(/\n/g).length;
+					diff_removed = delta.filter((d) => d.removed).map((d) => d.value).join("").split(/\n/g).length;
+				}
+				return {
+					...transform,
+					diff_added,
+					diff_removed
+				};
+			}).sort((a, b) => a.plugin_id - b.plugin_id);
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/utils/filepath.ts
+function isNodeModulePath(path) {
+	return !!path.match(/[/\\]node_modules[/\\]/) || isPackageName(path);
+}
+function isPackageName(name) {
+	return name[0] === "#" || !!name.match(/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/);
+}
+function getModuleNameFromPath(path) {
+	if (isPackageName(path)) return path;
+	const match = path.replace(/\\/g, "/").match(/.*\/node_modules\/(.*)$/)?.[1];
+	if (!match) return void 0;
+	if (match.startsWith("@")) return match.split("/").slice(0, 2).join("/");
+	return match.split("/")[0];
+}
+function getPackageDirPath(path) {
+	const nodeModulesPrefix = path.replace(/%2F/g, "/").replace(/\\/g, "/").match(/^(.+\/node_modules\/)/)?.[1];
+	const packageName = getModuleNameFromPath(path);
+	return nodeModulesPrefix + packageName;
+}
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-packages.ts
+const rolldownGetPackages = defineRpcFunction({
+	name: "vite:rolldown:get-packages",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session }) => {
+			const reader = await manager.loadSession(session);
+			const chunks = Array.from(reader.manager.chunks.values());
+			const modulesMap = reader.manager.modules;
+			const duplicatePackagesMap = /* @__PURE__ */ new Map();
+			const packagesManifest = /* @__PURE__ */ new Map();
+			const packages = chunks.map((chunk) => chunk.modules.map((module$1) => module$1)).flat().filter(isNodeModulePath).map((p) => {
+				const moduleBuildMetrics = modulesMap.get(p)?.build_metrics;
+				return {
+					path: p,
+					dir: getPackageDirPath(p),
+					transformedCodeSize: moduleBuildMetrics?.transforms[moduleBuildMetrics?.transforms.length - 1]?.transformed_code_size ?? 0
+				};
+			});
+			await Promise.all(packages.map(async (p) => {
+				const manifest = await readProjectManifestOnly(p.dir);
+				const packageKey = `${manifest.name}@${manifest.version}`;
+				const packageInfo = packagesManifest.get(packageKey);
+				const module$1 = modulesMap.get(p.path);
+				if (packageInfo) packagesManifest.set(packageKey, {
+					...packageInfo,
+					files: [...packageInfo.files, {
+						path: p.path,
+						transformedCodeSize: p.transformedCodeSize,
+						importers: module$1?.importers?.map((i) => ({
+							path: i,
+							version: ""
+						})) ?? []
+					}],
+					transformedCodeSize: packageInfo.transformedCodeSize + p.transformedCodeSize
+				});
+				else packagesManifest.set(packageKey, {
+					name: manifest.name,
+					version: manifest.version,
+					dir: p.dir,
+					files: [{
+						path: p.path,
+						transformedCodeSize: p.transformedCodeSize,
+						importers: module$1?.importers?.map((i) => ({
+							path: i,
+							version: ""
+						})) ?? []
+					}],
+					transformedCodeSize: p.transformedCodeSize
+				});
+			}));
+			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) => {
+						const manifest = isNodeModulePath(i.path) ? await readProjectManifestOnly(getPackageDirPath(i.path)) : null;
+						return {
+							...i,
+							version: manifest?.version ?? ""
+						};
+					}));
+					return {
+						...f,
+						importers
+					};
+				}));
+				return {
+					...p,
+					duplicated,
+					files
+				};
+			}))).filter((i) => !!i.transformedCodeSize);
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-plugin-details.ts
+const rolldownGetPluginDetails = defineRpcFunction({
+	name: "vite:rolldown:get-plugin-details",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session, id }) => {
+			const reader = await manager.loadSession(session);
+			const pluginBuildMetrics = reader.manager.plugin_build_metrics.get(+id);
+			if (!pluginBuildMetrics) return {
+				plugin_name: reader.meta.plugins.find((p) => p.plugin_id === +id)?.name,
+				plugin_id: +id,
+				calls: [],
+				loadMetrics: [],
+				resolveIdMetrics: [],
+				transformMetrics: []
+			};
+			const resolveIdMetrics = pluginBuildMetrics.calls.filter((c) => c.type === "resolve");
+			const loadMetrics = pluginBuildMetrics.calls.filter((c) => c.type === "load");
+			const transformMetrics = pluginBuildMetrics.calls.filter((c) => c.type === "transform");
+			return {
+				...pluginBuildMetrics,
+				resolveIdMetrics,
+				loadMetrics,
+				transformMetrics
+			};
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-raw-events.ts
+const rolldownGetRawEvents = defineRpcFunction({
+	name: "vite:rolldown:get-raw-events",
+	type: "query",
+	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",
+	type: "query",
+	setup: async (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ sessions }) => {
+			const reader = await Promise.all(sessions.map((s) => manager.loadSession(s)));
+			return sessions.map((s, index) => {
+				const _reader = reader[index];
+				const assets = Array.from(_reader.manager.assets.values());
+				const chunks = Array.from(_reader.manager.chunks.values());
+				function getInitialChunkIds(chunkIds, visited = /* @__PURE__ */ new Set()) {
+					const initialChunkIds$1 = [];
+					for (const chunkId of chunkIds) {
+						if (visited.has(chunkId)) continue;
+						visited.add(chunkId);
+						const chunk = chunks.find((c) => c.chunk_id === chunkId);
+						if (chunk?.imports) {
+							const importChunkIds = chunk.imports.map((imp) => imp.chunk_id);
+							initialChunkIds$1.push(...importChunkIds);
+							const nestedImports = getInitialChunkIds(importChunkIds, visited);
+							initialChunkIds$1.push(...nestedImports);
+						}
+					}
+					return initialChunkIds$1;
+				}
+				const entryChunkIds = chunks.filter((chunk) => !!chunk.is_user_defined_entry).map((chunk) => chunk.chunk_id);
+				const initialChunkIds = [...new Set([...entryChunkIds, ...getInitialChunkIds(entryChunkIds)])];
+				return {
+					id: s,
+					meta: _reader.meta,
+					build_duration: _reader.manager.build_end_time - _reader.manager.build_start_time,
+					modules: Array.from(_reader.manager.modules.values()).length,
+					chunks: chunks.length,
+					assets: assets.length,
+					bundle_size: assets.reduce((acc, asset) => acc + asset.size, 0),
+					initial_js: initialChunkIds.reduce((acc, chunkId) => acc + (assets.find((asset) => asset.chunk_id === chunkId)?.size || 0), 0)
+				};
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-get-session-summary.ts
+const rolldownGetSessionSummary = defineRpcFunction({
+	name: "vite:rolldown:get-session-summary",
+	type: "query",
+	setup: async (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async ({ session }) => {
+			const reader = await manager.loadSession(session);
+			return {
+				id: session,
+				meta: reader.meta,
+				build_duration: reader.manager.build_end_time - reader.manager.build_start_time,
+				modules: Array.from(reader.manager.modules.values()).sort((a, b) => a.id.localeCompare(b.id))
+			};
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/functions/rolldown-list-sessions.ts
+const rolldownListSessions = defineRpcFunction({
+	name: "vite:rolldown:list-sessions",
+	type: "query",
+	setup: (context) => {
+		const manager = getLogsManager(context);
+		return { handler: async () => {
+			return (await manager.list()).sort((a, b) => b.timestamp - a.timestamp);
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/index.ts
+const rpcFunctions = [
+	getPayload,
+	rolldownListSessions,
+	rolldownGetRawEvents,
+	rolldownGetSessionSummary,
+	rolldownGetModuleInfo,
+	rolldownGetModuleRawEvents,
+	rolldownGetModuleTransforms,
+	rolldownGetChunksGraph,
+	rolldownGetAssetsList,
+	rolldownGetAssetDetails,
+	rolldownGetPluginDetails,
+	rolldownGetSessionCompareSummary,
+	rolldownGetChunkInfo,
+	rolldownGetPackages
+];
+
+//#endregion
+//#region src/node/plugin.ts
+function DevToolsViteUI() {
+	return {
+		name: "vite:devtools",
+		devtools: { setup(ctx) {
+			console.log("Vite DevTools Vite plugin setup");
+			for (const fn of rpcFunctions) ctx.rpc.register(fn);
+			ctx.hostStatic("/__vite_devtools_vite__/", clientPublicDir);
+			ctx.docks.register({
+				id: "vite",
+				title: "Vite",
+				icon: "https://vite.dev/logo.svg",
+				type: "iframe",
+				url: "/__vite_devtools_vite__/"
+			});
+		} }
+	};
+}
+
+//#endregion
+export { DevToolsViteUI };