@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/esm/cache.js

@@ -1,297 +1,441 @@
-import { createHash } from 'crypto';
-import fs from 'node:fs';
-import { logger } from '@wyw-in-js/shared';
-import { getFileIdx } from './utils/getFileIdx';
-import { stripQueryAndHash } from './utils/parseRequest';
+import { createHash } from "crypto";
+import fs from "node:fs";
+import { logger } from "@wyw-in-js/shared";
+import { getFileIdx } from "./utils/getFileIdx.js";
+import { stripQueryAndHash } from "./utils/parseRequest.js";
 function hashContent(content) {
-  return createHash('sha256').update(content).digest('hex');
+	return createHash("sha256").update(content).digest("hex");
 }
 function isMissingFileError(error) {
-  if (!error || typeof error !== 'object') {
-    return false;
-  }
-  const {
-    code
-  } = error;
-  return code === 'ENOENT' || code === 'ENOTDIR';
+	if (!error || typeof error !== "object") {
+		return false;
+	}
+	const { code } = error;
+	return code === "ENOENT" || code === "ENOTDIR";
 }
-const cacheLogger = logger.extend('cache');
-const cacheNames = ['barrelManifests', 'entrypoints', 'exports'];
+const cacheLogger = logger.extend("cache");
+const cacheNames = [
+	"barrelManifests",
+	"entrypoints",
+	"exports"
+];
 const loggers = cacheNames.reduce((acc, key) => ({
-  ...acc,
-  [key]: cacheLogger.extend(key)
+	...acc,
+	[key]: cacheLogger.extend(key)
 }), {});
 export class TransformCacheCollection {
-  barrelManifestDependencies = new Map();
-  contentHashes = new Map();
-  fileMtimes = new Map();
-  exportDependencies = new Map();
-  constructor(caches = {}) {
-    this.barrelManifests = caches.barrelManifests || new Map();
-    this.entrypoints = caches.entrypoints || new Map();
-    this.exports = caches.exports || new Map();
-  }
-  add(cacheName, key, value) {
-    const cache = this[cacheName];
-    loggers[cacheName]('%s:add %s %f', getFileIdx(key), key, () => {
-      if (value === undefined) {
-        return cache.has(key) ? 'removed' : 'noop';
-      }
-      if (!cache.has(key)) {
-        return 'added';
-      }
-      return cache.get(key) === value ? 'unchanged' : 'updated';
-    });
-    if (value === undefined) {
-      cache.delete(key);
-      this.contentHashes.delete(key);
-      this.clearCacheDependencies(cacheName, key);
-      return;
-    }
-    this.clearCacheDependencies(cacheName, key);
-    cache.set(key, value);
-    if ('initialCode' in value) {
-      const maybeOriginalCode = value.originalCode;
-      const isLoaded = typeof value.initialCode === 'string';
-      const source = isLoaded ? 'loaded' : 'fs';
-      let resolvedCode;
-      if (isLoaded) {
-        resolvedCode = value.initialCode;
-      } else if (typeof maybeOriginalCode === 'string') {
-        resolvedCode = maybeOriginalCode;
-      }
-      if (resolvedCode !== undefined) {
-        this.setContentHash(key, source, hashContent(resolvedCode));
-        return;
-      }
-      try {
-        const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
-        this.setContentHash(key, source, hashContent(fileContent));
-      } catch {
-        this.setContentHash(key, source, hashContent(''));
-      }
-      return;
-    }
-    if (cacheName === 'barrelManifests') {
-      try {
-        const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
-        this.setContentHash(key, 'fs', hashContent(fileContent));
-      } catch {
-        this.setContentHash(key, 'fs', hashContent(''));
-      }
-    }
-  }
-  clear(cacheName) {
-    if (cacheName === 'all') {
-      cacheNames.forEach(name => {
-        this.clear(name);
-      });
-      return;
-    }
-    loggers[cacheName]('clear');
-    const cache = this[cacheName];
-    cache.clear();
-    this.clearCacheDependencies(cacheName);
-  }
-  delete(cacheName, key) {
-    this.invalidate(cacheName, key);
-  }
-  get(cacheName, key) {
-    const cache = this[cacheName];
-    const res = cache.get(key);
-    loggers[cacheName]('get', key, res === undefined ? 'miss' : 'hit');
-    return res;
-  }
-  has(cacheName, key) {
-    const cache = this[cacheName];
-    const res = cache.has(key);
-    loggers[cacheName]('has', key, res);
-    return res;
-  }
-  invalidate(cacheName, key) {
-    const cache = this[cacheName];
-    if (!cache.has(key)) {
-      return;
-    }
-    loggers[cacheName]('invalidate', key);
-    cache.delete(key);
-    this.clearCacheDependencies(cacheName, key);
-  }
-  invalidateForFile(filename) {
-    cacheNames.forEach(cacheName => {
-      this.invalidate(cacheName, filename);
-    });
-  }
-  invalidateIfChanged(filename, content, previousVisitedFiles, source = 'loaded', changedFiles = new Set()) {
-    if (changedFiles.has(filename)) {
-      return true;
-    }
-    const visitedFiles = new Set(previousVisitedFiles);
-    const fileEntrypoint = this.get('entrypoints', filename);
-    let anyDepChanged = false;
-
-    // We need to check all dependencies of the file
-    // because they might have changed as well.
-    if (!visitedFiles.has(filename) && (fileEntrypoint || this.hasCachedDependencies(filename))) {
-      visitedFiles.add(filename);
-      const invalidateOnDependencyChange = fileEntrypoint?.invalidateOnDependencyChange;
-      const dependenciesToCheck = new Map();
-      for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
-        dependenciesToCheck.set(key, dependency);
-      }
-      for (const [key, dependency] of fileEntrypoint?.invalidationDependencies ?? []) {
-        if (!dependenciesToCheck.has(key)) {
-          dependenciesToCheck.set(key, dependency);
-        }
-      }
-      for (const dependencyFilename of this.getCachedDependencies(filename)) {
-        if (![...dependenciesToCheck.values()].some(dependency => dependency.resolved === dependencyFilename)) {
-          dependenciesToCheck.set(dependencyFilename, {
-            resolved: dependencyFilename
-          });
-        }
-      }
-      for (const [, dependency] of dependenciesToCheck) {
-        const dependencyFilename = dependency.resolved;
-        if (dependencyFilename) {
-          let dependencyContent;
-          try {
-            dependencyContent = fs.readFileSync(stripQueryAndHash(dependencyFilename), 'utf8');
-          } catch (error) {
-            if (!isMissingFileError(error)) {
-              throw error;
-            }
-            this.invalidateForFile(dependencyFilename);
-            anyDepChanged = true;
-            // eslint-disable-next-line no-continue
-            continue;
-          }
-          const dependencyChanged = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles);
-          if (dependencyChanged && invalidateOnDependencyChange?.has(dependencyFilename)) {
-            cacheLogger('dependency affecting output has changed, invalidate all for %s', filename);
-            this.invalidateForFile(filename);
-            changedFiles.add(filename);
-            return true;
-          }
-          if (dependencyChanged) {
-            anyDepChanged = true;
-          }
-        }
-      }
-    }
-    const existing = this.contentHashes.get(filename);
-    const previousHash = existing?.[source];
-    const newHash = hashContent(content);
-    if (previousHash === undefined) {
-      const otherSource = source === 'fs' ? 'loaded' : 'fs';
-      const otherHash = existing?.[otherSource];
-      if (otherHash !== undefined && otherHash !== newHash || anyDepChanged) {
-        cacheLogger('content has changed, invalidate all for %s', filename);
-        this.setContentHash(filename, source, newHash);
-        this.invalidateForFile(filename);
-        changedFiles.add(filename);
-        return true;
-      }
-      this.setContentHash(filename, source, newHash);
-      if (anyDepChanged) {
-        this.invalidateForFile(filename);
-        changedFiles.add(filename);
-        return true;
-      }
-      return false;
-    }
-    if (previousHash !== newHash || anyDepChanged) {
-      cacheLogger('content has changed, invalidate all for %s', filename);
-      this.setContentHash(filename, source, newHash);
-      this.invalidateForFile(filename);
-      changedFiles.add(filename);
-      return true;
-    }
-    return false;
-  }
-  setCacheDependencies(cacheName, key, dependencies) {
-    const cache = this.getDependencyCache(cacheName);
-    const nextDependencies = new Set([...dependencies].filter(dependency => dependency.length > 0));
-    if (nextDependencies.size === 0) {
-      cache.delete(key);
-      return;
-    }
-    cache.set(key, nextDependencies);
-  }
-  clearCacheDependencies(cacheName, key) {
-    if (cacheName === 'all') {
-      this.barrelManifestDependencies.clear();
-      this.exportDependencies.clear();
-      return;
-    }
-    if (cacheName === 'barrelManifests') {
-      if (key === undefined) {
-        this.barrelManifestDependencies.clear();
-      } else {
-        this.barrelManifestDependencies.delete(key);
-      }
-      return;
-    }
-    if (cacheName === 'exports') {
-      if (key === undefined) {
-        this.exportDependencies.clear();
-      } else {
-        this.exportDependencies.delete(key);
-      }
-    }
-  }
-  getCachedDependencies(filename) {
-    return new Set([...(this.barrelManifestDependencies.get(filename) ?? []), ...(this.exportDependencies.get(filename) ?? [])]);
-  }
-  getDependencyCache(cacheName) {
-    return cacheName === 'barrelManifests' ? this.barrelManifestDependencies : this.exportDependencies;
-  }
-  hasCachedDependencies(filename) {
-    return this.getCachedDependencies(filename).size > 0;
-  }
-
-  /**
-   * Fast check if a file changed on disk since last seen.
-   * Uses mtime as a fast path — only reads the file if mtime differs.
-   * Returns true if the file changed (cache was invalidated).
-   */
-  checkFreshness(filename, strippedFilename) {
-    try {
-      const currentMtime = fs.statSync(strippedFilename).mtimeMs;
-      const cachedMtime = this.fileMtimes.get(filename);
-      if (cachedMtime !== undefined && currentMtime === cachedMtime) {
-        return false;
-      }
-      const content = fs.readFileSync(strippedFilename, 'utf-8');
-      this.fileMtimes.set(filename, currentMtime);
-      if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
-        return true;
-      }
-      return false;
-    } catch (error) {
-      if (!isMissingFileError(error)) {
-        throw error;
-      }
-      this.invalidateForFile(filename);
-      return true;
-    }
-  }
-  setContentHash(filename, source, hash) {
-    const current = this.contentHashes.get(filename);
-    if (current) {
-      current[source] = hash;
-    } else {
-      this.contentHashes.set(filename, {
-        [source]: hash
-      });
-    }
-    if (source === 'fs') {
-      try {
-        this.fileMtimes.set(filename, fs.statSync(stripQueryAndHash(filename)).mtimeMs);
-      } catch {
-        // ignore
-      }
-    }
-  }
+	barrelManifests;
+	entrypoints;
+	exports;
+	barrelManifestDependencies = new Map();
+	contentHashes = new Map();
+	fileMtimes = new Map();
+	exportDependencies = new Map();
+	keySalt = null;
+	invalidatedFiles = new Map();
+	consumedInvalidationVersions = new Map();
+	constructor(caches = {}) {
+		this.barrelManifests = caches.barrelManifests || new Map();
+		this.entrypoints = caches.entrypoints || new Map();
+		this.exports = caches.exports || new Map();
+	}
+	setKeySalt(keySalt) {
+		if (this.keySalt === keySalt) return;
+		const prevKeySalt = this.keySalt;
+		this.keySalt = keySalt;
+		if (prevKeySalt === null && keySalt) {
+			const migrate = (cache) => {
+				const entries = Array.from(cache.entries());
+				cache.clear();
+				entries.forEach(([key, value]) => {
+					cache.set(this.getKey(key), value);
+				});
+			};
+			migrate(this.barrelManifests);
+			migrate(this.entrypoints);
+			migrate(this.exports);
+			migrate(this.barrelManifestDependencies);
+			migrate(this.exportDependencies);
+			return;
+		}
+		this.barrelManifests.clear();
+		this.entrypoints.clear();
+		this.exports.clear();
+		this.clearCacheDependencies("all");
+	}
+	getKey(key) {
+		if (!this.keySalt) return key;
+		return `${key}::${this.keySalt}`;
+	}
+	getKeySalt() {
+		return this.keySalt;
+	}
+	add(cacheName, key, value) {
+		const cache = this[cacheName];
+		const cacheKey = this.getKey(key);
+		loggers[cacheName]("%s:add %s %f", getFileIdx(key), key, () => {
+			if (value === undefined) {
+				return cache.has(cacheKey) ? "removed" : "noop";
+			}
+			if (!cache.has(cacheKey)) {
+				return "added";
+			}
+			return cache.get(cacheKey) === value ? "unchanged" : "updated";
+		});
+		if (value === undefined) {
+			cache.delete(cacheKey);
+			this.contentHashes.delete(key);
+			this.clearCacheDependencies(cacheName, key);
+			return;
+		}
+		this.clearCacheDependencies(cacheName, key);
+		cache.set(cacheKey, value);
+		if ("initialCode" in value) {
+			const maybeOriginalCode = value.originalCode;
+			const isLoaded = typeof value.initialCode === "string";
+			const source = isLoaded ? "loaded" : "fs";
+			let resolvedCode;
+			if (isLoaded) {
+				resolvedCode = value.initialCode;
+			} else if (typeof maybeOriginalCode === "string") {
+				resolvedCode = maybeOriginalCode;
+			}
+			if (resolvedCode !== undefined) {
+				this.setContentHash(key, source, hashContent(resolvedCode));
+				return;
+			}
+			try {
+				const fileContent = fs.readFileSync(stripQueryAndHash(key), "utf8");
+				this.setContentHash(key, source, hashContent(fileContent));
+			} catch {
+				this.setContentHash(key, source, hashContent(""));
+			}
+			return;
+		}
+		if (cacheName === "barrelManifests" || cacheName === "exports") {
+			try {
+				const fileContent = fs.readFileSync(stripQueryAndHash(key), "utf8");
+				this.setContentHash(key, "fs", hashContent(fileContent));
+			} catch {
+				this.setContentHash(key, "fs", hashContent(""));
+			}
+		}
+	}
+	clear(cacheName) {
+		if (cacheName === "all") {
+			cacheNames.forEach((name) => {
+				this.clear(name);
+			});
+			return;
+		}
+		loggers[cacheName]("clear");
+		const cache = this[cacheName];
+		cache.clear();
+		this.clearCacheDependencies(cacheName);
+	}
+	delete(cacheName, key) {
+		this.invalidate(cacheName, key);
+	}
+	get(cacheName, key) {
+		const cache = this[cacheName];
+		const res = cache.get(this.getKey(key));
+		loggers[cacheName]("get", key, res === undefined ? "miss" : "hit");
+		return res;
+	}
+	has(cacheName, key) {
+		const cache = this[cacheName];
+		const res = cache.has(this.getKey(key));
+		loggers[cacheName]("has", key, res);
+		return res;
+	}
+	invalidate(cacheName, key) {
+		const cache = this[cacheName];
+		const cacheKey = this.getKey(key);
+		if (!cache.has(cacheKey)) {
+			return;
+		}
+		loggers[cacheName]("invalidate", key);
+		cache.delete(cacheKey);
+		this.clearCacheDependencies(cacheName, key);
+	}
+	invalidateForFile(filename) {
+		cacheNames.forEach((cacheName) => {
+			this.invalidate(cacheName, filename);
+		});
+		const key = stripQueryAndHash(filename);
+		const version = this.invalidatedFiles.get(key) ?? 0;
+		this.invalidatedFiles.set(key, version + 1);
+	}
+	consumeInvalidation(filename) {
+		const key = stripQueryAndHash(filename);
+		const invalidationVersion = this.invalidatedFiles.get(key);
+		if (invalidationVersion === undefined) {
+			return false;
+		}
+		const consumedVersion = this.consumedInvalidationVersions.get(filename) ?? 0;
+		if (consumedVersion >= invalidationVersion) {
+			return false;
+		}
+		this.consumedInvalidationVersions.set(filename, invalidationVersion);
+		return true;
+	}
+	invalidateIfChanged(filename, content, previousVisitedFiles, source = "loaded", changedFiles = new Set(), dependencyChangeMemo = new Map(), forceContentCheck = false) {
+		if (changedFiles.has(filename)) {
+			return true;
+		}
+		const visitedFiles = new Set(previousVisitedFiles);
+		const fileEntrypoint = this.get("entrypoints", filename);
+		let anyDepChanged = false;
+		if (!visitedFiles.has(filename) && (fileEntrypoint || this.hasCachedDependencies(filename))) {
+			visitedFiles.add(filename);
+			const invalidateOnDependencyChange = fileEntrypoint?.invalidateOnDependencyChange;
+			const dependenciesToCheck = this.getDependenciesToCheck(filename, fileEntrypoint);
+			for (const [, dependency] of dependenciesToCheck) {
+				const dependencyFilename = dependency.resolved;
+				if (dependencyFilename) {
+					const dependencyChanged = this.didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck || invalidateOnDependencyChange?.has(dependencyFilename) || false);
+					if (dependencyChanged && invalidateOnDependencyChange?.has(dependencyFilename)) {
+						cacheLogger("dependency affecting output has changed, invalidate all for %s", filename);
+						this.invalidateForFile(filename);
+						changedFiles.add(filename);
+						return true;
+					}
+					if (dependencyChanged) {
+						anyDepChanged = true;
+					}
+				}
+			}
+		}
+		const existing = this.contentHashes.get(filename);
+		const previousHash = existing?.[source];
+		const newHash = hashContent(content);
+		if (previousHash === undefined) {
+			const otherSource = source === "fs" ? "loaded" : "fs";
+			const otherHash = existing?.[otherSource];
+			if (otherHash !== undefined && otherHash !== newHash || anyDepChanged) {
+				cacheLogger("content has changed, invalidate all for %s", filename);
+				this.setContentHash(filename, source, newHash);
+				this.invalidateForFile(filename);
+				changedFiles.add(filename);
+				return true;
+			}
+			this.setContentHash(filename, source, newHash);
+			if (anyDepChanged) {
+				this.invalidateForFile(filename);
+				changedFiles.add(filename);
+				return true;
+			}
+			return false;
+		}
+		if (previousHash !== newHash || anyDepChanged) {
+			cacheLogger("content has changed, invalidate all for %s", filename);
+			this.setContentHash(filename, source, newHash);
+			this.invalidateForFile(filename);
+			changedFiles.add(filename);
+			return true;
+		}
+		return false;
+	}
+	getDependenciesToCheck(filename, fileEntrypoint) {
+		const dependenciesToCheck = new Map();
+		for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
+			dependenciesToCheck.set(key, dependency);
+		}
+		for (const [key, dependency] of fileEntrypoint?.invalidationDependencies ?? []) {
+			if (!dependenciesToCheck.has(key)) {
+				dependenciesToCheck.set(key, dependency);
+			}
+		}
+		for (const dependencyFilename of this.getCachedDependencies(filename)) {
+			if (![...dependenciesToCheck.values()].some((dependency) => dependency.resolved === dependencyFilename)) {
+				dependenciesToCheck.set(dependencyFilename, { resolved: dependencyFilename });
+			}
+		}
+		return dependenciesToCheck;
+	}
+	didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck = false) {
+		if (changedFiles.has(dependencyFilename)) {
+			return true;
+		}
+		const memoized = dependencyChangeMemo.get(dependencyFilename);
+		if (memoized !== undefined) {
+			return memoized;
+		}
+		if (visitedFiles.has(dependencyFilename)) {
+			return false;
+		}
+		const strippedDependencyFilename = stripQueryAndHash(dependencyFilename);
+		const cachedMtime = this.fileMtimes.get(dependencyFilename);
+		const cachedEntrypoint = this.get("entrypoints", dependencyFilename);
+		if (cachedMtime !== undefined) {
+			let currentMtime;
+			try {
+				currentMtime = fs.statSync(strippedDependencyFilename).mtimeMs;
+			} catch (error) {
+				if (!isMissingFileError(error)) {
+					throw error;
+				}
+				this.invalidateForFile(dependencyFilename);
+				changedFiles.add(dependencyFilename);
+				dependencyChangeMemo.set(dependencyFilename, true);
+				return true;
+			}
+			if (currentMtime === cachedMtime) {
+				const nestedDependencies = this.getDependenciesToCheck(dependencyFilename, cachedEntrypoint);
+				if (forceContentCheck && this.didFileContentHashChange(dependencyFilename, strippedDependencyFilename, changedFiles)) {
+					dependencyChangeMemo.set(dependencyFilename, true);
+					return true;
+				}
+				// A cached file without a cached entrypoint was invalidated earlier.
+				// If the caller forced a content check and the content hash is stable,
+				// the missing entrypoint is only cache churn and must not invalidate
+				// output-dependent parents.
+				if (!cachedEntrypoint && nestedDependencies.size === 0) {
+					if (forceContentCheck && this.contentHashes.get(dependencyFilename)?.fs !== undefined) {
+						dependencyChangeMemo.set(dependencyFilename, false);
+						return false;
+					}
+					dependencyChangeMemo.set(dependencyFilename, true);
+					return true;
+				}
+				if (nestedDependencies.size === 0) {
+					dependencyChangeMemo.set(dependencyFilename, false);
+					return false;
+				}
+				const nextVisitedFiles = new Set(visitedFiles);
+				nextVisitedFiles.add(dependencyFilename);
+				for (const [, nestedDependency] of nestedDependencies) {
+					if (nestedDependency.resolved && this.didDependencyChange(nestedDependency.resolved, nextVisitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck)) {
+						this.invalidateForFile(dependencyFilename);
+						changedFiles.add(dependencyFilename);
+						dependencyChangeMemo.set(dependencyFilename, true);
+						return true;
+					}
+				}
+				dependencyChangeMemo.set(dependencyFilename, false);
+				return false;
+			}
+		}
+		let dependencyContent;
+		try {
+			dependencyContent = fs.readFileSync(strippedDependencyFilename, "utf8");
+		} catch (error) {
+			if (!isMissingFileError(error)) {
+				throw error;
+			}
+			this.invalidateForFile(dependencyFilename);
+			changedFiles.add(dependencyFilename);
+			dependencyChangeMemo.set(dependencyFilename, true);
+			return true;
+		}
+		const invalidated = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, "fs", changedFiles, dependencyChangeMemo, forceContentCheck);
+		dependencyChangeMemo.set(dependencyFilename, invalidated);
+		return invalidated;
+	}
+	didFileContentHashChange(filename, strippedFilename, changedFiles) {
+		const previousHash = this.contentHashes.get(filename)?.fs;
+		if (previousHash === undefined) {
+			return false;
+		}
+		let content;
+		try {
+			content = fs.readFileSync(strippedFilename, "utf8");
+		} catch (error) {
+			if (!isMissingFileError(error)) {
+				throw error;
+			}
+			this.invalidateForFile(filename);
+			changedFiles.add(filename);
+			return true;
+		}
+		const nextHash = hashContent(content);
+		if (previousHash === nextHash) {
+			return false;
+		}
+		this.setContentHash(filename, "fs", nextHash);
+		this.invalidateForFile(filename);
+		changedFiles.add(filename);
+		return true;
+	}
+	setCacheDependencies(cacheName, key, dependencies) {
+		const cache = this.getDependencyCache(cacheName);
+		const nextDependencies = new Set([...dependencies].filter((dependency) => dependency.length > 0));
+		const cacheKey = this.getKey(key);
+		if (nextDependencies.size === 0) {
+			cache.delete(cacheKey);
+			return;
+		}
+		cache.set(cacheKey, nextDependencies);
+	}
+	/**
+	* Fast check if a file changed on disk since last seen.
+	* Uses mtime as a fast path and only reads the file if mtime differs.
+	*/
+	checkFreshness(filename, strippedFilename) {
+		try {
+			const currentMtime = fs.statSync(strippedFilename).mtimeMs;
+			const cachedMtime = this.fileMtimes.get(filename);
+			if (cachedMtime !== undefined && currentMtime === cachedMtime) {
+				return false;
+			}
+			const content = fs.readFileSync(strippedFilename, "utf8");
+			this.fileMtimes.set(filename, currentMtime);
+			if (this.invalidateIfChanged(filename, content, undefined, "fs")) {
+				return true;
+			}
+			return false;
+		} catch (error) {
+			if (!isMissingFileError(error)) {
+				throw error;
+			}
+			this.invalidateForFile(filename);
+			return true;
+		}
+	}
+	clearCacheDependencies(cacheName, key) {
+		if (cacheName === "all") {
+			this.barrelManifestDependencies.clear();
+			this.exportDependencies.clear();
+			return;
+		}
+		if (cacheName === "barrelManifests") {
+			if (key === undefined) {
+				this.barrelManifestDependencies.clear();
+			} else {
+				this.barrelManifestDependencies.delete(this.getKey(key));
+			}
+			return;
+		}
+		if (cacheName === "exports") {
+			if (key === undefined) {
+				this.exportDependencies.clear();
+			} else {
+				this.exportDependencies.delete(this.getKey(key));
+			}
+		}
+	}
+	getCachedDependencies(filename) {
+		const key = this.getKey(filename);
+		return new Set([...this.barrelManifestDependencies.get(key) ?? [], ...this.exportDependencies.get(key) ?? []]);
+	}
+	getDependencyCache(cacheName) {
+		return cacheName === "barrelManifests" ? this.barrelManifestDependencies : this.exportDependencies;
+	}
+	hasCachedDependencies(filename) {
+		return this.getCachedDependencies(filename).size > 0;
+	}
+	setContentHash(filename, source, hash) {
+		const current = this.contentHashes.get(filename);
+		if (current) {
+			current[source] = hash;
+		} else {
+			this.contentHashes.set(filename, { [source]: hash });
+		}
+		if (source === "fs") {
+			try {
+				this.fileMtimes.set(filename, fs.statSync(stripQueryAndHash(filename)).mtimeMs);
+			} catch {}
+		}
+	}
 }
-//# sourceMappingURL=cache.js.map
+//# sourceMappingURL=cache.js.map