@atlaspack/core 2.14.1-canary.7 → 2.14.1-dev.107

package/lib/Atlaspack.js

@@ -118,6 +118,8 @@ function _featureFlags() {
 var _atlaspackV = require("./atlaspack-v3");
 var _AssetGraphRequest = _interopRequireDefault(require("./requests/AssetGraphRequest"));
 var _AssetGraphRequestRust = require("./requests/AssetGraphRequestRust");
+var _rustWorkerThreadDylibHack = require("./rustWorkerThreadDylibHack");
+var _isSuperPackage = require("./isSuperPackage");
 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 }; }
@@ -125,7 +127,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 const INTERNAL_TRANSFORM = exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
 const INTERNAL_RESOLVE = exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
-const WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+const WORKER_PATH = exports.WORKER_PATH = _path().default.join( /*#__ATLASPACK_IGNORE__*/__dirname, 'worker.js');
 class Atlaspack {
   #requestTracker /*: RequestTracker*/;
   #config /*: AtlaspackConfig*/;
@@ -165,6 +167,9 @@ class Atlaspack {
       ...this.#initialOptions.featureFlags
     };
     (0, _featureFlags().setFeatureFlags)(featureFlags);
+    if ((0, _featureFlags().getFeatureFlag)('enableRustWorkerThreadDylibHack')) {
+      (0, _rustWorkerThreadDylibHack.loadRustWorkerThreadDylibHack)();
+    }
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     this.#disposable = new (_events().Disposable)();
@@ -207,14 +212,15 @@ class Atlaspack {
       await lmdb.put('current_session_version', Buffer.from(version));
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
-        corePath: _path().default.join(__dirname, '..'),
+        corePath: _path().default.join( /*#__ATLASPACK_IGNORE__*/__dirname, '..'),
         threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
         fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
         // $FlowFixMe ProjectPath is a string
         defaultTargetOptions: resolvedOptions.defaultTargetOptions,
-        lmdb
+        lmdb,
+        isSuperPackage: (0, _isSuperPackage.isSuperPackage)()
       });
     }
     this.rustAtlaspack = rustAtlaspack;

package/lib/BundleGraph.js

@@ -832,7 +832,10 @@ class BundleGraph {
       // If this asset is referenced by any async dependency, it's referenced.
       return true;
     }
-    let dependencies = this._graph.getNodeIdsConnectedTo(assetNodeId).map(id => (0, _nullthrows().default)(this._graph.getNode(id))).filter(node => node.type === 'dependency').map(node => {
+    let dependencies = this._graph.getNodeIdsConnectedTo(assetNodeId,
+    // TODO: This seems like bug with library builds when assets are present
+    // in other files. Guarding the fix for now exclusively for super builds
+    process.env.ATLASPACK_SUPER_BUILD === 'true' ? _graph().ALL_EDGE_TYPES : undefined).map(id => (0, _nullthrows().default)(this._graph.getNode(id))).filter(node => node.type === 'dependency').map(node => {
       (0, _assert().default)(node.type === 'dependency');
       return node.value;
     });

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -33,7 +33,7 @@ function _rust() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, 'worker', 'index.js');
+const WORKER_PATH = _path().default.join( /*#__ATLASPACK_IGNORE__*/__dirname, 'worker', 'napi-worker.js');
 const ATLASPACK_NAPI_WORKERS = _process().default.env.ATLASPACK_NAPI_WORKERS && parseInt(_process().default.env.ATLASPACK_NAPI_WORKERS, 10);
 class NapiWorkerPool {
   #workers;

package/lib/atlaspack-v3/worker/worker.js

@@ -48,6 +48,7 @@ function _module() {
 }
 var _jsCallable = require("../jsCallable");
 var _compat = require("./compat");
+var _internalPlugins = _interopRequireDefault(require("../../internal-plugins"));
 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 }; }
