@atlaspack/core 2.16.2-canary.57 → 2.16.2-canary.59

package/lib/EnvironmentManager.js

@@ -4,8 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.fromEnvironmentId = fromEnvironmentId;
+exports.loadEnvironmentsFromCache = loadEnvironmentsFromCache;
 exports.toEnvironmentId = toEnvironmentId;
 exports.toEnvironmentRef = toEnvironmentRef;
+exports.writeEnvironmentsToCache = writeEnvironmentsToCache;
 function _rust() {
   const data = require("@atlaspack/rust");
   _rust = function () {
@@ -20,6 +22,14 @@ function _featureFlags() {
   };
   return data;
 }
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _constants = require("./constants");
 /*!
  * At the moment we're doing this change for `CoreEnvironment`,
  * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
@@ -77,4 +87,51 @@ function fromEnvironmentId(id) {
   const env = Object.freeze((0, _rust().getEnvironment)(id));
   localEnvironmentCache.set(id, env);
   return env;
+}
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function writeEnvironmentsToCache(cache) {
+  const environments = (0, _rust().getAllEnvironments)();
+  const environmentIds = new Set();
+
+  // Store each environment individually
+  for (const env of environments) {
+    environmentIds.add(env.id);
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${env.id}`;
+    await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${envKey})`, async () => {
+      await cache.set(envKey, env);
+    });
+  }
+
+  // Store the list of environment IDs
+  await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${_constants.ATLASPACK_VERSION}`})`, async () => {
+    await cache.set(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`, Array.from(environmentIds));
+  });
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function loadEnvironmentsFromCache(cache) {
+  const cachedEnvIds = await cache.get(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`);
+  if (cachedEnvIds == null) {
+    return;
+  }
+  const environments = [];
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    (0, _rust().setAllEnvironments)(environments);
+  }
 }

package/lib/RequestTracker.js

@@ -95,6 +95,7 @@ function _perf_hooks() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -162,7 +163,7 @@ const nodeFromOption = (option, value) => ({
   hash: (0, _utils2.hashFromOption)(value)
 });
 const nodeFromConfigKey = (fileName, configKey, contentHash) => ({
-  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${configKey}`,
+  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${JSON.stringify(configKey)}`,
   type: CONFIG_KEY,
   configKey,
   contentHash
@@ -695,10 +696,18 @@ class RequestGraph extends _graph().ContentGraph {
         this.removeNode(nodeId, removeOrphans);
       }
       let configKeyNodes = this.configKeyNodes.get(_filePath);
-      if (configKeyNodes && (type === 'delete' || type === 'update')) {
+
+      // With granular invalidations we will always run this block,
+      // so even if we get a create event (for whatever reason), we will still
+      // try to limit invalidations from config key changes through hashing.
+      //
+      // Currently create events can invalidate a large number of nodes due to
+      // "create above" invalidations.
+      const isConfigKeyChange = (0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation') || type === 'delete' || type === 'update';
+      if (configKeyNodes && isConfigKeyChange) {
         for (let nodeId of configKeyNodes) {
           let isInvalid = type === 'delete';
-          if (type === 'update') {
+          if (type !== 'delete') {
             let node = this.getNode(nodeId);
             (0, _assert().default)(node && node.type === CONFIG_KEY);
             let contentHash = await (0, _ConfigRequest.getConfigKeyContentHash)(_filePath, node.configKey, options);
@@ -1015,6 +1024,9 @@ class RequestTracker {
         total,
         size: this.graph.nodes.length
       });
+      if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+        await (0, _EnvironmentManager.writeEnvironmentsToCache)(options.cache);
+      }
       let serialisedGraph = this.graph.serialize();
 
       // Delete an existing request graph cache, to prevent invalid states
@@ -1206,6 +1218,9 @@ async function loadRequestGraph(options) {
       ...commonMeta
     }
   });
+  if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    await (0, _EnvironmentManager.loadEnvironmentsFromCache)(options.cache);
+  }
   const hasRequestGraphInCache = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.has(requestGraphKey) : await options.cache.hasLargeBlob(requestGraphKey);
   if (hasRequestGraphInCache) {
     try {

package/lib/public/Config.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.makeConfigProxy = makeConfigProxy;
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -37,6 +38,71 @@ function _featureFlags() {
 var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const internalConfigToConfig = new (_utils().DefaultWeakMap)(() => new WeakMap());
+
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+function makeConfigProxy(onRead, config) {
+  const reportedPaths = new Set();
+  const reportPath = path => {
+    if (reportedPaths.has(path)) {
+      return;
+    }
+    reportedPaths.add(path);
+    onRead(path);
+  };
+  const makeProxy = (target, path) => {
+    return new Proxy(target, {
+      ownKeys(target) {
+        reportPath(path);
+
+        // $FlowFixMe
+        return Object.getOwnPropertyNames(target);
+      },
+      get(target, prop) {
+        // $FlowFixMe
+        const value = target[prop];
+        if (typeof value === 'object' && value != null && !Array.isArray(value)) {
+          return makeProxy(value, [...path, prop]);
+        }
+        reportPath([...path, prop]);
+        return value;
+      }
+    });
+  };
+
+  // $FlowFixMe
+  return makeProxy(config, []);
+}
 class PublicConfig {
   #config /*: Config */;
   #pkg /*: ?PackageJSON */;
@@ -127,32 +193,30 @@ class PublicConfig {
       });
       if (pkg && pkg.contents[packageKey]) {
         // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
         return {
           contents: pkg.contents[packageKey],
           filePath: pkg.filePath
         };
       }
     }
