fix: move join/dirname caches to Resolver instance to prevent memory leak

Move cachedJoin/cachedDirname from module-level globals to per-Resolver
instance caches. When a Resolver is garbage collected, its join/dirname
caches are released with it, preventing unbounded memory growth in
long-running processes.

- Extract createCachedJoin/createCachedDirname factory functions in path.js
- Resolver constructor creates instance-level join/dirname via factories
- TsconfigPathsPlugin and UnsafeCachePlugin now use resolver.join/dirname
  instead of global cachedJoin/cachedDirname
- Global cachedJoin/cachedDirname retained for direct resolve() usage

Ref: #418

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: xiaoxiaojx

lib/Resolver.js

@@ -10,7 +10,8 @@ const createInnerContext = require("./createInnerContext");
 const { parseIdentifier } = require("./util/identifier");
 const {
 	PathType,
-	cachedJoin: join,
+	createCachedDirname,
+	createCachedJoin,
 	getType,
 	normalize,
 } = require("./util/path");
@@ -397,6 +398,8 @@ class Resolver {
 	constructor(fileSystem, options) {
 		this.fileSystem = fileSystem;
 		this.options = options;
+		this.join = createCachedJoin();
+		this.dirname = createCachedDirname();
 		/** @type {KnownHooks} */
 		this.hooks = {
 			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),
@@ -800,15 +803,6 @@ class Resolver {
 		return path.endsWith("/");
 	}
 
-	/**
-	 * @param {string} path path
-	 * @param {string} request request
-	 * @returns {string} joined path
-	 */
-	join(path, request) {
-		return join(path, request);
-	}
-
 	/**
 	 * @param {string} path path
 	 * @returns {string} normalized path

lib/TsconfigPathsPlugin.js

@@ -8,13 +8,7 @@
 const { aliasResolveHandler } = require("./AliasUtils");
 const { modulesResolveHandler } = require("./ModulesUtils");
 const { readJson } = require("./util/fs");
-const {
-	PathType: _PathType,
-	cachedDirname: dirname,
-	cachedJoin: join,
-	isSubPath,
-	normalize,
-} = require("./util/path");
+const { PathType: _PathType, isSubPath, normalize } = require("./util/path");
 
 /** @typedef {import("./Resolver")} Resolver */
 /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
@@ -102,10 +96,11 @@ function substituteConfigDir(pathValue, configDir) {
  * Convert tsconfig paths to resolver options
  * @param {string} configDir Config file directory
  * @param {{ [key: string]: string[] }} paths TypeScript paths mapping
+ * @param {(rootPath: string, request: string) => string} join join function
  * @param {string=} baseUrl Base URL for resolving paths (relative to configDir)
  * @returns {TsconfigPathsData} the resolver options
  */
-function tsconfigPathsToResolveOptions(configDir, paths, baseUrl) {
+function tsconfigPathsToResolveOptions(configDir, paths, join, baseUrl) {
 	// Calculate absolute base URL
 	const absoluteBaseUrl = !baseUrl ? configDir : join(configDir, baseUrl);
 
@@ -155,10 +150,11 @@ function tsconfigPathsToResolveOptions(configDir, paths, baseUrl) {
 /**
  * Get the base context for the current project
  * @param {string} context the context
+ * @param {(rootPath: string, request: string) => string} join join function
  * @param {string=} baseUrl base URL for resolving paths
  * @returns {string} the base context
  */
-function getAbsoluteBaseUrl(context, baseUrl) {
+function getAbsoluteBaseUrl(context, join, baseUrl) {
 	return !baseUrl ? context : join(context, baseUrl);
 }
 
@@ -293,6 +289,7 @@ module.exports = class TsconfigPathsPlugin {
 	 * @returns {Promise<TsconfigPathsMap | null>} the tsconfig paths map or null
 	 */
 	async _getTsconfigPathsMap(resolver, request, resolveContext) {
+		const { join, dirname } = resolver;
 		if (typeof request.tsconfigPathsMap === "undefined") {
 			try {
 				const absTsconfigPath = join(
@@ -302,6 +299,8 @@ module.exports = class TsconfigPathsPlugin {
 				const result = await this._loadTsconfigPathsMap(
 					resolver.fileSystem,
 					absTsconfigPath,
+					join,
+					dirname,
 				);
 
 				request.tsconfigPathsMap = result;
@@ -334,15 +333,19 @@ module.exports = class TsconfigPathsPlugin {
 	 * Includes main project paths and all referenced projects
 	 * @param {FileSystem} fileSystem the file system
 	 * @param {string} absTsconfigPath absolute path to tsconfig.json
+	 * @param {(rootPath: string, request: string) => string} join join function
+	 * @param {(maybePath: string) => string} dirname dirname function
 	 * @returns {Promise<TsconfigPathsMap>} the complete tsconfig paths map
 	 */
-	async _loadTsconfigPathsMap(fileSystem, absTsconfigPath) {
+	async _loadTsconfigPathsMap(fileSystem, absTsconfigPath, join, dirname) {
 		/** @type {Set<string>} */
 		const fileDependencies = new Set();
 		const config = await this._loadTsconfig(
 			fileSystem,
 			absTsconfigPath,
 			fileDependencies,
+			join,
+			dirname,
 		);
 
 		const compilerOptions = config.compilerOptions || {};
@@ -354,6 +357,7 @@ module.exports = class TsconfigPathsPlugin {
 		const main = tsconfigPathsToResolveOptions(
 			mainContext,
 			compilerOptions.paths || {},
+			join,
 			baseUrl,
 		);
 		/** @type {{ [baseUrl: string]: TsconfigPathsData }} */
@@ -373,6 +377,8 @@ module.exports = class TsconfigPathsPlugin {
 				referencesToUse,
 				fileDependencies,
 				refs,
+				join,
+				dirname,
 			);
 		}
 
@@ -423,6 +429,8 @@ module.exports = class TsconfigPathsPlugin {
 	 * @param {string} extendedConfigValue extends value
 	 * @param {Set<string>} fileDependencies the file dependencies
 	 * @param {Set<string>} visitedConfigPaths config paths being loaded (for circular extends detection)
+	 * @param {(rootPath: string, request: string) => string} join join function
+	 * @param {(maybePath: string) => string} dirname dirname function
 	 * @returns {Promise<Tsconfig>} the extended tsconfig
 	 */
 	async _loadTsconfigFromExtends(
@@ -431,6 +439,8 @@ module.exports = class TsconfigPathsPlugin {
 		extendedConfigValue,
 		fileDependencies,
 		visitedConfigPaths,
+		join,
+		dirname,
 	) {
 		const currentDir = dirname(configFilePath);
 
@@ -485,6 +495,8 @@ module.exports = class TsconfigPathsPlugin {
 			fileSystem,
 			extendedConfigPath,
 			fileDependencies,
+			join,
+			dirname,
 			visitedConfigPaths,
 		);
 		const compilerOptions = config.compilerOptions || { baseUrl: undefined };
@@ -493,6 +505,7 @@ module.exports = class TsconfigPathsPlugin {
 			const extendedConfigDir = dirname(extendedConfigPath);
 			compilerOptions.baseUrl = getAbsoluteBaseUrl(
 				extendedConfigDir,
+				join,
 				compilerOptions.baseUrl,
 			);
 		}
@@ -511,6 +524,8 @@ module.exports = class TsconfigPathsPlugin {
 	 * @param {TsconfigReference[]} references array of references
 	 * @param {Set<string>} fileDependencies the file dependencies
 	 * @param {{ [baseUrl: string]: TsconfigPathsData }} referenceMatchMap the map to populate
+	 * @param {(rootPath: string, request: string) => string} join join function
+	 * @param {(maybePath: string) => string} dirname dirname function
 	 * @returns {Promise<void>}
 	 */
 	async _loadTsconfigReferences(
@@ -519,6 +534,8 @@ module.exports = class TsconfigPathsPlugin {
 		references,
 		fileDependencies,
 		referenceMatchMap,
+		join,
+		dirname,
 	) {
 		await Promise.all(
 			references.map(async (ref) => {
@@ -530,6 +547,8 @@ module.exports = class TsconfigPathsPlugin {
 						fileSystem,
 						refConfigPath,
 						fileDependencies,
+						join,
+						dirname,
 					);
 
 					if (refConfig.compilerOptions && refConfig.compilerOptions.paths) {
@@ -538,6 +557,7 @@ module.exports = class TsconfigPathsPlugin {
 						referenceMatchMap[refContext] = tsconfigPathsToResolveOptions(
 							refContext,
 							refConfig.compilerOptions.paths || {},
+							join,
 							refConfig.compilerOptions.baseUrl,
 						);
 					}
@@ -552,6 +572,8 @@ module.exports = class TsconfigPathsPlugin {
 							refConfig.references,
 							fileDependencies,
 							referenceMatchMap,
+							join,
+							dirname,
 						);
 					}
 				} catch (_err) {
@@ -566,13 +588,17 @@ module.exports = class TsconfigPathsPlugin {
 	 * @param {FileSystem} fileSystem the file system
 	 * @param {string} configFilePath absolute path to tsconfig.json
 	 * @param {Set<string>} fileDependencies the file dependencies
+	 * @param {(rootPath: string, request: string) => string} join join function
+	 * @param {(maybePath: string) => string} dirname dirname function
 	 * @param {Set<string>=} visitedConfigPaths config paths being loaded (for circular extends detection)
 	 * @returns {Promise<Tsconfig>} the merged tsconfig
 	 */
 	async _loadTsconfig(
 		fileSystem,
 		configFilePath,
 		fileDependencies,
+		join,
+		dirname,
 		visitedConfigPaths = new Set(),
 	) {
 		if (visitedConfigPaths.has(configFilePath)) {
@@ -599,6 +625,8 @@ module.exports = class TsconfigPathsPlugin {
 						extendedConfigElement,
 						fileDependencies,
 						visitedConfigPaths,
+						join,
+						dirname,
 					);
 					base = mergeTsconfigs(base, extendedTsconfig);
 				}
@@ -609,6 +637,8 @@ module.exports = class TsconfigPathsPlugin {
 					extendedConfig,
 					fileDependencies,
 					visitedConfigPaths,
+					join,
+					dirname,
 				);
 			}
 

lib/UnsafeCachePlugin.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const { cachedJoin } = require("./util/path");
-
 /** @typedef {import("./Resolver")} Resolver */
 /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
 /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
@@ -18,10 +16,11 @@ const RELATIVE_REQUEST_REGEXP = /^\.\.?(?:\/|$)/;
 /**
  * @param {string} relativePath relative path from package root
  * @param {string} request relative request
+ * @param {(rootPath: string, request: string) => string} join join function
  * @returns {string} normalized request with a preserved leading dot
  */
-function joinRelativePreservingLeadingDot(relativePath, request) {
-	const normalized = cachedJoin(relativePath, request);
+function joinRelativePreservingLeadingDot(relativePath, request, join) {
+	const normalized = join(relativePath, request);
 	return RELATIVE_REQUEST_REGEXP.test(normalized)
 		? normalized
 		: `./${normalized}`;
@@ -40,9 +39,10 @@ function getCachePath(request) {
 
 /**
  * @param {ResolveRequest} request request
+ * @param {(rootPath: string, request: string) => string} join join function
  * @returns {string | undefined} normalized request string
  */
-function getCacheRequest(request) {
+function getCacheRequest(request, join) {
 	const requestString = request.request;
 	if (
 		!requestString ||
@@ -51,23 +51,28 @@ function getCacheRequest(request) {
 	) {
 		return requestString;
 	}
-	return joinRelativePreservingLeadingDot(request.relativePath, requestString);
+	return joinRelativePreservingLeadingDot(
+		request.relativePath,
+		requestString,
+		join,
+	);
 }
 
 /**
  * @param {string} type type of cache
  * @param {ResolveRequest} request request
  * @param {boolean} withContext cache with context?
+ * @param {(rootPath: string, request: string) => string} join join function
  * @returns {string} cache id
  */
-function getCacheId(type, request, withContext) {
+function getCacheId(type, request, withContext, join) {
 	return JSON.stringify({
 		type,
 		context: withContext ? request.context : "",
 		path: getCachePath(request),
 		query: request.query,
 		fragment: request.fragment,
-		request: getCacheRequest(request),
+		request: getCacheRequest(request, join),
 	});
 }
 
@@ -93,6 +98,7 @@ module.exports = class UnsafeCachePlugin {
 	 */
 	apply(resolver) {
 		const target = resolver.ensureHook(this.target);
+		const { join } = resolver;
 		resolver
 			.getHook(this.source)
 			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
@@ -110,6 +116,7 @@ module.exports = class UnsafeCachePlugin {
 					isYield ? "yield" : "default",
 					request,
 					this.withContext,
+					join,
 				);
 				const cacheEntry = this.cache[cacheId];
 				if (cacheEntry) {