@@ -66,10 +67,16 @@ class AtlaspackWorker {
     specifier,
     resolveFrom
   }) => {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    let resolvedModule = await import(resolvedPath);
+    let resolvedModule;
+    if (_internalPlugins.default && _internalPlugins.default[specifier]) {
+      // If the plugin is available inside the package then use it
+      resolvedModule = _internalPlugins.default[specifier]();
+    } else {
+      let customRequire = _module().createRequire(resolveFrom);
+      let resolvedPath = customRequire.resolve(specifier);
+      // $FlowFixMe
+      resolvedModule = await import(resolvedPath);
+    }
     let instance = undefined;
     if (resolvedModule.default && resolvedModule.default[CONFIG]) {
       instance = resolvedModule.default[CONFIG];

package/lib/index.js

@@ -9,7 +9,8 @@ var _exportNames = {
   BuildError: true,
   createWorkerFarm: true,
   INTERNAL_RESOLVE: true,
-  INTERNAL_TRANSFORM: true
+  INTERNAL_TRANSFORM: true,
+  isSuperPackage: true
 };
 Object.defineProperty(exports, "Atlaspack", {
   enumerable: true,
@@ -53,7 +54,14 @@ Object.defineProperty(exports, "default", {
     return _Atlaspack.default;
   }
 });
+Object.defineProperty(exports, "isSuperPackage", {
+  enumerable: true,
+  get: function () {
+    return _isSuperPackage.isSuperPackage;
+  }
+});
 var _Atlaspack = _interopRequireWildcard(require("./Atlaspack"));
+var _isSuperPackage = require("./isSuperPackage");
 var _atlaspackV = require("./atlaspack-v3");
 Object.keys(_atlaspackV).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/internal-plugins.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// This file is overridden in super package builds
+// $FlowFixMe
+var _default = exports.default = {};

package/lib/isSuperPackage.js

@@ -0,0 +1,23 @@
+"use strict";
+
+let fs = require('fs');
+let {
+  findAncestorFile
+} = require('@atlaspack/rust');
+let dirname = /*#__ATLASPACK_IGNORE__*/__dirname;
+function isSuperPackage() {
+  if (!dirname) {
+    return false;
+  }
+  let packageJson = JSON.parse(
+  // $FlowFixMe
+  fs.readFileSync(findAncestorFile(['package.json'], dirname, '/'), 'utf8'));
+  return packageJson.name === '@atlaspack/super';
+}
+let result;
+module.exports.isSuperPackage = () => {
+  if (result == null) {
+    result = isSuperPackage();
+  }
+  return result;
+};

package/lib/loadAtlaspackPlugin.js

@@ -25,6 +25,8 @@ function _diagnostic() {
   };
   return data;
 }
+var _package = require("../package.json");
+var _internalPlugins = _interopRequireDefault(require("./internal-plugins"));
 function _utils() {
   const data = require("@atlaspack/utils");
   _utils = function () {
@@ -33,13 +35,25 @@ function _utils() {
   return data;
 }
 var _projectPath = require("./projectPath");
-var _package = require("../package.json");
 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 }; }
 const NODE_MODULES = `${_path().default.sep}node_modules${_path().default.sep}`;
 const CONFIG = Symbol.for('parcel-plugin-config');
 async function loadPlugin(pluginName, configPath, keyPath, options) {
+  if (_internalPlugins.default && _internalPlugins.default[pluginName]) {
+    let plugin = _internalPlugins.default[pluginName]();
+    plugin = plugin.default || plugin;
+    plugin = plugin[CONFIG];
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not a valid Atlaspack plugin, should export an instance of a Atlaspack plugin ex. "export default new Reporter({ ... })".`);
+    }
+    return {
+      plugin,
+      version: _package.version,
+      resolveFrom: (0, _projectPath.toProjectPathUnsafe)(options.projectRoot)
+    };
+  }
   let resolveFrom = configPath;
 
   // Config packages can reference plugins, but cannot contain other plugins within them.
@@ -62,10 +76,9 @@ async function loadPlugin(pluginName, configPath, keyPath, options) {
       }
     });
   }
-  let resolved, pkg;
+  let pkg;
   try {
     ({
-      resolved,
       pkg
     } = await options.packageManager.resolve(pluginName, resolveFrom, {
       shouldAutoInstall: options.shouldAutoInstall
@@ -93,9 +106,6 @@ async function loadPlugin(pluginName, configPath, keyPath, options) {
       }
     });
   }
-
-  // Remove plugin version compatiblility validation in canary builds as they don't use semver
-
   let plugin = await options.packageManager.require(pluginName, resolveFrom, {
     shouldAutoInstall: options.shouldAutoInstall
   });

package/lib/public/BundleGraph.js

@@ -262,12 +262,13 @@ class BundleGraph {
         ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
       }
       for (let bundle of bundles) {
-        const conditions = bundleConditions.get(bundle) ?? new Map();
+        const conditions = bundleConditions.get(bundle.id) ?? new Map();
         conditions.set(cond.key, {
+          bundle,
           ifTrueBundles,
           ifFalseBundles
         });
-        bundleConditions.set(bundle, conditions);
+        bundleConditions.set(bundle.id, conditions);
       }
     }
     return bundleConditions;

package/lib/requests/AtlaspackConfigRequest.js

@@ -40,7 +40,7 @@ function _diagnostic() {
   return data;
 }
 function _json() {
-  const data = require("json5");
+  const data = _interopRequireDefault(require("json5"));
   _json = function () {
     return data;
   };
@@ -60,11 +60,13 @@ function _assert() {
   };
   return data;
 }
+var _internalPlugins = _interopRequireDefault(require("../internal-plugins"));
 var _AtlaspackConfig = require("../AtlaspackConfig");
 var _AtlaspackConfig2 = _interopRequireDefault(require("../AtlaspackConfig.schema"));
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
 var _utils2 = require("../utils");
+var _isSuperPackage = require("../isSuperPackage");
 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; }
@@ -134,28 +136,38 @@ async function resolveAtlaspackConfig(options) {
   let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
   let configPath = options.config != null ? (await options.packageManager.resolve(options.config, resolveFrom)).resolved : await (0, _utils().resolveConfig)(options.inputFS, resolveFrom, ['.parcelrc'], options.projectRoot);
   let usedDefault = false;
-  if (configPath == null && options.defaultConfig != null) {
+  let config, extendedFiles;
+  if (configPath == null && options.defaultConfig != null && (0, _isSuperPackage.isSuperPackage)() && options.defaultConfig.endsWith('.js')) {
     usedDefault = true;
-    configPath = (await options.packageManager.resolve(options.defaultConfig, resolveFrom)).resolved;
-  }
-  if (configPath == null) {
-    return null;
-  }
-  let contents;
-  try {
-    contents = await options.inputFS.readFile(configPath, 'utf8');
-  } catch (e) {
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: (0, _diagnostic().md)`Could not find parcel config at ${_path().default.relative(options.projectRoot, configPath)}`,
-        origin: '@atlaspack/core'
-      }
-    });
+    // Load the super package default config
+    let result = await processConfigChain(_internalPlugins.default['@atlaspack/config-default'](),
+    // $FlowFixMe
+    options.defaultConfig, options);
+    config = result.config;
+    extendedFiles = result.extendedFiles;
+  } else {
+    if (configPath == null && options.defaultConfig != null) {
+      usedDefault = true;
+      configPath = (await options.packageManager.resolve(options.defaultConfig, resolveFrom)).resolved;
+    }
+    if (configPath == null) {
+      return null;
+    }
+    let contents;
+    try {
+      contents = await options.inputFS.readFile(configPath, 'utf8');
+    } catch (e) {
+      throw new (_diagnostic().default)({
+        diagnostic: {
+          message: (0, _diagnostic().md)`Could not find parcel config at ${_path().default.relative(options.projectRoot, configPath)}`,
+          origin: '@atlaspack/core'
+        }
+      });
+    }
+    let result = await parseAndProcessConfig(configPath, contents, options);
+    config = result.config;
+    extendedFiles = result.extendedFiles;
   }
-  let {
-    config,
-    extendedFiles
-  } = await parseAndProcessConfig(configPath, contents, options);
   if (options.additionalReporters.length > 0) {
     config.reporters = [...options.additionalReporters.map(({
       packageName,
@@ -179,7 +191,7 @@ function create(config, options) {
 async function parseAndProcessConfig(configPath, contents, options) {
   let config;
   try {
-    config = (0, _json().parse)(contents);
+    config = _json().default.parse(contents);
   } catch (e) {
     let pos = {
       line: e.lineNumber,
@@ -304,13 +316,16 @@ async function processConfigChain(configFile, filePath, options) {
       for (let ext of exts) {
         try {
           let key = Array.isArray(configFile.extends) ? `/extends/${i}` : '/extends';
-          let resolved = await resolveExtends(ext, filePath, key, options);
-          extendedFiles.push(resolved);
-          let {
-            extendedFiles: moreExtendedFiles,
-            config: nextConfig
-          } = await processExtendedConfig(filePath, key, ext, resolved, options);
-          extendedFiles = extendedFiles.concat(moreExtendedFiles);
+          let nextConfig;
+          if (_internalPlugins.default[ext]) {
+            nextConfig = (await processConfigChain(_internalPlugins.default[ext](), /*#__ATLASPACK_IGNORE__*/__dirname, options)).config;
+          } else {
+            let resolved = await resolveExtends(ext, filePath, key, options);
+            extendedFiles.push(resolved);
+            let result = await processExtendedConfig(filePath, key, ext, resolved, options);
+            extendedFiles = extendedFiles.concat(result.extendedFiles);
+            nextConfig = result.config;
+          }
           extStartConfig = extStartConfig ? mergeConfigs(extStartConfig, nextConfig) : nextConfig;
         } catch (err) {
           errors.push(err);

package/lib/resolveOptions.js

@@ -139,8 +139,19 @@ async function resolveOptions(initialOptions) {
   // where symlinked dependencies outside the project root need to trigger HMR
   // updates. Default to the project root if not provided.
   let watchDir = initialOptions.watchDir != null ? _path().default.resolve(initialOptions.watchDir) : projectRoot;
-  const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('useLmdbJsLite') || (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-  let cache = needsRustLmdbCache ? new (_cache().LMDBLiteCache)(cacheDir) : outputFS instanceof _fs().NodeFS ? new (_cache().LMDBCache)(cacheDir) : new (_cache().FSCache)(outputFS, cacheDir);
+  let cache = function createCache() {
+    if (initialOptions.cache) {
+      return initialOptions.cache;
+    }
+    const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
+    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);
+  }();
   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';
   let publicUrl = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau2 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau2 === void 0 ? void 0 : _initialOptions$defau2.publicUrl) ?? '/';

package/lib/rustWorkerThreadDylibHack.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadRustWorkerThreadDylibHack = loadRustWorkerThreadDylibHack;
+/**
+ * This is a workaround for https://github.com/rust-lang/rust/issues/91979
+ * when running atlaspack with parcel bindings, it is possible that the parcel
+ * dylib will be loaded from a node worker thread, which causes a crash on exit.
+ *
+ * This is a workaround to ensure that the parcel dylib is loaded in the main
+ * thread, which fixes the crash.
+ */
+function loadRustWorkerThreadDylibHack() {
+  try {
+    // $FlowFixMe
+    require('@parcel/rust'); // eslint-disable-line
+  } catch (err) {
+    /* ignore */
+  }
+}

package/lib/worker.js

@@ -78,15 +78,15 @@ require("@atlaspack/package-manager");
 require("@atlaspack/fs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // register with serializer
+// Repl builds are currently not enabled
 // $FlowFixMe
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  // $FlowFixMe
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
-
+// if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
+//   /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
+//   require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
+//   // $FlowFixMe
+//   require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
+//   /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
+// }
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 
 // Remove the workerApi type from the TransformationOpts and ValidationOpts types:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.14.1-canary.7+6ec11f10a",
+  "version": "2.14.1-dev.107+4f5d524fd",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.7+6ec11f10a",
-    "@atlaspack/cache": "2.13.3-canary.7+6ec11f10a",
-    "@atlaspack/diagnostic": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/events": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/feature-flags": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/fs": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/graph": "3.4.1-canary.7+6ec11f10a",
-    "@atlaspack/logger": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/package-manager": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/plugin": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/profiler": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/rust": "3.0.1-canary.7+6ec11f10a",
-    "@atlaspack/types": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/utils": "2.14.1-canary.7+6ec11f10a",
-    "@atlaspack/workers": "2.14.1-canary.7+6ec11f10a",
+    "@atlaspack/build-cache": "2.13.3-dev.107+4f5d524fd",
+    "@atlaspack/cache": "2.13.3-dev.107+4f5d524fd",
+    "@atlaspack/diagnostic": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/events": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/feature-flags": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/fs": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/graph": "3.4.1-dev.107+4f5d524fd",
+    "@atlaspack/logger": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/package-manager": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/plugin": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/profiler": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/rust": "3.0.1-dev.107+4f5d524fd",
+    "@atlaspack/types": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/utils": "2.14.1-dev.107+4f5d524fd",
+    "@atlaspack/workers": "2.14.1-dev.107+4f5d524fd",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -67,5 +67,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "6ec11f10a9366fb8a9fc0475c7678235056bd80e"
+  "gitHead": "4f5d524fdb28f9955f3a26abe0115d7545eb41f4"
 }

package/src/Atlaspack.js

@@ -58,17 +58,26 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import {
+  getFeatureFlag,
+  setFeatureFlags,
+  DEFAULT_FEATURE_FLAGS,
+} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
 import type {AssetGraphRequestResult} from './requests/AssetGraphRequest';
+import {loadRustWorkerThreadDylibHack} from './rustWorkerThreadDylibHack';
+import {isSuperPackage} from './isSuperPackage';
 
 registerCoreWithSerializer();
 
 export const INTERNAL_TRANSFORM: symbol = Symbol('internal_transform');
 export const INTERNAL_RESOLVE: symbol = Symbol('internal_resolve');
-export const WORKER_PATH: string = path.join(__dirname, 'worker.js');
+export const WORKER_PATH: string = path.join(
+  /*#__ATLASPACK_IGNORE__*/ __dirname,
+  'worker.js',
+);
 
 export default class Atlaspack {
   #requestTracker /*: RequestTracker*/;
@@ -117,6 +126,10 @@ export default class Atlaspack {
     };
     setFeatureFlags(featureFlags);
 
+    if (getFeatureFlag('enableRustWorkerThreadDylibHack')) {
+      loadRustWorkerThreadDylibHack();
+    }
+
     await initSourcemaps;
     await initRust?.();
 
@@ -164,7 +177,7 @@ export default class Atlaspack {
 
       rustAtlaspack = await AtlaspackV3.create({
         ...options,
-        corePath: path.join(__dirname, '..'),
+        corePath: path.join(/*#__ATLASPACK_IGNORE__*/ __dirname, '..'),
         threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
         entries: Array.isArray(entries)
           ? entries
@@ -176,6 +189,7 @@ export default class Atlaspack {
         // $FlowFixMe ProjectPath is a string
         defaultTargetOptions: resolvedOptions.defaultTargetOptions,
         lmdb,
+        isSuperPackage: isSuperPackage(),
       });
     }
     this.rustAtlaspack = rustAtlaspack;

package/src/BundleGraph.js

@@ -1315,7 +1315,14 @@ export default class BundleGraph {
     }
 
     let dependencies = this._graph
-      .getNodeIdsConnectedTo(assetNodeId)
+      .getNodeIdsConnectedTo(
+        assetNodeId,
+        // TODO: This seems like bug with library builds when assets are present
+        // in other files. Guarding the fix for now exclusively for super builds
+        process.env.ATLASPACK_SUPER_BUILD === 'true'
+          ? ALL_EDGE_TYPES
+          : undefined,
+      )
       .map((id) => nullthrows(this._graph.getNode(id)))
       .filter((node) => node.type === 'dependency')
       .map((node) => {

package/src/atlaspack-v3/NapiWorkerPool.js

@@ -6,7 +6,11 @@ import process from 'process';
 import type {Transferable} from '@atlaspack/rust';
 import {getAvailableThreads} from '@atlaspack/rust';
 
-const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
+const WORKER_PATH = path.join(
+  /*#__ATLASPACK_IGNORE__*/ __dirname,
+  'worker',
+  'napi-worker.js',
+);
 const ATLASPACK_NAPI_WORKERS =
   process.env.ATLASPACK_NAPI_WORKERS &&
   parseInt(process.env.ATLASPACK_NAPI_WORKERS, 10);

package/src/atlaspack-v3/worker/worker.js

@@ -25,6 +25,7 @@ import {
   bundleBehaviorMap,
   dependencyPriorityMap,
 } from './compat';
+import atlaspackInternalPlugins from '../../internal-plugins';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -41,10 +42,16 @@ export class AtlaspackWorker {
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
     async ({kind, specifier, resolveFrom}) => {
-      let customRequire = module.createRequire(resolveFrom);
-      let resolvedPath = customRequire.resolve(specifier);
-      // $FlowFixMe
-      let resolvedModule = await import(resolvedPath);
+      let resolvedModule;
+      if (atlaspackInternalPlugins && atlaspackInternalPlugins[specifier]) {
+        // If the plugin is available inside the package then use it
+        resolvedModule = atlaspackInternalPlugins[specifier]();
+      } else {
+        let customRequire = module.createRequire(resolveFrom);
+        let resolvedPath = customRequire.resolve(specifier);
+        // $FlowFixMe
+        resolvedModule = await import(resolvedPath);
+      }
 
       let instance = undefined;
       if (resolvedModule.default && resolvedModule.default[CONFIG]) {

package/src/index.js

@@ -10,4 +10,6 @@ export {
   INTERNAL_TRANSFORM,
 } from './Atlaspack';
 
+export {isSuperPackage} from './isSuperPackage';
+
 export * from './atlaspack-v3';

package/src/internal-plugins.js

@@ -0,0 +1,4 @@
+// @flow
+// This file is overridden in super package builds
+// $FlowFixMe
+export default {};

package/src/isSuperPackage.js

@@ -0,0 +1,28 @@
+// @flow strict-local
+let fs = require('fs');
+let {findAncestorFile} = require('@atlaspack/rust');
+
+let dirname = /*#__ATLASPACK_IGNORE__*/ __dirname;
+
+function isSuperPackage(): boolean {
+  if (!dirname) {
+    return false;
+  }
+
+  let packageJson = JSON.parse(
+    // $FlowFixMe
+    fs.readFileSync(findAncestorFile(['package.json'], dirname, '/'), 'utf8'),
+  );
+
+  return packageJson.name === '@atlaspack/super';
+}
+
+let result;
+
+module.exports.isSuperPackage = (): boolean => {
+  if (result == null) {
+    result = isSuperPackage();
+  }
+
+  return result;
+};

package/src/loadAtlaspackPlugin.js

@@ -3,16 +3,19 @@ import type {FilePath, PackageName, Semver} from '@atlaspack/types';
 import type {AtlaspackOptions} from './types';
 
 import path from 'path';
-import semver from 'semver';
-import logger from '@atlaspack/logger';
 import nullthrows from 'nullthrows';
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
   md,
 } from '@atlaspack/diagnostic';
-import {findAlternativeNodeModules, resolveConfig} from '@atlaspack/utils';
-import {type ProjectPath, toProjectPath} from './projectPath';
 import {version as ATLASPACK_VERSION} from '../package.json';
+import atlaspackInternalPlugins from './internal-plugins';
+import {findAlternativeNodeModules} from '@atlaspack/utils';
+import {
+  type ProjectPath,
+  toProjectPath,
+  toProjectPathUnsafe,
+} from './projectPath';
 
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
 const CONFIG = Symbol.for('parcel-plugin-config');
@@ -27,6 +30,22 @@ export default async function loadPlugin<T>(
   version: Semver,
   resolveFrom: ProjectPath,
 |}> {
+  if (atlaspackInternalPlugins && atlaspackInternalPlugins[pluginName]) {
+    let plugin = atlaspackInternalPlugins[pluginName]();
+    plugin = plugin.default || plugin;
+    plugin = plugin[CONFIG];
+    if (!plugin) {
+      throw new Error(
+        `Plugin ${pluginName} is not a valid Atlaspack plugin, should export an instance of a Atlaspack plugin ex. "export default new Reporter({ ... })".`,
+      );
+    }
+    return {
+      plugin,
+      version: ATLASPACK_VERSION,
+      resolveFrom: toProjectPathUnsafe(options.projectRoot),
+    };
+  }
+
   let resolveFrom = configPath;
 
   // Config packages can reference plugins, but cannot contain other plugins within them.
@@ -56,13 +75,11 @@ export default async function loadPlugin<T>(
     });
   }
 
-  let resolved, pkg;
+  let pkg;
   try {
-    ({resolved, pkg} = await options.packageManager.resolve(
-      pluginName,
-      resolveFrom,
-      {shouldAutoInstall: options.shouldAutoInstall},
-    ));
+    ({pkg} = await options.packageManager.resolve(pluginName, resolveFrom, {
+      shouldAutoInstall: options.shouldAutoInstall,
+    }));
   } catch (err) {
     if (err.code !== 'MODULE_NOT_FOUND') {
       throw err;
@@ -102,61 +119,6 @@ export default async function loadPlugin<T>(
     });
   }
 
-  // Remove plugin version compatiblility validation in canary builds as they don't use semver
-  if (!process.env.SKIP_PLUGIN_COMPATIBILITY_CHECK) {
-    if (!pluginName.startsWith('.')) {
-      // Validate the plugin engines field
-      let key = 'atlaspack';
-      let atlaspackVersionRange;
-      if (pkg?.engines?.atlaspack) {
-        atlaspackVersionRange = pkg.engines.atlaspack;
-      } else if (pkg?.engines?.parcel) {
-        key = 'parcel';
-        atlaspackVersionRange = pkg.engines.parcel;
-      }
-
-      if (!atlaspackVersionRange) {
-        logger.warn({
-          origin: '@atlaspack/core',
-          message: `The plugin "${pluginName}" needs to specify a \`package.json#engines.atlaspack\` field with the supported Atlaspack version range.`,
-        });
-      }
-
-      if (
-        atlaspackVersionRange &&
-        !semver.satisfies(ATLASPACK_VERSION, atlaspackVersionRange)
-      ) {
-        let pkgFile = nullthrows(
-          await resolveConfig(
-            options.inputFS,
-            resolved,
-            ['package.json'],
-            options.projectRoot,
-          ),
-        );
-        let pkgContents = await options.inputFS.readFile(pkgFile, 'utf8');
-        throw new ThrowableDiagnostic({
-          diagnostic: {
-            message: md`The plugin "${pluginName}" is not compatible with the current version of Atlaspack. Requires "${atlaspackVersionRange}" but the current version is "${ATLASPACK_VERSION}".`,
-            origin: '@atlaspack/core',
-            codeFrames: [
-              {
-                filePath: pkgFile,
-                language: 'json5',
-                code: pkgContents,
-                codeHighlights: generateJSONCodeHighlights(pkgContents, [
-                  {
-                    key: `/engines/${key}`,
-                  },
-                ]),
-              },
-            ],
-          },
-        });
-      }
-    }
-  }
-
   let plugin = await options.packageManager.require(pluginName, resolveFrom, {
     shouldAutoInstall: options.shouldAutoInstall,
   });