-    if ((0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation')) {
-      const configKey = options === null || options === void 0 ? void 0 : options.configKey;
-      if (configKey != null) {
-        for (let fileName of fileNames) {
-          let config = await this.getConfigFrom(searchPath, [fileName], {
-            exclude: true
+    const readTracking = options === null || options === void 0 ? void 0 : options.readTracking;
+    if (readTracking === true) {
+      for (let fileName of fileNames) {
+        const config = await this.getConfigFrom(searchPath, [fileName], {
+          exclude: true
+        });
+        if (config != null) {
+          return Promise.resolve({
+            contents: makeConfigProxy(keyPath => {
+              this.invalidateOnConfigKeyChange(config.filePath, keyPath);
+            }, config.contents),
+            filePath: config.filePath
           });
-          if (config && config.contents[configKey]) {
-            // Invalidate only when the package key changes
-            this.invalidateOnConfigKeyChange(config.filePath, configKey);
-            return {
-              contents: config.contents[configKey],
-              filePath: config.filePath
-            };
-          }
         }
-
-        // fall through so that file above invalidations are registered
       }
+
+      // fall through so that file above invalidations are registered
     }
 
     if (fileNames.length === 0) {
@@ -219,7 +283,9 @@ class PublicConfig {
     if (this.#pkg) {
       return this.#pkg;
     }
-    let pkgConfig = await this.getConfig(['package.json']);
+    let pkgConfig = await this.getConfig(['package.json'], {
+      readTracking: (0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation')
+    });
     if (!pkgConfig) {
       return null;
     }

package/lib/requests/ConfigRequest.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfigHash = getConfigHash;
 exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.getConfigRequests = getConfigRequests;
+exports.getValueAtPath = getValueAtPath;
 exports.loadPluginConfig = loadPluginConfig;
 exports.runConfigRequest = runConfigRequest;
 function _utils() {
@@ -86,19 +87,41 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
 const configKeyCache = (0, _buildCache().createBuildCache)();
 async function getConfigKeyContentHash(filePath, configKey, options) {
-  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${configKey}`;
+  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
   let cachedValue = configKeyCache.get(cacheKey);
   if (cachedValue) {
     return cachedValue;
   }
-  let conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
-  if (conf == null || conf.config[configKey] == null) {
+  const conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
+  const value = getValueAtPath(conf === null || conf === void 0 ? void 0 : conf.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
-  let contentHash = typeof conf.config[configKey] === 'object' ? (0, _utils().hashObject)(conf.config[configKey]) : (0, _rust().hashString)(JSON.stringify(conf.config[configKey]));
+  const contentHash = typeof value === 'object' ? (0, _utils().hashObject)(value) : (0, _rust().hashString)(JSON.stringify(value));
   configKeyCache.set(cacheKey, contentHash);
   return contentHash;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.57+6dd4ccb75",
+  "version": "2.16.2-canary.59+0b2f6f557",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -21,21 +21,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.125+6dd4ccb75",
-    "@atlaspack/cache": "3.1.1-canary.57+6dd4ccb75",
-    "@atlaspack/diagnostic": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/events": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/feature-flags": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/fs": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/graph": "3.4.1-canary.125+6dd4ccb75",
-    "@atlaspack/logger": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/package-manager": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/plugin": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/profiler": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/rust": "3.2.1-canary.57+6dd4ccb75",
-    "@atlaspack/types": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/utils": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/workers": "2.14.5-canary.57+6dd4ccb75",
+    "@atlaspack/build-cache": "2.13.3-canary.127+0b2f6f557",
+    "@atlaspack/cache": "3.1.1-canary.59+0b2f6f557",
+    "@atlaspack/diagnostic": "2.14.1-canary.127+0b2f6f557",
+    "@atlaspack/events": "2.14.1-canary.127+0b2f6f557",
+    "@atlaspack/feature-flags": "2.14.1-canary.127+0b2f6f557",
+    "@atlaspack/fs": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/graph": "3.4.1-canary.127+0b2f6f557",
+    "@atlaspack/logger": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/package-manager": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/plugin": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/profiler": "2.14.1-canary.127+0b2f6f557",
+    "@atlaspack/rust": "3.2.1-canary.59+0b2f6f557",
+    "@atlaspack/types": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/utils": "2.14.5-canary.59+0b2f6f557",
+    "@atlaspack/workers": "2.14.5-canary.59+0b2f6f557",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -71,5 +71,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "6dd4ccb753541de32322d881f973d571dd57e4ca"
+  "gitHead": "0b2f6f55794d3ff6e2f5a41f963e7e5dd8ad9f8d"
 }

package/src/EnvironmentManager.js

@@ -4,8 +4,16 @@
  * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
  */
 import type {Environment as CoreEnvironment} from './types';
-import {addEnvironment, getEnvironment} from '@atlaspack/rust';
+import {type Cache} from '@atlaspack/cache';
+import {
+  addEnvironment,
+  getEnvironment,
+  getAllEnvironments,
+  setAllEnvironments,
+} from '@atlaspack/rust';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {instrument} from '@atlaspack/logger';
+import {ATLASPACK_VERSION} from './constants';
 
 const localEnvironmentCache = new Map<string, CoreEnvironment>();
 
@@ -74,3 +82,64 @@ export function fromEnvironmentId(id: EnvironmentRef): CoreEnvironment {
   localEnvironmentCache.set(id, env);
   return env;
 }
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export async function writeEnvironmentsToCache(cache: Cache): Promise<void> {
+  const environments = getAllEnvironments();
+  const environmentIds = new Set<string>();
+
+  // Store each environment individually
+  for (const env of environments) {
+    environmentIds.add(env.id);
+    const envKey = `Environment/${ATLASPACK_VERSION}/${env.id}`;
+
+    await instrument(
+      `RequestTracker::writeToCache::cache.put(${envKey})`,
+      async () => {
+        await cache.set(envKey, env);
+      },
+    );
+  }
+
+  // Store the list of environment IDs
+  await instrument(
+    `RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${ATLASPACK_VERSION}`})`,
+    async () => {
+      await cache.set(
+        `EnvironmentManager/${ATLASPACK_VERSION}`,
+        Array.from(environmentIds),
+      );
+    },
+  );
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export async function loadEnvironmentsFromCache(cache: Cache): Promise<void> {
+  const cachedEnvIds = await cache.get(
+    `EnvironmentManager/${ATLASPACK_VERSION}`,
+  );
+
+  if (cachedEnvIds == null) {
+    return;
+  }
+
+  const environments = [];
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    setAllEnvironments(environments);
+  }
+}

package/src/InternalConfig.js

@@ -24,7 +24,7 @@ type ConfigOpts = {|
   invalidateOnFileChange?: Set<ProjectPath>,
   invalidateOnConfigKeyChange?: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange?: Set<string>,

package/src/RequestTracker.js

@@ -30,15 +30,15 @@ import nullthrows from 'nullthrows';
 
 import {
   ATLASPACK_VERSION,
-  VALID,
-  INITIAL_BUILD,
   FILE_CREATE,
-  FILE_UPDATE,
   FILE_DELETE,
+  FILE_UPDATE,
   ENV_CHANGE,
+  ERROR,
+  INITIAL_BUILD,
   OPTION_CHANGE,
   STARTUP,
-  ERROR,
+  VALID,
 } from './constants';
 import type {AtlaspackV3} from './atlaspack-v3/AtlaspackV3';
 import {
@@ -71,6 +71,11 @@ import type {
 import {BuildAbortError, assertSignalNotAborted, hashFromOption} from './utils';
 import {performance} from 'perf_hooks';
 
+import {
+  loadEnvironmentsFromCache,
+  writeEnvironmentsToCache,
+} from './EnvironmentManager';
+
 export const requestGraphEdgeTypes = {
   subrequest: 2,
   invalidated_by_update: 3,
@@ -144,7 +149,7 @@ type OptionNode = {|
 type ConfigKeyNode = {|
   id: ContentKey,
   +type: typeof CONFIG_KEY,
-  configKey: string,
+  configKey: string[],
   contentHash: string,
 |};
 
@@ -216,7 +221,7 @@ export type RunAPI<TResult: RequestResult> = {|
   invalidateOnFileUpdate: (ProjectPath) => void,
   invalidateOnConfigKeyChange: (
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) => void,
   invalidateOnStartup: () => void,
@@ -283,10 +288,12 @@ const nodeFromOption = (option: string, value: mixed): RequestGraphNode => ({
 
 const nodeFromConfigKey = (
   fileName: ProjectPath,
-  configKey: string,
+  configKey: string[],
   contentHash: string,
 ): RequestGraphNode => ({
-  id: `config_key:${fromProjectPathRelative(fileName)}:${configKey}`,
+  id: `config_key:${fromProjectPathRelative(fileName)}:${JSON.stringify(
+    configKey,
+  )}`,
   type: CONFIG_KEY,
   configKey,
   contentHash,
@@ -527,7 +534,7 @@ export class RequestGraph extends ContentGraph<
   invalidateOnConfigKeyChange(
     requestNodeId: NodeId,
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) {
     let configKeyNodeId = this.addNode(
@@ -1109,11 +1116,22 @@ export class RequestGraph extends ContentGraph<
       }
 
       let configKeyNodes = this.configKeyNodes.get(_filePath);
-      if (configKeyNodes && (type === 'delete' || type === 'update')) {
+
+      // With granular invalidations we will always run this block,
+      // so even if we get a create event (for whatever reason), we will still
+      // try to limit invalidations from config key changes through hashing.
+      //
+      // Currently create events can invalidate a large number of nodes due to
+      // "create above" invalidations.
+      const isConfigKeyChange =
+        getFeatureFlag('granularTsConfigInvalidation') ||
+        type === 'delete' ||
+        type === 'update';
+      if (configKeyNodes && isConfigKeyChange) {
         for (let nodeId of configKeyNodes) {
           let isInvalid = type === 'delete';
 
-          if (type === 'update') {
+          if (type !== 'delete') {
             let node = this.getNode(nodeId);
             invariant(node && node.type === CONFIG_KEY);
 
@@ -1559,6 +1577,10 @@ export default class RequestTracker {
         size: this.graph.nodes.length,
       });
 
+      if (getFeatureFlag('environmentDeduplication')) {
+        await writeEnvironmentsToCache(options.cache);
+      }
+
       let serialisedGraph = this.graph.serialize();
 
       // Delete an existing request graph cache, to prevent invalid states
@@ -1843,6 +1865,10 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     },
   });
 
+  if (getFeatureFlag('environmentDeduplication')) {
+    await loadEnvironmentsFromCache(options.cache);
+  }
+
   const hasRequestGraphInCache = getFeatureFlag('cachePerformanceImprovements')
     ? await options.cache.has(requestGraphKey)
     : await options.cache.hasLargeBlob(requestGraphKey);

package/src/atlaspack-v3/worker/compat/plugin-config.js

@@ -107,7 +107,7 @@ export class PluginConfig implements IPluginConfig {
           exclude?: boolean,
         |}
       | {|
-          configKey?: string,
+          readTracking?: boolean,
         |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.#inner.getConfigFrom(searchPath, filePaths, options);