@atlaspack/core 2.26.0 → 2.26.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @atlaspack/core
 
+## 2.26.1
+
+### Patch Changes
+
+- [#847](https://github.com/atlassian-labs/atlaspack/pull/847) [`9cd9521`](https://github.com/atlassian-labs/atlaspack/commit/9cd9521978f783046e2ae4ce78f2de7aeb07d073) Thanks [@marcins](https://github.com/marcins)! - Ensure feature flags are set in V3 workers
+
+- [#844](https://github.com/atlassian-labs/atlaspack/pull/844) [`d0c7bea`](https://github.com/atlassian-labs/atlaspack/commit/d0c7bea04458255b4c5d4299600e734b5f919fe1) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - deduplicate reporters from config
+
+- [#851](https://github.com/atlassian-labs/atlaspack/pull/851) [`1086c6a`](https://github.com/atlassian-labs/atlaspack/commit/1086c6a2c59271b63b3fb78e6acdb9d3a0dbf354) Thanks [@benjervis](https://github.com/benjervis)! - Remove asset groups from V3.
+
+  Asset groups were initially created to address the problem of a single asset being transformed into multiple assets (e.g. css modules).
+
+  This did the job, but means that an asset group is created for every single asset, and most groups only have a single asset inside.
+  This is a lot of unnecessary nodes, and we don't need to carry that over to the native rewrite.
+
+  This PR deletes the step that used to create them, and updates things like symbol prop to handle there potentially being no asset groups.
+
+- Updated dependencies [[`02f6aa1`](https://github.com/atlassian-labs/atlaspack/commit/02f6aa1906953fc184d2b49c905c2ef815cb878d), [`58527ee`](https://github.com/atlassian-labs/atlaspack/commit/58527eec15c1aebaaadbeb63586f3082c16beae3), [`525898e`](https://github.com/atlassian-labs/atlaspack/commit/525898e33cc229a4bc938ae853732be36d20c01a), [`cfb39a0`](https://github.com/atlassian-labs/atlaspack/commit/cfb39a0d729eb620cf2ca1611750a2bf7a080d08), [`d0c7bea`](https://github.com/atlassian-labs/atlaspack/commit/d0c7bea04458255b4c5d4299600e734b5f919fe1), [`1086c6a`](https://github.com/atlassian-labs/atlaspack/commit/1086c6a2c59271b63b3fb78e6acdb9d3a0dbf354), [`9cd9521`](https://github.com/atlassian-labs/atlaspack/commit/9cd9521978f783046e2ae4ce78f2de7aeb07d073), [`5776be2`](https://github.com/atlassian-labs/atlaspack/commit/5776be21f70a3f2b9471ba33da3ba1a883f21f1a)]:
+  - @atlaspack/rust@3.9.0
+  - @atlaspack/feature-flags@2.26.0
+  - @atlaspack/utils@3.1.0
+  - @atlaspack/cache@3.2.31
+  - @atlaspack/fs@2.15.31
+  - @atlaspack/logger@2.14.28
+  - @atlaspack/graph@3.5.25
+  - @atlaspack/package-manager@2.14.36
+  - @atlaspack/workers@2.14.36
+  - @atlaspack/plugin@2.14.36
+  - @atlaspack/profiler@2.14.33
+  - @atlaspack/types@2.15.26
+
 ## 2.26.0
 
 ### Minor Changes

package/dist/SymbolPropagation.js

@@ -345,17 +345,16 @@ function propagateSymbols({ options, assetGraph, changedAssetsPropagation, asset
                 incomingDep.excluded = false;
                 if (incomingDep.value.symbols != null &&
                     incomingDep.usedSymbolsUp.size === 0) {
-                    let assetGroups = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(incomingDep.id));
-                    if (assetGroups.length === 1) {
-                        let [assetGroupId] = assetGroups;
-                        let assetGroup = (0, nullthrows_1.default)(assetGraph.getNode(assetGroupId));
-                        if (assetGroup.type === 'asset_group' &&
-                            assetGroup.value.sideEffects === false) {
-                            incomingDep.excluded = true;
-                        }
-                    }
-                    else {
-                        (0, assert_1.default)(assetGroups.length === 0);
+                    let connectedNodeIds = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(incomingDep.id));
+                    let sideEffectFree = connectedNodeIds.every((nodeId) => {
+                        let connectedNode = (0, nullthrows_1.default)(assetGraph.getNode(nodeId));
+                        // Dependencies should only connect to asset_groups or assets
+                        (0, assert_1.default)(connectedNode.type === 'asset' ||
+                            connectedNode.type === 'asset_group');
+                        return connectedNode.value.sideEffects === false;
+                    });
+                    if (sideEffectFree) {
+                        incomingDep.excluded = true;
                     }
                 }
             }
@@ -566,18 +565,22 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
 function getDependencyResolution(graph, depId) {
     let depNodeId = graph.getNodeIdByContentKey(depId);
     let connected = graph.getNodeIdsConnectedFrom(depNodeId);
-    (0, assert_1.default)(connected.length <= 1);
-    let child = connected[0];
-    if (child) {
+    let resolvedNodeIds = [];
+    // If any of the resolved nodes is an asset_group, we need to resolve its
+    // assets here.
+    for (let child of connected) {
+        if (!child) {
+            continue;
+        }
         let childNode = (0, nullthrows_1.default)(graph.getNode(child));
         if (childNode.type === 'asset_group') {
-            return graph.getNodeIdsConnectedFrom(child);
+            resolvedNodeIds.push(...graph.getNodeIdsConnectedFrom(child));
         }
         else {
-            return [child];
+            resolvedNodeIds.push(child);
         }
     }
-    return [];
+    return resolvedNodeIds;
 }
 function equalMap(a, b) {
     if (a.size !== b.size)

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

@@ -63,7 +63,7 @@ class AtlaspackWorker {
         _AtlaspackWorker_resolvers.set(this, void 0);
         _AtlaspackWorker_transformers.set(this, void 0);
         _AtlaspackWorker_fs.set(this, void 0);
-        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom }) => {
+        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom, featureFlags }) => {
             let customRequire = module.createRequire(resolveFrom);
             let resolvedPath = customRequire.resolve(specifier);
             let resolvedModule = await import(resolvedPath);
@@ -79,6 +79,11 @@ class AtlaspackWorker {
             else {
                 throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
             }
+            // Set feature flags in the worker process
+            if (featureFlags) {
+                const { setFeatureFlags } = await import('@atlaspack/feature-flags');
+                setFeatureFlags(featureFlags);
+            }
             switch (kind) {
                 case 'resolver':
                     __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").set(specifier, { resolver: instance });

package/dist/requests/AssetGraphRequestRust.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -42,7 +9,7 @@ const assert_1 = __importDefault(require("assert"));
 const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
 const logger_1 = require("@atlaspack/logger");
 const feature_flags_1 = require("@atlaspack/feature-flags");
-const AssetGraph_1 = __importStar(require("../AssetGraph"));
+const AssetGraph_1 = __importDefault(require("../AssetGraph"));
 const RequestTracker_1 = require("../RequestTracker");
 const SymbolPropagation_1 = require("../SymbolPropagation");
 const EnvironmentManager_1 = require("../EnvironmentManager");
@@ -219,24 +186,11 @@ function getAssetGraph(serializedGraph) {
         let toNode = graph.getNode(to);
         if (fromNode?.type === 'dependency') {
             (0, assert_1.default)(toNode?.type === 'asset');
-            // For backwards compatibility, create asset group node if needed.
-            let assetGroupNode = (0, AssetGraph_1.nodeFromAssetGroup)({
-                filePath: toNode.value.filePath,
-                env: fromNode.value.env,
-                pipeline: toNode.value.pipeline,
-                sideEffects: Boolean(toNode.value.sideEffects),
-            });
-            let index = graph.addNodeByContentKeyIfNeeded(assetGroupNode.id, assetGroupNode);
-            graph.addEdge(from, index);
-            graph.addEdge(index, to);
         }
-        else if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+        if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
             fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-            graph.addEdge(from, to);
-        }
-        else {
-            graph.addEdge(from, to);
         }
+        graph.addEdge(from, to);
     }
     return {
         assetGraph: graph,

package/dist/requests/AtlaspackConfigRequest.js

@@ -141,13 +141,27 @@ async function resolveAtlaspackConfig(options) {
     }
     let { config, extendedFiles } = await parseAndProcessConfig(configPath, contents, options);
     if (options.additionalReporters.length > 0) {
-        config.reporters = [
-            ...options.additionalReporters.map(({ packageName, resolveFrom }) => ({
-                packageName,
-                resolveFrom,
-            })),
-            ...(config.reporters ?? []),
-        ];
+        if (options.featureFlags.deduplicateReporters) {
+            const reporterMap = new Map();
+            options.additionalReporters.forEach(({ packageName, resolveFrom }) => {
+                reporterMap.set(packageName, { packageName, resolveFrom });
+            });
+            config.reporters?.forEach((reporter) => {
+                if (!reporterMap.has(reporter.packageName)) {
+                    reporterMap.set(reporter.packageName, reporter);
+                }
+            });
+            config.reporters = Array.from(reporterMap.values());
+        }
+        else {
+            config.reporters = [
+                ...options.additionalReporters.map(({ packageName, resolveFrom }) => ({
+                    packageName,
+                    resolveFrom,
+                })),
+                ...(config.reporters ?? []),
+            ];
+        }
     }
     return { config, extendedFiles, usedDefault };
 }

package/lib/SymbolPropagation.js

@@ -383,15 +383,15 @@ function propagateSymbols({
         }
         incomingDep.excluded = false;
         if (incomingDep.value.symbols != null && incomingDep.usedSymbolsUp.size === 0) {
-          let assetGroups = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(incomingDep.id));
-          if (assetGroups.length === 1) {
-            let [assetGroupId] = assetGroups;
-            let assetGroup = (0, _nullthrows().default)(assetGraph.getNode(assetGroupId));
-            if (assetGroup.type === 'asset_group' && assetGroup.value.sideEffects === false) {
-              incomingDep.excluded = true;
-            }
-          } else {
-            (0, _assert().default)(assetGroups.length === 0);
+          let connectedNodeIds = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(incomingDep.id));
+          let sideEffectFree = connectedNodeIds.every(nodeId => {
+            let connectedNode = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
+            // Dependencies should only connect to asset_groups or assets
+            (0, _assert().default)(connectedNode.type === 'asset' || connectedNode.type === 'asset_group');
+            return connectedNode.value.sideEffects === false;
+          });
+          if (sideEffectFree) {
+            incomingDep.excluded = true;
           }
         }
       }
@@ -590,17 +590,22 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
 function getDependencyResolution(graph, depId) {
   let depNodeId = graph.getNodeIdByContentKey(depId);
   let connected = graph.getNodeIdsConnectedFrom(depNodeId);
-  (0, _assert().default)(connected.length <= 1);
-  let child = connected[0];
-  if (child) {
+  let resolvedNodeIds = [];
+
+  // If any of the resolved nodes is an asset_group, we need to resolve its
+  // assets here.
+  for (let child of connected) {
+    if (!child) {
+      continue;
+    }
     let childNode = (0, _nullthrows().default)(graph.getNode(child));
     if (childNode.type === 'asset_group') {
-      return graph.getNodeIdsConnectedFrom(child);
+      resolvedNodeIds.push(...graph.getNodeIdsConnectedFrom(child));
     } else {
-      return [child];
+      resolvedNodeIds.push(child);
     }
   }
-  return [];
+  return resolvedNodeIds;
 }
 function equalMap(a, b) {
   if (a.size !== b.size) return false;

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

@@ -66,7 +66,8 @@ class AtlaspackWorker {
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
     specifier,
-    resolveFrom
+    resolveFrom,
+    featureFlags
   }) => {
     let customRequire = _module().createRequire(resolveFrom);
     let resolvedPath = customRequire.resolve(specifier);
@@ -79,6 +80,13 @@ class AtlaspackWorker {
     } else {
       throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
     }
+    // Set feature flags in the worker process
+    if (featureFlags) {
+      const {
+        setFeatureFlags
+      } = await import('@atlaspack/feature-flags');
+      setFeatureFlags(featureFlags);
+    }
     switch (kind) {
       case 'resolver':
         this.#resolvers.set(specifier, {

package/lib/requests/AssetGraphRequestRust.js

@@ -33,13 +33,11 @@ function _featureFlags() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
+var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
 var _Environment = require("../Environment");
-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 }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
@@ -212,23 +210,11 @@ function getAssetGraph(serializedGraph) {
     let toNode = graph.getNode(to);
     if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
       (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-
-      // For backwards compatibility, create asset group node if needed.
-      let assetGroupNode = (0, _AssetGraph.nodeFromAssetGroup)({
-        filePath: toNode.value.filePath,
-        env: fromNode.value.env,
-        pipeline: toNode.value.pipeline,
-        sideEffects: Boolean(toNode.value.sideEffects)
-      });
-      let index = graph.addNodeByContentKeyIfNeeded(assetGroupNode.id, assetGroupNode);
-      graph.addEdge(from, index);
-      graph.addEdge(index, to);
-    } else if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
+    }
+    if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
       fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-      graph.addEdge(from, to);
-    } else {
-      graph.addEdge(from, to);
     }
+    graph.addEdge(from, to);
   }
   return {
     assetGraph: graph,

package/lib/requests/AtlaspackConfigRequest.js

@@ -161,13 +161,33 @@ async function resolveAtlaspackConfig(options) {
     extendedFiles
   } = await parseAndProcessConfig(configPath, contents, options);
   if (options.additionalReporters.length > 0) {
-    config.reporters = [...options.additionalReporters.map(({
-      packageName,
-      resolveFrom
-    }) => ({
-      packageName,
-      resolveFrom
-    })), ...(config.reporters ?? [])];
+    if (options.featureFlags.deduplicateReporters) {
+      var _config$reporters;
+      const reporterMap = new Map();
+      options.additionalReporters.forEach(({
+        packageName,
+        resolveFrom
+      }) => {
+        reporterMap.set(packageName, {
+          packageName,
+          resolveFrom
+        });
+      });
+      (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
+        if (!reporterMap.has(reporter.packageName)) {
+          reporterMap.set(reporter.packageName, reporter);
+        }
+      });
+      config.reporters = Array.from(reporterMap.values());
+    } else {
+      config.reporters = [...options.additionalReporters.map(({
+        packageName,
+        resolveFrom
+      }) => ({
+        packageName,
+        resolveFrom
+      })), ...(config.reporters ?? [])];
+    }
   }
   return {
     config,

package/lib/types/atlaspack-v3/worker/worker.d.ts

@@ -1,6 +1,7 @@
 import * as napi from '@atlaspack/rust';
 import type { JsCallable } from '@atlaspack/rust';
 import type { FilePath } from '@atlaspack/types';
+import { FeatureFlags } from '@atlaspack/feature-flags';
 export declare class AtlaspackWorker {
     #private;
     constructor();
@@ -18,6 +19,7 @@ type LoadPluginOptions = {
     kind: 'resolver' | 'transformer';
     specifier: string;
     resolveFrom: string;
+    featureFlags?: FeatureFlags;
 };
 type RpcPluginOptions = {
     projectRoot: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.26.0",
+  "version": "2.26.1",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,20 +24,20 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.30",
+    "@atlaspack/cache": "3.2.31",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.25.5",
-    "@atlaspack/fs": "2.15.30",
-    "@atlaspack/graph": "3.5.24",
-    "@atlaspack/logger": "2.14.27",
-    "@atlaspack/package-manager": "2.14.35",
-    "@atlaspack/plugin": "2.14.35",
-    "@atlaspack/profiler": "2.14.32",
-    "@atlaspack/rust": "3.8.3",
-    "@atlaspack/types": "2.15.25",
-    "@atlaspack/utils": "3.0.3",
-    "@atlaspack/workers": "2.14.35",
+    "@atlaspack/feature-flags": "2.26.0",
+    "@atlaspack/fs": "2.15.31",
+    "@atlaspack/graph": "3.5.25",
+    "@atlaspack/logger": "2.14.28",
+    "@atlaspack/package-manager": "2.14.36",
+    "@atlaspack/plugin": "2.14.36",
+    "@atlaspack/profiler": "2.14.33",
+    "@atlaspack/rust": "3.9.0",
+    "@atlaspack/types": "2.15.26",
+    "@atlaspack/utils": "3.1.0",
+    "@atlaspack/workers": "2.14.36",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",

package/src/SymbolPropagation.ts

@@ -533,20 +533,22 @@ export function propagateSymbols({
             incomingDep.value.symbols != null &&
             incomingDep.usedSymbolsUp.size === 0
           ) {
-            let assetGroups = assetGraph.getNodeIdsConnectedFrom(
+            let connectedNodeIds = assetGraph.getNodeIdsConnectedFrom(
               assetGraph.getNodeIdByContentKey(incomingDep.id),
             );
-            if (assetGroups.length === 1) {
-              let [assetGroupId] = assetGroups;
-              let assetGroup = nullthrows(assetGraph.getNode(assetGroupId));
-              if (
-                assetGroup.type === 'asset_group' &&
-                assetGroup.value.sideEffects === false
-              ) {
-                incomingDep.excluded = true;
-              }
-            } else {
-              invariant(assetGroups.length === 0);
+
+            let sideEffectFree = connectedNodeIds.every((nodeId) => {
+              let connectedNode = nullthrows(assetGraph.getNode(nodeId));
+              // Dependencies should only connect to asset_groups or assets
+              invariant(
+                connectedNode.type === 'asset' ||
+                  connectedNode.type === 'asset_group',
+              );
+              return connectedNode.value.sideEffects === false;
+            });
+
+            if (sideEffectFree) {
+              incomingDep.excluded = true;
             }
           }
         }
@@ -807,17 +809,25 @@ function getDependencyResolution(
 ): Array<NodeId> {
   let depNodeId = graph.getNodeIdByContentKey(depId);
   let connected = graph.getNodeIdsConnectedFrom(depNodeId);
-  invariant(connected.length <= 1);
-  let child = connected[0];
-  if (child) {
+
+  let resolvedNodeIds: Array<NodeId> = [];
+
+  // If any of the resolved nodes is an asset_group, we need to resolve its
+  // assets here.
+  for (let child of connected) {
+    if (!child) {
+      continue;
+    }
+
     let childNode = nullthrows(graph.getNode(child));
     if (childNode.type === 'asset_group') {
-      return graph.getNodeIdsConnectedFrom(child);
+      resolvedNodeIds.push(...graph.getNodeIdsConnectedFrom(child));
     } else {
-      return [child];
+      resolvedNodeIds.push(child);
     }
   }
-  return [];
+
+  return resolvedNodeIds;
 }
 
 function equalMap<K>(

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

@@ -25,6 +25,7 @@ import {
   bundleBehaviorMap,
   dependencyPriorityMap,
 } from './compat';
+import {FeatureFlags} from '@atlaspack/feature-flags';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -40,7 +41,7 @@ export class AtlaspackWorker {
   }
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>> = jsCallable(
-    async ({kind, specifier, resolveFrom}) => {
+    async ({kind, specifier, resolveFrom, featureFlags}) => {
       let customRequire = module.createRequire(resolveFrom);
       let resolvedPath = customRequire.resolve(specifier);
       let resolvedModule = await import(resolvedPath);
@@ -59,6 +60,11 @@ export class AtlaspackWorker {
           `Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`,
         );
       }
+      // Set feature flags in the worker process
+      if (featureFlags) {
+        const {setFeatureFlags} = await import('@atlaspack/feature-flags');
+        setFeatureFlags(featureFlags);
+      }
 
       switch (kind) {
         case 'resolver':
@@ -340,6 +346,7 @@ type LoadPluginOptions = {
   kind: 'resolver' | 'transformer';
   specifier: string;
   resolveFrom: string;
+  featureFlags?: FeatureFlags;
 };
 
 type RpcPluginOptions = {

package/src/requests/AssetGraphRequestRust.ts

@@ -238,28 +238,13 @@ export function getAssetGraph(serializedGraph: any): {
 
     if (fromNode?.type === 'dependency') {
       invariant(toNode?.type === 'asset');
+    }
 
-      // For backwards compatibility, create asset group node if needed.
-      let assetGroupNode = nodeFromAssetGroup({
-        filePath: toNode.value.filePath,
-        env: fromNode.value.env,
-        pipeline: toNode.value.pipeline,
-        sideEffects: Boolean(toNode.value.sideEffects),
-      });
-
-      let index = graph.addNodeByContentKeyIfNeeded(
-        assetGroupNode.id,
-        assetGroupNode,
-      );
-
-      graph.addEdge(from, index);
-      graph.addEdge(index, to);
-    } else if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+    if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
       fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-      graph.addEdge(from, to);
-    } else {
-      graph.addEdge(from, to);
     }
+
+    graph.addEdge(from, to);
   }
 
   return {

package/src/requests/AtlaspackConfigRequest.ts

@@ -12,6 +12,7 @@ import type {
   PureAtlaspackConfigPipeline,
   AtlaspackOptions,
   ProcessedAtlaspackConfig,
+  AtlaspackPluginNode,
 } from '../types';
 
 import {createBuildCache} from '@atlaspack/build-cache';
@@ -197,13 +198,29 @@ export async function resolveAtlaspackConfig(
     await parseAndProcessConfig(configPath, contents, options);
 
   if (options.additionalReporters.length > 0) {
-    config.reporters = [
-      ...options.additionalReporters.map(({packageName, resolveFrom}) => ({
-        packageName,
-        resolveFrom,
-      })),
-      ...(config.reporters ?? []),
-    ];
+    if (options.featureFlags.deduplicateReporters) {
+      const reporterMap = new Map<PackageName, AtlaspackPluginNode>();
+
+      options.additionalReporters.forEach(({packageName, resolveFrom}) => {
+        reporterMap.set(packageName, {packageName, resolveFrom});
+      });
+
+      config.reporters?.forEach((reporter) => {
+        if (!reporterMap.has(reporter.packageName)) {
+          reporterMap.set(reporter.packageName, reporter);
+        }
+      });
+
+      config.reporters = Array.from(reporterMap.values());
+    } else {
+      config.reporters = [
+        ...options.additionalReporters.map(({packageName, resolveFrom}) => ({
+          packageName,
+          resolveFrom,
+        })),
+        ...(config.reporters ?? []),
+      ];
+    }
   }
 
   return {config, extendedFiles, usedDefault};