package/src/public/BundleGraph.js

@@ -444,10 +444,11 @@ export default class BundleGraph<TBundle: IBundle>
   // be used by a webserver to understand which conditions are used by which bundles,
   // and which bundles those conditions require depending on what they evaluate to.
   getConditionalBundleMapping(): Map<
-    TBundle,
+    string,
     Map<
       string,
       {|
+        bundle: TBundle,
         ifTrueBundles: Array<TBundle>,
         ifFalseBundles: Array<TBundle>,
       |},
@@ -486,14 +487,15 @@ export default class BundleGraph<TBundle: IBundle>
       }
 
       for (let bundle of bundles) {
-        const conditions = bundleConditions.get(bundle) ?? new Map();
+        const conditions = bundleConditions.get(bundle.id) ?? new Map();
 
         conditions.set(cond.key, {
+          bundle,
           ifTrueBundles,
           ifFalseBundles,
         });
 
-        bundleConditions.set(bundle, conditions);
+        bundleConditions.set(bundle.id, conditions);
       }
     }
 

package/src/requests/AtlaspackConfigRequest.js

@@ -30,15 +30,17 @@ import ThrowableDiagnostic, {
   md,
   errorToDiagnostic,
 } from '@atlaspack/diagnostic';
-import {parse} from 'json5';
+import json5 from 'json5';
 import path from 'path';
 import invariant from 'assert';
 
