@atlaspack/core 2.14.1-dev.144 → 2.14.1-dev.146

package/lib/requests/WriteBundleRequest.js

@@ -61,6 +61,14 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("../EnvironmentManager");
 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; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -114,7 +122,8 @@ async function run({
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete((0, _projectPath.toProjectPath)(options.projectRoot, fullPath + '.map'));
   }
   let dir = _path().default.dirname(fullPath);
@@ -145,11 +154,14 @@ async function run({
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && (await options.cache.has(mapKey))) {
-    await writeFiles((0, _utils().blobToStream)(await options.cache.getBlob(mapKey)), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+  const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+    await writeFiles((0, _utils().blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,

package/lib/requests/WriteBundlesRequest.js

@@ -76,6 +76,7 @@ async function run({
       let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
       res.set(bundle.id, {
         filePath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, name),
+        bundleId: bundle.id,
         type: bundle.type,
         // FIXME: this is wrong if the packager changes the type...
         stats: {

package/lib/resolveOptions.js

@@ -145,13 +145,12 @@ async function resolveOptions(initialOptions) {
       return initialOptions.cache;
     }
     const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-      return new (_cache().FSCache)(outputFS, cacheDir);
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+        return new (_cache().FSCache)(outputFS, cacheDir);
+      }
     }
-    if (needsRustLmdbCache || (0, _featureFlags().getFeatureFlag)('useLmdbJsLite')) {
-      return new (_cache().LMDBLiteCache)(cacheDir);
-    }
-    return new (_cache().LMDBCache)(cacheDir);
+    return new (_cache().LMDBLiteCache)(cacheDir);
   }();
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.14.1-dev.144+ea7d58b70",
+  "version": "2.14.1-dev.146+33cba81e9",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -10,6 +10,7 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
+  "types": "index.d.ts",
   "source": "src/index.js",
   "engines": {
     "node": ">= 16.0.0"
@@ -20,21 +21,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-dev.144+ea7d58b70",
-    "@atlaspack/cache": "2.13.3-dev.144+ea7d58b70",
-    "@atlaspack/diagnostic": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/events": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/feature-flags": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/fs": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/graph": "3.4.1-dev.144+ea7d58b70",
-    "@atlaspack/logger": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/package-manager": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/plugin": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/profiler": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/rust": "3.0.1-dev.144+ea7d58b70",
-    "@atlaspack/types": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/utils": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/workers": "2.14.1-dev.144+ea7d58b70",
+    "@atlaspack/build-cache": "2.13.3-dev.146+33cba81e9",
+    "@atlaspack/cache": "2.13.3-dev.146+33cba81e9",
+    "@atlaspack/diagnostic": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/events": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/feature-flags": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/fs": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/graph": "3.4.1-dev.146+33cba81e9",
+    "@atlaspack/logger": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/package-manager": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/plugin": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/profiler": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/rust": "3.0.1-dev.146+33cba81e9",
+    "@atlaspack/types": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/utils": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/workers": "2.14.1-dev.146+33cba81e9",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,7 +58,10 @@
   },
   "exports": {
     "./*": "./*",
-    ".": "./lib/index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./worker": {
       "@atlaspack::sources": "./src/worker.js",
       "default": "./lib/worker.js"
@@ -70,5 +74,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "ea7d58b70fbe4bbc6324d4053ac673ea307b7bf6"
+  "gitHead": "33cba81e98b6eb098014f5a19d7932821b95f075"
 }

package/src/AssetGraph.js

@@ -29,6 +29,8 @@ import nullthrows from 'nullthrows';
 import {ContentGraph} from '@atlaspack/graph';
 import {createDependency} from './Dependency';
 import {type ProjectPath, fromProjectPathRelative} from './projectPath';
+import {fromEnvironmentId, toEnvironmentId} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type InitOpts = {|
   entries?: Array<ProjectPath>,
@@ -65,7 +67,7 @@ export function nodeFromAssetGroup(assetGroup: AssetGroup): AssetGroupNode {
   return {
     id: hashString(
       fromProjectPathRelative(assetGroup.filePath) +
-        assetGroup.env.id +
+        toEnvironmentId(assetGroup.env) +
         String(assetGroup.isSource) +
         String(assetGroup.sideEffects) +
         (assetGroup.code ?? '') +
@@ -149,14 +151,18 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input: Asset | Dependency | AssetGroup) {
-    let {id, context} = input.env;
+    if (getFeatureFlag('environmentDeduplication')) {
+      return;
+    }
+
+    let {id, context} = fromEnvironmentId(input.env);
     let idAndContext = `${id}-${context}`;
 
     let env = this.envCache.get(idAndContext);
     if (env) {
       input.env = env;
     } else {
-      this.envCache.set(idAndContext, input.env);
+      this.envCache.set(idAndContext, fromEnvironmentId(input.env));
     }
   }
 
@@ -235,13 +241,13 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
           env: target.env,
           isEntry: true,
           needsStableName: true,
-          symbols: target.env.isLibrary
+          symbols: fromEnvironmentId(target.env).isLibrary
             ? new Map([['*', {local: '*', isWeak: true, loc: null}]])
             : undefined,
         }),
       );
 
-      if (node.value.env.isLibrary) {
+      if (fromEnvironmentId(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -428,7 +434,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
       let depIsDeferrable =
         d.symbols &&
-        !(d.env.isLibrary && d.isEntry) &&
+        !(fromEnvironmentId(d.env).isLibrary && d.isEntry) &&
         !d.symbols.has('*') &&
         ![...d.symbols.keys()].some((symbol) => {
           let assetSymbol = resolvedAsset.symbols?.get(symbol)?.local;

package/src/Atlaspack.js

@@ -58,11 +58,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {
-  getFeatureFlag,
-  setFeatureFlags,
-  DEFAULT_FEATURE_FLAGS,
-} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
@@ -125,9 +121,7 @@ export default class Atlaspack {
     };
     setFeatureFlags(featureFlags);
 
-    if (getFeatureFlag('enableRustWorkerThreadDylibHack')) {
-      loadRustWorkerThreadDylibHack();
-    }
+    loadRustWorkerThreadDylibHack();
 
     await initSourcemaps;
     await initRust?.();
@@ -174,9 +168,16 @@ export default class Atlaspack {
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
 
+      let threads = undefined;
+      if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+        threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+      } else if (process.env.NODE_ENV === 'test') {
+        threads = 2;
+      }
+
       rustAtlaspack = await AtlaspackV3.create({
         ...options,
-        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        threads,
         entries: Array.isArray(entries)
           ? entries
           : entries == null
@@ -534,10 +535,11 @@ export default class Atlaspack {
           nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
         }
 
-        let isInvalid = await this.#requestTracker.respondToFSEvents(
-          events,
-          Number.POSITIVE_INFINITY,
-        );
+        let {didInvalidate: isInvalid} =
+          await this.#requestTracker.respondToFSEvents(
+            events,
+            Number.POSITIVE_INFINITY,
+          );
 
         if (
           (nativeInvalid || isInvalid) &&
@@ -647,6 +649,20 @@ export default class Atlaspack {
     return result;
   }
 
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache(): Promise<void> {
+    await this._init();
+
+    const cache = nullthrows(this.#resolvedOptions).cache;
+    if (cache instanceof LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/BundleGraph.js

@@ -24,7 +24,6 @@ import type {
   BundleNode,
   Dependency,
   DependencyNode,
-  Environment,
   InternalSourceLocation,
   Target,
   Condition,
@@ -49,6 +48,8 @@ import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -283,7 +284,7 @@ export default class BundleGraph {
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
-        node.value.env.shouldScopeHoist &&
+        fromEnvironmentId(node.value.env).shouldScopeHoist &&
         // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
         isProduction
       ) {
@@ -555,11 +556,11 @@ export default class BundleGraph {
           +needsStableName?: ?boolean,
           +bundleBehavior?: ?IBundleBehavior,
           +shouldContentHash: boolean,
-          +env: Environment,
+          +env: EnvironmentRef,
         |}
       | {|
           +type: string,
-          +env: Environment,
+          +env: EnvironmentRef,
           +uniqueKey: string,
           +target: Target,
           +needsStableName?: ?boolean,
@@ -1366,7 +1367,8 @@ export default class BundleGraph {
 
         if (
           descendant.type !== bundle.type ||
-          descendant.env.context !== bundle.env.context
+          fromEnvironmentId(descendant.env).context !==
+            fromEnvironmentId(bundle.env).context
         ) {
           actions.skipChildren();
           return;
@@ -1407,7 +1409,7 @@ export default class BundleGraph {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
     if (
-      ISOLATED_ENVS.has(bundle.env.context) ||
+      ISOLATED_ENVS.has(fromEnvironmentId(bundle.env).context) ||
       !bundle.isSplittable ||
       bundle.bundleBehavior === BundleBehavior.isolated ||
       bundle.bundleBehavior === BundleBehavior.inline
@@ -1461,7 +1463,8 @@ export default class BundleGraph {
               node.type === 'root' ||
               (node.type === 'bundle' &&
                 (node.value.id === bundle.id ||
-                  node.value.env.context !== bundle.env.context))
+                  fromEnvironmentId(node.value.env).context !==
+                    fromEnvironmentId(bundle.env).context))
             ) {
               isReachable = false;
               actions.stop();
@@ -2135,7 +2138,9 @@ export default class BundleGraph {
       hash.writeString(referencedBundle.id);
     }
 
-    hash.writeString(JSON.stringify(objectSortedEntriesDeep(bundle.env)));
+    hash.writeString(
+      JSON.stringify(objectSortedEntriesDeep(fromEnvironmentId(bundle.env))),
+    );
     return hash.finish();
   }
 

package/src/Dependency.js

@@ -8,7 +8,7 @@ import type {
   BundleBehavior as IBundleBehavior,
   SemverRange,
 } from '@atlaspack/types';
-import type {Dependency, Environment, Target} from './types';
+import type {Dependency, Target} from './types';
 import {createDependencyId as createDependencyIdRust} from '@atlaspack/rust';
 import {
   SpecifierType,
@@ -21,6 +21,8 @@ import {toInternalSourceLocation} from './utils';
 import {toProjectPath} from './projectPath';
 import assert from 'assert';
 import {identifierRegistry} from './IdentifierRegistry';
+import {fromEnvironmentId, toEnvironmentId} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 type DependencyOpts = {|
   id?: string,
@@ -34,7 +36,7 @@ type DependencyOpts = {|
   isEntry?: boolean,
   isOptional?: boolean,
   loc?: SourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: Array<string>,
   meta?: Meta,
   resolveFrom?: FilePath,
@@ -60,7 +62,7 @@ export function createDependencyId({
 }: {|
   sourceAssetId?: string | void,
   specifier: DependencySpecifier,
-  env: Environment,
+  env: EnvironmentRef,
   target?: Target | void,
   pipeline?: ?string,
   specifierType: $Keys<typeof SpecifierType>,
@@ -73,8 +75,14 @@ export function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: toEnvironmentId(env),
+    target:
+      target != null
+        ? {
+            ...target,
+            env: fromEnvironmentId(target.env),
+          }
+        : null,
     pipeline,
     specifierType: SpecifierType[specifierType],
     bundleBehavior,

package/src/Environment.js

@@ -10,6 +10,8 @@ import {toInternalSourceLocation} from './utils';
 import PublicEnvironment from './public/Environment';
 import {environmentToInternalEnvironment} from './public/Environment';
 import {identifierRegistry} from './IdentifierRegistry';
+import {toEnvironmentRef} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 const DEFAULT_ENGINES = {
   browsers: ['> 0.25%'],
@@ -35,7 +37,7 @@ export function createEnvironment({
   loc,
 }: EnvironmentOpts = {
   /*::...null*/
-}): Environment {
+}): EnvironmentRef {
   if (context == null) {
     if (engines?.node) {
       context = 'node';
@@ -112,21 +114,22 @@ export function createEnvironment({
   };
 
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+
+  return toEnvironmentRef(Object.freeze(res));
 }
 
 export function mergeEnvironments(
   projectRoot: FilePath,
   a: Environment,
   b: ?(EnvironmentOptions | IEnvironment),
-): Environment {
+): EnvironmentRef {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return toEnvironmentRef(a);
   }
 
   if (b instanceof PublicEnvironment) {
-    return environmentToInternalEnvironment(b);
+    return toEnvironmentRef(environmentToInternalEnvironment(b));
   }
 
   // $FlowFixMe - ignore the `id` that is already on a

package/src/EnvironmentManager.js

@@ -0,0 +1,145 @@
+// @flow strict-local
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+import type {Environment as CoreEnvironment} from './types';
+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>();
+
+export opaque type EnvironmentId = string;
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+export type EnvironmentRef = EnvironmentId | CoreEnvironment;
+
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+export function toEnvironmentRef(env: CoreEnvironment): EnvironmentRef {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    return env;
+  }
+
+  const id = toEnvironmentId(env);
+  return id;
+}
+
+/**
+ * Convert environment to a string ID
+ */
+export function toEnvironmentId(
+  /**
+   * Redundant type during roll-out
+   */
+  env: CoreEnvironment | EnvironmentRef,
+): string {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    return typeof env === 'string' ? env : env.id;
+  }
+
+  if (typeof env === 'string') {
+    return env;
+  }
+
+  addEnvironment(env);
+  return env.id;
+}
+
+export function fromEnvironmentId(id: EnvironmentRef): CoreEnvironment {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    if (typeof id === 'string') {
+      throw new Error(
+        'This should never happen when environmentDeduplication feature-flag is off',
+      );
+    } else {
+      return id;
+    }
+  }
+
+  if (typeof id !== 'string') {
+    return id;
+  }
+
+  const localEnv = localEnvironmentCache.get(id);
+
+  if (localEnv) {
+    return localEnv;
+  }
+
+  const env = Object.freeze(getEnvironment(id));
+  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

@@ -3,7 +3,6 @@
 import type {PackageName, ConfigResult} from '@atlaspack/types';
 import type {
   Config,
-  Environment,
   InternalFileCreateInvalidation,
   InternalDevDepOptions,
 } from './types';
@@ -13,17 +12,19 @@ import {fromProjectPathRelative} from './projectPath';
 import {createEnvironment} from './Environment';
 import {hashString} from '@atlaspack/rust';
 import {identifierRegistry} from './IdentifierRegistry';
+import type {EnvironmentRef} from './EnvironmentManager';
+import {toEnvironmentId} from './EnvironmentManager';
 
 type ConfigOpts = {|
   plugin: PackageName,
   searchPath: ProjectPath,
   isSource?: boolean,
-  env?: Environment,
+  env?: EnvironmentRef,
   result?: ConfigResult,
   invalidateOnFileChange?: Set<ProjectPath>,
   invalidateOnConfigKeyChange?: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange?: Set<string>,
@@ -52,13 +53,13 @@ export function createConfig({
   const configId = hashString(
     plugin +
       fromProjectPathRelative(searchPath) +
-      environment.id +
+      toEnvironmentId(environment) +
       String(isSource),
   );
   identifierRegistry.addIdentifier('config_request', configId, {
     plugin,
     searchPath,
-    environmentId: environment.id,
+    environmentId: toEnvironmentId(environment),
     isSource,
   });
   return {