vite-node 3.2.0-beta.2 → 3.2.0

package/dist/client.mjs

@@ -55,8 +55,8 @@ class ModuleCacheMap extends Map {
 		if (!super.has(modulePath)) this.setByModuleId(modulePath, {});
 		const mod = super.get(modulePath);
 		if (!mod.imports) Object.assign(mod, {
-			imports: new Set(),
-			importers: new Set()
+			imports: /* @__PURE__ */ new Set(),
+			importers: /* @__PURE__ */ new Set()
 		});
 		return mod;
 	}
@@ -82,7 +82,7 @@ class ModuleCacheMap extends Map {
 	/**
 	* Invalidate modules that dependent on the given modules, up to the main entry
 	*/
-	invalidateDepTree(ids, invalidated = new Set()) {
+	invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
 		for (const _id of ids) {
 			const id = this.normalizePath(_id);
 			if (invalidated.has(id)) continue;
@@ -96,7 +96,7 @@ class ModuleCacheMap extends Map {
 	/**
 	* Invalidate dependency modules of the given modules, down to the bottom-level dependencies
 	*/
-	invalidateSubDepTree(ids, invalidated = new Set()) {
+	invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
 		for (const _id of ids) {
 			const id = this.normalizePath(_id);
 			if (invalidated.has(id)) continue;
@@ -132,6 +132,25 @@ class ViteNodeRunner {
 	* Keys of the map are filepaths, or plain package names
 	*/
 	moduleCache;
+	/**
+	* Tracks the stack of modules being executed for the purpose of calculating import self-time.
+	*
+	* Note that while in most cases, imports are a linear stack of modules,
+	* this is occasionally not the case, for example when you have parallel top-level dynamic imports like so:
+	*
+	* ```ts
+	* await Promise.all([
+	*  import('./module1'),
+	*  import('./module2'),
+	* ]);
+	* ```
+	*
+	* In this case, the self time will be reported incorrectly for one of the modules (could go negative).
+	* As top-level awaits with dynamic imports like this are uncommon, we don't handle this case specifically.
+	*/
+	executionStack = [];
+	// `performance` can be mocked, so make sure we're using the original function
+	performanceNow = performance.now.bind(performance);
 	constructor(options) {
 		this.options = options;
 		this.root = options.root ?? process.cwd();
@@ -153,12 +172,14 @@ class ViteNodeRunner {
 		const { imports, importers } = mod;
 		if (importee) importers.add(importee);
 		const getStack = () => `stack:\n${[...callstack, fsPath].reverse().map((p) => `  - ${p}`).join("\n")}`;
+		// check circular dependency
 		if (callstack.includes(fsPath) || Array.from(imports.values()).some((i) => importers.has(i))) {
 			if (mod.exports) return mod.exports;
 		}
 		let debugTimer;
 		if (this.debug) debugTimer = setTimeout(() => console.warn(`[vite-node] module ${fsPath} takes over 2s to load.\n${getStack()}`), 2e3);
 		try {
+			// cached module
 			if (mod.promise) return await mod.promise;
 			const promise = this.directRequest(id, fsPath, callstack);
 			Object.assign(mod, {
@@ -181,6 +202,7 @@ class ViteNodeRunner {
 		const { path, exists } = toFilePath(dep, this.root);
 		if (!this.options.resolveId || exists) return [dep, path];
 		const resolved = await this.options.resolveId(dep, importer);
+		// supported since Vite 5-beta.19
 		if (resolved === null || resolved === void 0 || (_resolved$meta = resolved.meta) === null || _resolved$meta === void 0 || (_resolved$meta = _resolved$meta["vite:alias"]) === null || _resolved$meta === void 0 ? void 0 : _resolved$meta.noResolved) {
 			const error = new Error(`Cannot find module '${id}'${importer ? ` imported from '${importer}'` : ""}.
 
@@ -204,6 +226,7 @@ class ViteNodeRunner {
 	}
 	async resolveUrl(id, importee) {
 		const resolveKey = `resolve:${id}`;
+		// put info about new import as soon as possible, so we can start tracking it
 		this.moduleCache.setByModuleId(resolveKey, { resolving: true });
 		try {
 			return await this._resolveUrl(id, importee);
@@ -219,6 +242,7 @@ class ViteNodeRunner {
 		try {
 			return await this.options.fetchModule(id);
 		} catch (cause) {
+			// rethrow vite error if it cannot load the module because it's not resolved
 			if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof (cause === null || cause === void 0 ? void 0 : cause.message) === "string" && cause.message.includes("Failed to load url")) {
 				const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
 				error.code = "ERR_MODULE_NOT_FOUND";
@@ -251,6 +275,7 @@ class ViteNodeRunner {
 		if (transformed == null) throw new Error(`[vite-node] Failed to load "${id}" imported from ${callstack[callstack.length - 2]}`);
 		const { Object, Reflect, Symbol } = this.getContextPrimitives();
 		const modulePath = cleanUrl(moduleId);
+		// disambiguate the `<UNIT>:/` on windows: see nodejs/node#31710
 		const href = pathToFileURL(modulePath).href;
 		const __filename = fileURLToPath(href);
 		const __dirname = dirname(__filename);
@@ -268,6 +293,8 @@ class ViteNodeRunner {
 		});
 		const SYMBOL_NOT_DEFINED = Symbol("not defined");
 		let moduleExports = SYMBOL_NOT_DEFINED;
+		// this proxy is triggered only on exports.{name} and module.exports access
+		// inside the module itself. imported module is always "exports"
 		const cjsExports = new Proxy(exports, {
 			get: (target, p, receiver) => {
 				if (Reflect.has(target, p)) return Reflect.get(target, p, receiver);
@@ -275,12 +302,16 @@ class ViteNodeRunner {
 			},
 			getPrototypeOf: () => Object.prototype,
 			set: (_, p, value) => {
+				// treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
+				// so "exports.default" becomes the actual module
 				if (p === "default" && this.shouldInterop(modulePath, { default: value }) && cjsExports !== value) {
 					exportAll(cjsExports, value);
 					exports.default = value;
 					return true;
 				}
 				if (!Reflect.has(exports, "default")) exports.default = {};
+				// returns undefined, when accessing named exports, if default is not an object
+				// but is still present inside hasOwnKeys, this is Node behaviour for CJS
 				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
 					defineExport(exports, p, () => void 0);
 					return true;
@@ -304,6 +335,7 @@ class ViteNodeRunner {
 				return cjsExports;
 			}
 		};
+		// Vite hot context
 		let hotContext;
 		if (this.options.createHotContext) Object.defineProperty(meta, "hot", {
 			enumerable: true,
@@ -316,11 +348,20 @@ class ViteNodeRunner {
 				hotContext = value;
 			}
 		});
+		// Be careful when changing this
+		// changing context will change amount of code added on line :114 (vm.runInThisContext)
+		// this messes up sourcemaps for coverage
+		// adjust `WRAPPER_LENGTH` variable in packages/coverage-v8/src/provider.ts if you do change this
 		const context = this.prepareContext({
 			__vite_ssr_import__: request,
 			__vite_ssr_dynamic_import__: request,
 			__vite_ssr_exports__: exports,
 			__vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+			__vite_ssr_exportName__: (name, getter) => Object.defineProperty(exports, name, {
+				enumerable: true,
+				configurable: true,
+				get: getter
+			}),
 			__vite_ssr_import_meta__: meta,
 			require: createRequire(href),
 			exports: cjsExports,
@@ -329,6 +370,7 @@ class ViteNodeRunner {
 			__dirname
 		});
 		debugExecute(__filename);
+		// remove shebang
 		if (transformed[0] === "#") transformed = transformed.replace(/^#!.*/, (s) => " ".repeat(s.length));
 		await this.runModule(context, transformed);
 		return exports;
@@ -341,7 +383,7 @@ class ViteNodeRunner {
 		};
 	}
 	async runModule(context, transformed) {
-		var _this$options$moduleE;
+		// add 'use strict' since ESM enables it by default
 		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
 		const code = `${codeDefinition}${transformed}\n}}`;
 		const options = {
@@ -349,9 +391,38 @@ class ViteNodeRunner {
 			lineOffset: 0,
 			columnOffset: -codeDefinition.length
 		};
-		(_this$options$moduleE = this.options.moduleExecutionInfo) === null || _this$options$moduleE === void 0 || _this$options$moduleE.set(options.filename, { startOffset: codeDefinition.length });
-		const fn = vm.runInThisContext(code, options);
-		await fn(...Object.values(context));
+		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			const fn = vm.runInThisContext(code, options);
+			await fn(...Object.values(context));
+		} finally {
+			var _this$options$moduleE;
+			(_this$options$moduleE = this.options.moduleExecutionInfo) === null || _this$options$moduleE === void 0 || _this$options$moduleE.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	/**
+	* Starts calculating the module execution info such as the total duration and self time spent on executing the module.
+	* Returns a function to call once the module has finished executing.
+	*/
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = this.performanceNow();
+		this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		});
+		return () => {
+			const duration = this.performanceNow() - startTime;
+			const currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
 	}
 	prepareContext(context) {
 		return context;
@@ -362,6 +433,8 @@ class ViteNodeRunner {
 	*/
 	shouldInterop(path, mod) {
 		if (this.options.interopDefault === false) return false;
+		// never interop ESM modules
+		// TODO: should also skip for `.js` with `type="module"`
 		return !path.endsWith(".mjs") && "default" in mod;
 	}
 	importExternalModule(path) {
@@ -413,6 +486,7 @@ function interopModule(mod) {
 		defaultExport
 	};
 }
+// keep consistency with Vite on how exports are defined
 function defineExport(exports, key, value) {
 	Object.defineProperty(exports, key, {
 		enumerable: true,
@@ -421,6 +495,8 @@ function defineExport(exports, key, value) {
 	});
 }
 function exportAll(exports, sourceModule) {
+	// #1120 when a module exports itself it causes
+	// call stack error
 	if (exports === sourceModule) return;
 	if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise) return;
 	for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {

package/dist/hmr.d.ts

@@ -1,6 +1,6 @@
 import { HMRPayload, Plugin } from 'vite';
 import { EventEmitter } from 'node:events';
-import { C as CustomEventMap, a as ViteNodeRunner, H as HMRPayload$1, b as HotContext } from './index.d-CWZbpOcv.js';
+import { C as CustomEventMap, a as ViteNodeRunner, H as HMRPayload$1, b as HotContext } from './index.d-DGmxD2U7.js';
 import './trace-mapping.d-DLVdEqOp.js';
 
 type EventType = string | symbol;
@@ -21,6 +21,8 @@ declare module "vite" {
 declare function createHmrEmitter(): HMREmitter;
 declare function viteNodeHmrPlugin(): Plugin;
 
+/* eslint-disable no-console */
+
 type ModuleNamespace = Record<string, any> & {
 	[Symbol.toStringTag]: "Module"
 };
@@ -30,6 +32,7 @@ interface HotModule {
 	callbacks: HotCallback[];
 }
 interface HotCallback {
+	// the dependencies must be fetchable paths
 	deps: string[];
 	fn: (modules: (ModuleNamespace | undefined)[]) => void;
 }

package/dist/{index.d-CWZbpOcv.d.ts → index.d-DGmxD2U7.d.ts}

@@ -34,6 +34,8 @@ interface Update {
   /** @internal */
   isWithinCircularImport?: boolean
   /** @internal */
+  firstInvalidatedBy?: string
+  /** @internal */
   invalidates?: string[]
 }
 
@@ -98,14 +100,20 @@ interface WebSocketConnectionPayload {
 interface InvalidatePayload {
   path: string
   message: string | undefined
+  firstInvalidatedBy: string
 }
 
 /**
- * provides types for built-in Vite events
+ * provides types for payloads of built-in Vite events
  */
 type InferCustomEventPayload<T extends string> =
   T extends keyof CustomEventMap ? CustomEventMap[T] : any
 
+/**
+ * provides types for names of built-in Vite events
+ */
+type CustomEventName = keyof CustomEventMap | (string & {})
+
 type ModuleNamespace = Record<string, any> & {
   [Symbol.toStringTag]: 'Module'
 }
@@ -130,15 +138,18 @@ interface ViteHotContext {
   prune(cb: (data: any) => void): void
   invalidate(message?: string): void
 
-  on<T extends string>(
+  on<T extends CustomEventName>(
     event: T,
     cb: (payload: InferCustomEventPayload<T>) => void,
   ): void
-  off<T extends string>(
+  off<T extends CustomEventName>(
     event: T,
     cb: (payload: InferCustomEventPayload<T>) => void,
   ): void
-  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
+  send<T extends CustomEventName>(
+    event: T,
+    data?: InferCustomEventPayload<T>,
+  ): void
 }
 
 declare const DEFAULT_REQUEST_STUBS: Record<string, Record<string, unknown>>;
@@ -168,9 +179,14 @@ declare class ModuleCacheMap extends Map<string, ModuleCache> {
 	*/
 	getSourceMap(id: string): EncodedSourceMap | null;
 }
-type ModuleExecutionInfo = Map<string, {
-	startOffset: number
-}>;
+type ModuleExecutionInfo = Map<string, ModuleExecutionInfoEntry>;
+interface ModuleExecutionInfoEntry {
+	startOffset: number;
+	/** The duration that was spent executing the module. */
+	duration: number;
+	/** The time that was spent executing the module itself and externalized imports. */
+	selfTime: number;
+}
 declare class ViteNodeRunner {
 	options: ViteNodeRunnerOptions;
 	root: string;
@@ -180,6 +196,25 @@ declare class ViteNodeRunner {
 	* Keys of the map are filepaths, or plain package names
 	*/
 	moduleCache: ModuleCacheMap;
+	/**
+	* Tracks the stack of modules being executed for the purpose of calculating import self-time.
+	*
+	* Note that while in most cases, imports are a linear stack of modules,
+	* this is occasionally not the case, for example when you have parallel top-level dynamic imports like so:
+	*
+	* ```ts
+	* await Promise.all([
+	*  import('./module1'),
+	*  import('./module2'),
+	* ]);
+	* ```
+	*
+	* In this case, the self time will be reported incorrectly for one of the modules (could go negative).
+	* As top-level awaits with dynamic imports like this are uncommon, we don't handle this case specifically.
+	*/
+	private executionStack;
+	// `performance` can be mocked, so make sure we're using the original function
+	private performanceNow;
 	constructor(options: ViteNodeRunnerOptions);
 	executeFile(file: string): Promise<any>;
 	executeId(rawId: string): Promise<any>;
@@ -193,6 +228,11 @@ declare class ViteNodeRunner {
 		Symbol: SymbolConstructor
 	};
 	protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
+	/**
+	* Starts calculating the module execution info such as the total duration and self time spent on executing the module.
+	* Returns a function to call once the module has finished executing.
+	*/
+	protected startCalculateModuleExecutionInfo(filename: string, startOffset: number): () => ModuleExecutionInfoEntry;
 	prepareContext(context: Record<string, any>): Record<string, any>;
 	/**
 	* Define if a module should be interop-ed
@@ -320,4 +360,4 @@ interface DebuggerOptions {
 }
 
 export { ModuleCacheMap as M, ViteNodeRunner as a, DEFAULT_REQUEST_STUBS as e };
-export type { Arrayable as A, CustomEventMap as C, DebuggerOptions as D, FetchResult as F, HMRPayload as H, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeServerOptions as V, HotContext as b, DepsHandlingOptions as c, ViteNodeResolveId as d, ModuleExecutionInfo as f, Awaitable as g, FetchFunction as h, ResolveIdFunction as i, CreateHotContextFunction as j, ModuleCache as k, ViteNodeRunnerOptions as l, ViteNodeResolveModule as m };
+export type { Arrayable as A, CustomEventMap as C, DebuggerOptions as D, FetchResult as F, HMRPayload as H, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeServerOptions as V, HotContext as b, DepsHandlingOptions as c, ViteNodeResolveId as d, ModuleExecutionInfo as f, ModuleExecutionInfoEntry as g, Awaitable as h, FetchFunction as i, ResolveIdFunction as j, CreateHotContextFunction as k, ModuleCache as l, ViteNodeRunnerOptions as m, ViteNodeResolveModule as n };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { A as Arrayable, g as Awaitable, j as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, h as FetchFunction, F as FetchResult, b as HotContext, k as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, i as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, m as ViteNodeResolveModule, l as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index.d-CWZbpOcv.js';
+export { A as Arrayable, h as Awaitable, k as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, i as FetchFunction, F as FetchResult, b as HotContext, l as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, j as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, n as ViteNodeResolveModule, m as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index.d-DGmxD2U7.js';
 export { D as DecodedSourceMap, E as EncodedSourceMap, S as SourceMapInput } from './trace-mapping.d-DLVdEqOp.js';

package/dist/server.cjs

@@ -34,6 +34,7 @@ function _interopNamespaceDefault(e) {
 
 var esModuleLexer__namespace = /*#__PURE__*/_interopNamespaceDefault(esModuleLexer);
 
+/* eslint-disable no-console */
 function hashCode(s) {
 	return s.split("").reduce((a, b) => {
 		a = (a << 5) - a + b.charCodeAt(0);
@@ -43,7 +44,7 @@ function hashCode(s) {
 class Debugger {
 	dumpDir;
 	initPromise;
-	externalizeMap = new Map();
+	externalizeMap = /* @__PURE__ */ new Map();
 	constructor(root, options) {
 		this.options = options;
 		if (options.dumpModules) this.dumpDir = pathe.resolve(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
@@ -88,7 +89,7 @@ class Debugger {
 	async writeInfo() {
 		if (!this.dumpDir) return;
 		const info = JSON.stringify({
-			time: new Date().toLocaleString(),
+			time: (/* @__PURE__ */ new Date()).toLocaleString(),
 			externalize: Object.fromEntries(this.externalizeMap.entries())
 		}, null, 2);
 		return fs.promises.writeFile(pathe.join(this.dumpDir, "info.json"), info, "utf-8");
@@ -128,6 +129,7 @@ function guessCJSversion(id) {
 		]) if (fs.existsSync(i)) return i;
 	}
 }
+// The code from https://github.com/unjs/mlly/blob/c5bcca0cda175921344fd6de1bc0c499e73e5dac/src/syntax.ts#L51-L98
 async function isValidNodeImport(id) {
 	const extension = pathe.extname(id);
 	if (BUILTIN_EXTENSIONS.has(extension)) return true;
@@ -145,19 +147,24 @@ async function isValidNodeImport(id) {
 		return false;
 	}
 }
-const _defaultExternalizeCache = new Map();
+const _defaultExternalizeCache = /* @__PURE__ */ new Map();
 async function shouldExternalize(id, options, cache = _defaultExternalizeCache) {
 	if (!cache.has(id)) cache.set(id, _shouldExternalize(id, options));
 	return cache.get(id);
 }
 async function _shouldExternalize(id, options) {
 	if (utils.isNodeBuiltin(id)) return id;
+	// data: should be processed by native import,
+	// since it is a feature of ESM.
+	// also externalize network imports since nodejs allows it when --experimental-network-imports
 	if (id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
 	id = patchWindowsImportPath(id);
 	const moduleDirectories = (options === null || options === void 0 ? void 0 : options.moduleDirectories) || ["/node_modules/"];
 	if (matchExternalizePattern(id, moduleDirectories, options === null || options === void 0 ? void 0 : options.inline)) return false;
 	if ((options === null || options === void 0 ? void 0 : options.inlineFiles) && (options === null || options === void 0 ? void 0 : options.inlineFiles.includes(id))) return false;
 	if (matchExternalizePattern(id, moduleDirectories, options === null || options === void 0 ? void 0 : options.external)) return id;
+	// Unless the user explicitly opted to inline them, externalize Vite deps.
+	// They are too big to inline by default.
 	if ((options === null || options === void 0 ? void 0 : options.cacheDir) && id.includes(options.cacheDir)) return id;
 	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir));
 	const guessCJS = isLibraryModule && (options === null || options === void 0 ? void 0 : options.fallbackCJS);
@@ -184,33 +191,38 @@ function patchWindowsImportPath(path) {
 const debugRequest = createDebug("vite-node:server:request");
 class ViteNodeServer {
 	fetchPromiseMap = {
-		ssr: new Map(),
-		web: new Map()
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
 	};
 	transformPromiseMap = {
-		ssr: new Map(),
-		web: new Map()
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
 	};
 	durations = {
-		ssr: new Map(),
-		web: new Map()
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
 	};
-	existingOptimizedDeps = new Set();
+	existingOptimizedDeps = /* @__PURE__ */ new Set();
 	fetchCaches = {
-		ssr: new Map(),
-		web: new Map()
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
 	};
-	fetchCache = new Map();
-	externalizeCache = new Map();
+	fetchCache = /* @__PURE__ */ new Map();
+	externalizeCache = /* @__PURE__ */ new Map();
 	debugger;
 	constructor(server, options = {}) {
+		var _options$deps3;
 		this.server = server;
 		this.options = options;
-		var _options$deps3;
 		const ssrOptions = server.config.ssr;
 		options.deps ?? (options.deps = {});
 		options.deps.cacheDir = pathe.relative(server.config.root, options.deps.cacheDir || server.config.cacheDir);
 		if (ssrOptions) {
+			// we don't externalize ssr, because it has different semantics in Vite
+			// if (ssrOptions.external) {
+			//   options.deps.external ??= []
+			//   options.deps.external.push(...ssrOptions.external)
+			// }
 			if (ssrOptions.noExternal === true) {
 				var _options$deps;
 				(_options$deps = options.deps).inline ?? (_options$deps.inline = true);
@@ -240,6 +252,7 @@ class ViteNodeServer {
 			if (!dir.endsWith("/")) dir += "/";
 			return pathe.normalize(dir);
 		});
+		// always add node_modules as a module directory
 		if (!options.deps.moduleDirectories.includes("/node_modules/")) options.deps.moduleDirectories.push("/node_modules/");
 	}
 	shouldExternalize(id) {
@@ -293,6 +306,7 @@ class ViteNodeServer {
 		const moduleId = utils.normalizeModuleId(id);
 		this.assertMode(mode);
 		const promiseMap = this.fetchPromiseMap[mode];
+		// reuse transform for concurrent requests
 		if (!promiseMap.has(moduleId)) promiseMap.set(moduleId, this._fetchModule(moduleId, mode).finally(() => {
 			promiseMap.delete(moduleId);
 		}));
@@ -302,6 +316,7 @@ class ViteNodeServer {
 		const mode = transformMode || this.getTransformMode(id);
 		this.assertMode(mode);
 		const promiseMap = this.transformPromiseMap[mode];
+		// reuse transform for concurrent requests
 		if (!promiseMap.has(id)) promiseMap.set(id, this._transformRequest(id, filepath, mode).finally(() => {
 			promiseMap.delete(id);
 		}));
@@ -327,6 +342,7 @@ class ViteNodeServer {
 		if (module) return module;
 		const _modules = this.server.moduleGraph.getModulesByFile(file);
 		if (!_modules || !_modules.size) return null;
+		// find the latest changed module
 		const modules = [..._modules];
 		let mod = modules[0];
 		let latestMax = -1;
@@ -354,6 +370,9 @@ class ViteNodeServer {
 		const { path: filePath } = utils.toFilePath(id, this.server.config.root);
 		const moduleNode = this.getChangedModule(id, filePath);
 		const cache = this.fetchCaches[transformMode].get(filePath);
+		// lastUpdateTimestamp is the timestamp that marks the last time the module was changed
+		// if lastUpdateTimestamp is 0, then the module was not changed since the server started
+		// we test "timestamp === 0" for expressiveness, but it's not necessary
 		const timestamp = moduleNode ? Math.max(moduleNode.lastHMRTimestamp, moduleNode.lastInvalidationTimestamp) : 0;
 		if (cache && (timestamp === 0 || cache.timestamp >= timestamp)) return cache.result;
 		const time = Date.now();
@@ -401,6 +420,8 @@ class ViteNodeServer {
 			if (result) return result;
 		}
 		if (transformMode === "web") {
+			// for components like Vue, we want to use the client side
+			// plugins but then convert the code to be consumed by the server
 			result = await this.server.transformRequest(id);
 			if (result) result = await this.server.ssrTransform(result.code, result.map, id);
 		} else result = await this.server.transformRequest(id, { ssr: true });

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { TransformResult, ViteDevServer } from 'vite';
-import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index.d-CWZbpOcv.js';
+import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index.d-DGmxD2U7.js';
 import { E as EncodedSourceMap } from './trace-mapping.d-DLVdEqOp.js';
 
 declare class Debugger {