+import atlaspackInternalPlugins from '../internal-plugins';
 import {AtlaspackConfig} from '../AtlaspackConfig';
 import AtlaspackConfigSchema from '../AtlaspackConfig.schema';
 import {toProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
 import {optionsProxy} from '../utils';
+import {isSuperPackage} from '../isSuperPackage';
 
 type ConfigMap<K, V> = {[K]: V, ...};
 
@@ -159,34 +161,60 @@ export async function resolveAtlaspackConfig(
         );
 
   let usedDefault = false;
-  if (configPath == null && options.defaultConfig != null) {
+  let config, extendedFiles;
+
+  if (
+    configPath == null &&
+    options.defaultConfig != null &&
+    isSuperPackage() &&
+    options.defaultConfig.endsWith('.js')
+  ) {
     usedDefault = true;
-    configPath = (
-      await options.packageManager.resolve(options.defaultConfig, resolveFrom)
-    ).resolved;
-  }
+    // Load the super package default config
+    let result: AtlaspackConfigChain = await processConfigChain(
+      atlaspackInternalPlugins['@atlaspack/config-default'](),
+      // $FlowFixMe
+      options.defaultConfig,
+      options,
+    );
+    config = result.config;
+    extendedFiles = result.extendedFiles;
+  } else {
+    if (configPath == null && options.defaultConfig != null) {
+      usedDefault = true;
 
-  if (configPath == null) {
-    return null;
-  }
+      configPath = (
+        await options.packageManager.resolve(options.defaultConfig, resolveFrom)
+      ).resolved;
+    }
 
-  let contents;
-  try {
-    contents = await options.inputFS.readFile(configPath, 'utf8');
-  } catch (e) {
-    throw new ThrowableDiagnostic({
-      diagnostic: {
-        message: md`Could not find parcel config at ${path.relative(
-          options.projectRoot,
-          configPath,
-        )}`,
-        origin: '@atlaspack/core',
-      },
-    });
-  }
+    if (configPath == null) {
+      return null;
+    }
+
+    let contents;
+    try {
+      contents = await options.inputFS.readFile(configPath, 'utf8');
+    } catch (e) {
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: md`Could not find parcel config at ${path.relative(
+            options.projectRoot,
+            configPath,
+          )}`,
+          origin: '@atlaspack/core',
+        },
+      });
+    }
 
-  let {config, extendedFiles}: AtlaspackConfigChain =
-    await parseAndProcessConfig(configPath, contents, options);
+    let result: AtlaspackConfigChain = await parseAndProcessConfig(
+      configPath,
+      contents,
+      options,
+    );
+    config = result.config;
+    extendedFiles = result.extendedFiles;
+  }
 
   if (options.additionalReporters.length > 0) {
     config.reporters = [
@@ -216,7 +244,7 @@ export async function parseAndProcessConfig(
 ): Promise<AtlaspackConfigChain> {
   let config: RawAtlaspackConfig;
   try {
-    config = parse(contents);
+    config = json5.parse(contents);
   } catch (e) {
     let pos = {
       line: e.lineNumber,
@@ -446,11 +474,29 @@ export async function processConfigChain(
           let key = Array.isArray(configFile.extends)
             ? `/extends/${i}`
             : '/extends';
-          let resolved = await resolveExtends(ext, filePath, key, options);
-          extendedFiles.push(resolved);
-          let {extendedFiles: moreExtendedFiles, config: nextConfig} =
-            await processExtendedConfig(filePath, key, ext, resolved, options);
-          extendedFiles = extendedFiles.concat(moreExtendedFiles);
+
+          let nextConfig;
+          if (atlaspackInternalPlugins[ext]) {
+            nextConfig = (
+              await processConfigChain(
+                atlaspackInternalPlugins[ext](),
+                /*#__ATLASPACK_IGNORE__*/ __dirname,
+                options,
+              )
+            ).config;
+          } else {
+            let resolved = await resolveExtends(ext, filePath, key, options);
+            extendedFiles.push(resolved);
+            let result = await processExtendedConfig(
+              filePath,
+              key,
+              ext,
+              resolved,
+              options,
+            );
+            extendedFiles = extendedFiles.concat(result.extendedFiles);
+            nextConfig = result.config;
+          }
           extStartConfig = extStartConfig
             ? mergeConfigs(extStartConfig, nextConfig)
             : nextConfig;

package/src/resolveOptions.js

@@ -146,14 +146,25 @@ export default async function resolveOptions(
       ? path.resolve(initialOptions.watchDir)
       : projectRoot;
 
-  const needsRustLmdbCache =
-    getFeatureFlag('useLmdbJsLite') || getFeatureFlag('atlaspackV3');
-
-  let cache = needsRustLmdbCache
-    ? new LMDBLiteCache(cacheDir)
-    : outputFS instanceof NodeFS
-    ? new LMDBCache(cacheDir)
-    : new FSCache(outputFS, cacheDir);
+  function createCache() {
+    if (initialOptions.cache) {
+      return initialOptions.cache;
+    }
+
+    const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
+
+    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+      return new FSCache(outputFS, cacheDir);
+    }
+
+    if (needsRustLmdbCache || getFeatureFlag('useLmdbJsLite')) {
+      return new LMDBLiteCache(cacheDir);
+    }
+
+    return new LMDBCache(cacheDir);
+  }
+
+  let cache = createCache();
 
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize =

package/src/rustWorkerThreadDylibHack.js

@@ -0,0 +1,18 @@
+// @flow strict-local
+
+/**
+ * This is a workaround for https://github.com/rust-lang/rust/issues/91979
+ * when running atlaspack with parcel bindings, it is possible that the parcel
+ * dylib will be loaded from a node worker thread, which causes a crash on exit.
+ *
+ * This is a workaround to ensure that the parcel dylib is loaded in the main
+ * thread, which fixes the crash.
+ */
+export function loadRustWorkerThreadDylibHack() {
+  try {
+    // $FlowFixMe
+    require('@parcel/rust'); // eslint-disable-line
+  } catch (err) {
+    /* ignore */
+  }
+}

package/src/worker.js

@@ -32,14 +32,15 @@ import '@atlaspack/cache'; // register with serializer
 import '@atlaspack/package-manager';
 import '@atlaspack/fs';
 
+// Repl builds are currently not enabled
 // $FlowFixMe
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  // $FlowFixMe
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
+// if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
+//   /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
+//   require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
+//   // $FlowFixMe
+//   require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
+//   /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
+// }
 
 registerCoreWithSerializer();
 

package/test/AtlaspackConfig.test.js

@@ -3,10 +3,6 @@
 import assert from 'assert';
 import path from 'path';
 
-import logger from '@atlaspack/logger';
-import {inputFS} from '@atlaspack/test-utils';
-import sinon from 'sinon';
-
 import {AtlaspackConfig} from '../src/AtlaspackConfig';
 import {toProjectPath} from '../src/projectPath';
 import {parseAndProcessConfig} from '../src/requests/AtlaspackConfigRequest';
@@ -127,167 +123,6 @@ describe('AtlaspackConfig', () => {
   });
 
   describe('loadPlugin', () => {
-    it('should warn if a plugin needs to specify an engines.atlaspack field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {
-            '*.js': [
-              {
-                packageName: 'atlaspack-transformer-no-engines',
-                resolveFrom: configFilePath,
-                keyPath: '/transformers/*.js/0',
-              },
-            ],
-          },
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      let warnStub = sinon.stub(logger, 'warn');
-      let {plugin} = await config.loadPlugin({
-        packageName: 'atlaspack-transformer-no-engines',
-        resolveFrom: configFilePath,
-        keyPath: '/transformers/*.js/0',
-      });
-
-      assert.equal(typeof plugin?.transform, 'function');
-      assert(warnStub.calledOnce);
-      assert.deepEqual(warnStub.getCall(0).args[0], {
-        origin: '@atlaspack/core',
-        message:
-          'The plugin "atlaspack-transformer-no-engines" needs to specify a `package.json#engines.atlaspack` field with the supported Atlaspack version range.',
-      });
-      warnStub.restore();
-    });
-
-    it('should error if a plugin specifies an invalid engines.atlaspack field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {},
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      // $FlowFixMe[untyped-import]
-      let atlaspackVersion = require('../package.json').version;
-      let pkgJSON = path.join(
-        projectRoot,
-        'node_modules',
-        'atlaspack-transformer-bad-engines',
-        'package.json',
-      );
-      let code = inputFS.readFileSync(pkgJSON, 'utf8');
-
-      // $FlowFixMe
-      await assert.rejects(
-        () =>
-          config.loadPlugin({
-            packageName: 'atlaspack-transformer-bad-engines',
-            resolveFrom: configFilePath,
-            keyPath: '/transformers/*.js/0',
-          }),
-        {
-          name: 'Error',
-          diagnostics: [
-            {
-              message: `The plugin "atlaspack-transformer-bad-engines" is not compatible with the current version of Atlaspack. Requires "1.x" but the current version is "${atlaspackVersion}".`,
-              origin: '@atlaspack/core',
-              codeFrames: [
-                {
-                  filePath: pkgJSON,
-                  language: 'json5',
-                  code,
-                  codeHighlights: [
-                    {
-                      start: {line: 5, column: 5},
-                      end: {line: 5, column: 22},
-                      message: undefined,
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      );
-    });
-
-    it('should error if a plugin specifies an invalid engines.parcel field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {},
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      // $FlowFixMe[untyped-import]
-      let atlaspackVersion = require('../package.json').version;
-      let pkgJSON = path.join(
-        projectRoot,
-        'node_modules',
-        'atlaspack-transformer-bad-parcel-engines',
-        'package.json',
-      );
-      let code = inputFS.readFileSync(pkgJSON, 'utf8');
-
-      // $FlowFixMe
-      await assert.rejects(
-        () =>
-          config.loadPlugin({
-            packageName: 'atlaspack-transformer-bad-parcel-engines',
-            resolveFrom: configFilePath,
-            keyPath: '/transformers/*.js/0',
-          }),
-        {
-          name: 'Error',
-          diagnostics: [
-            {
-              message: `The plugin "atlaspack-transformer-bad-parcel-engines" is not compatible with the current version of Atlaspack. Requires "1.x" but the current version is "${atlaspackVersion}".`,
-              origin: '@atlaspack/core',
-              codeFrames: [
-                {
-                  filePath: pkgJSON,
-                  language: 'json5',
-                  code,
-                  codeHighlights: [
-                    {
-                      start: {line: 5, column: 5},
-                      end: {line: 5, column: 19},
-                      message: undefined,
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      );
-    });
-
     it('should error with a codeframe if a plugin is not resolved', async () => {
       let configFilePath = path.join(
         __dirname,

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-engines/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "atlaspack-transformer-bad-engines",
-  "version": "1.0.0",
-  "engines": {
-    "atlaspack": "1.x"
-  }
-}

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-parcel-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-parcel-engines/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "atlaspack-transformer-bad-parcel-engines",
-  "version": "1.0.0",
-  "engines": {
-    "parcel": "1.x"
-  }
-}

package/test/fixtures/plugins/node_modules/atlaspack-transformer-no-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-no-engines/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "atlaspack-transformer-no-engines",
-  "version": "1.0.0"
-}