@atlaspack/core 2.16.2-dev.55 → 2.16.2-dev.72

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @atlaspack/core
 
+## 2.18.2
+
+### Patch Changes
+
+- Updated dependencies [[`73ea3c4`](https://github.com/atlassian-labs/atlaspack/commit/73ea3c4d85d4401fdd15abcbf988237e890e7ad3), [`b1b3693`](https://github.com/atlassian-labs/atlaspack/commit/b1b369317c66f8a431c170df2ebba4fa5b2e38ef)]:
+  - @atlaspack/feature-flags@2.17.0
+  - @atlaspack/cache@3.2.6
+  - @atlaspack/fs@2.15.6
+  - @atlaspack/graph@3.5.1
+  - @atlaspack/utils@2.14.11
+  - @atlaspack/package-manager@2.14.11
+  - @atlaspack/profiler@2.14.9
+  - @atlaspack/types@2.15.1
+  - @atlaspack/workers@2.14.11
+  - @atlaspack/plugin@2.14.11
+
+## 2.18.1
+
+### Patch Changes
+
+- Updated dependencies [[`1b52b99`](https://github.com/atlassian-labs/atlaspack/commit/1b52b99db4298b04c1a6eb0f97994d75a2d436f9)]:
+  - @atlaspack/graph@3.5.0
+
+## 2.18.0
+
+### Minor Changes
+
+- [#601](https://github.com/atlassian-labs/atlaspack/pull/601) [`1e32d4e`](https://github.com/atlassian-labs/atlaspack/commit/1e32d4eae6b3af3968e8a0ef97d35b4347fd4196) Thanks [@yamadapc](https://github.com/yamadapc)! - Improve granular configuration file invalidations
+
+- [#599](https://github.com/atlassian-labs/atlaspack/pull/599) [`0b2f6f5`](https://github.com/atlassian-labs/atlaspack/commit/0b2f6f55794d3ff6e2f5a41f963e7e5dd8ad9f8d) Thanks [@pancaspe87](https://github.com/pancaspe87)! - load and write env to cache - change is feature flagged
+
+### Patch Changes
+
+- [#595](https://github.com/atlassian-labs/atlaspack/pull/595) [`51aba5f`](https://github.com/atlassian-labs/atlaspack/commit/51aba5fc0e49235ee06bbc3c376f48c3e7da5c4b) Thanks [@yamadapc](https://github.com/yamadapc)! - Add bundleId to write bundle request results
+
+- [#572](https://github.com/atlassian-labs/atlaspack/pull/572) [`6dd4ccb`](https://github.com/atlassian-labs/atlaspack/commit/6dd4ccb753541de32322d881f973d571dd57e4ca) Thanks [@yamadapc](https://github.com/yamadapc)! - Add feature-flagged change which removes all environment duplication around objects
+
+- Updated dependencies [[`0999fb7`](https://github.com/atlassian-labs/atlaspack/commit/0999fb78da519a6c7582d212883e515fcf6c1252), [`51aba5f`](https://github.com/atlassian-labs/atlaspack/commit/51aba5fc0e49235ee06bbc3c376f48c3e7da5c4b), [`1e32d4e`](https://github.com/atlassian-labs/atlaspack/commit/1e32d4eae6b3af3968e8a0ef97d35b4347fd4196), [`35fdd4b`](https://github.com/atlassian-labs/atlaspack/commit/35fdd4b52da0af20f74667f7b8adfb2f90279b7c), [`6dd4ccb`](https://github.com/atlassian-labs/atlaspack/commit/6dd4ccb753541de32322d881f973d571dd57e4ca)]:
+  - @atlaspack/fs@2.15.5
+  - @atlaspack/types@2.15.0
+  - @atlaspack/rust@3.3.5
+  - @atlaspack/cache@3.2.5
+  - @atlaspack/package-manager@2.14.10
+  - @atlaspack/profiler@2.14.8
+  - @atlaspack/workers@2.14.10
+  - @atlaspack/plugin@2.14.10
+  - @atlaspack/logger@2.14.10
+  - @atlaspack/utils@2.14.10
+
 ## 2.17.4
 
 ### Patch Changes

package/lib/AssetGraph.js

@@ -46,6 +46,14 @@ function _graph() {
 }
 var _Dependency = require("./Dependency");
 var _projectPath = require("./projectPath");
+var _EnvironmentManager = require("./EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function nodeFromDep(dep) {
   return {
@@ -63,7 +71,7 @@ function nodeFromDep(dep) {
 }
 function nodeFromAssetGroup(assetGroup) {
   return {
-    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + assetGroup.env.id + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
+    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + (0, _EnvironmentManager.toEnvironmentId)(assetGroup.env) + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
     type: 'asset_group',
     value: assetGroup,
     usedSymbolsDownDirty: true
@@ -130,16 +138,19 @@ class AssetGraph extends _graph().ContentGraph {
 
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input) {
+    if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+      return;
+    }
     let {
       id,
       context
-    } = input.env;
+    } = (0, _EnvironmentManager.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, (0, _EnvironmentManager.fromEnvironmentId)(input.env));
     }
   }
   setRootConnections({
@@ -199,13 +210,13 @@ class AssetGraph extends _graph().ContentGraph {
         env: target.env,
         isEntry: true,
         needsStableName: true,
-        symbols: target.env.isLibrary ? new Map([['*', {
+        symbols: (0, _EnvironmentManager.fromEnvironmentId)(target.env).isLibrary ? new Map([['*', {
           local: '*',
           isWeak: true,
           loc: null
         }]]) : undefined
       }));
-      if (node.value.env.isLibrary) {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -348,7 +359,7 @@ class AssetGraph extends _graph().ContentGraph {
       if (this.undeferredDependencies.has(d)) {
         return false;
       }
-      let depIsDeferrable = d.symbols && !(d.env.isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
+      let depIsDeferrable = d.symbols && !((0, _EnvironmentManager.fromEnvironmentId)(d.env).isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
         var _resolvedAsset$symbol;
         let assetSymbol = (_resolvedAsset$symbol = resolvedAsset.symbols) === null || _resolvedAsset$symbol === void 0 || (_resolvedAsset$symbol = _resolvedAsset$symbol.get(symbol)) === null || _resolvedAsset$symbol === void 0 ? void 0 : _resolvedAsset$symbol.local;
         return assetSymbol != null && symbols.has(assetSymbol);

package/lib/Atlaspack.js

@@ -126,7 +126,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*/;
@@ -215,7 +215,6 @@ class Atlaspack {
       }
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
-        corePath: _path().default.join(__dirname, '..'),
         threads,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
@@ -510,9 +509,7 @@ class Atlaspack {
       if (this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
-      let {
-        didInvalidate: isInvalid
-      } = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
       if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
         if (this.#watchAbortController) {
           this.#watchAbortController.abort();

package/lib/AtlaspackConfig.schema.js

@@ -14,13 +14,7 @@ exports.validatePackageName = validatePackageName;
 // * We do not care about package names
 // * Validation makes interop between parcel/atlaspack confusing.
 //
-function validatePackageName(
-// eslint-disable-next-line no-unused-vars
-pkg,
-// eslint-disable-next-line no-unused-vars
-pluginType,
-// eslint-disable-next-line no-unused-vars
-key) {}
+function validatePackageName() {}
 const validatePluginName = (pluginType, key) => {
   return val => {
     // allow plugin spread...

package/lib/BundleGraph.js

@@ -51,6 +51,7 @@ function _featureFlags() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -207,7 +208,7 @@ class BundleGraph {
           }
         }
       }
-      if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
+      if (node.type === 'dependency' && node.value.symbols != null && (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
         let nodeValueSymbols = node.value.symbols;
@@ -832,7 +833,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;
     });
@@ -859,14 +863,13 @@ class BundleGraph {
           return;
         }
         visitedBundles.add(descendant);
-        if (descendant.type !== bundle.type || descendant.env.context !== bundle.env.context) {
+        if (descendant.type !== bundle.type || (0, _EnvironmentManager.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) {
           actions.skipChildren();
           return;
         }
         if (bundleHasReference(descendant)) {
           isReferenced = true;
           actions.stop();
-          return;
         }
       }, referencer);
       return isReferenced;
@@ -888,7 +891,7 @@ class BundleGraph {
   isAssetReachableFromBundle(asset, bundle) {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
-    if (_Environment.ISOLATED_ENVS.has(bundle.env.context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
+    if (_Environment.ISOLATED_ENVS.has((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
       return false;
     }
 
@@ -916,7 +919,7 @@ class BundleGraph {
           let node = (0, _nullthrows().default)(this._graph.getNode(nodeId));
           // If we've reached the root or a context change without
           // finding this asset in the ancestry, it is not reachable.
-          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || node.value.env.context !== bundle.env.context)) {
+          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context)) {
             isReachable = false;
             actions.stop();
             return;
@@ -925,7 +928,6 @@ class BundleGraph {
             let childBundles = this.getBundlesInBundleGroup(node.value);
             if (childBundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && this.bundleHasAsset(b, asset))) {
               actions.skipChildren();
-              return;
             }
           }
         }, [bundleGraphEdgeTypes.references, bundleGraphEdgeTypes.bundle]);
@@ -1412,7 +1414,7 @@ class BundleGraph {
     for (let referencedBundle of this.getReferencedBundles(bundle)) {
       hash.writeString(referencedBundle.id);
     }
-    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)(bundle.env)));
+    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)((0, _EnvironmentManager.fromEnvironmentId)(bundle.env))));
     return hash.finish();
   }
   getBundleGraphHash() {

package/lib/Dependency.js

@@ -24,6 +24,7 @@ function _assert() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createDependencyId({
   sourceAssetId,
@@ -41,8 +42,11 @@ function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(env),
+    target: target != null ? {
+      ...target,
+      env: (0, _EnvironmentManager.fromEnvironmentId)(target.env)
+    } : null,
     pipeline,
     specifierType: _types.SpecifierType[specifierType],
     bundleBehavior,

package/lib/Environment.js

@@ -15,6 +15,7 @@ function _rust() {
 var _utils = require("./utils");
 var _Environment = _interopRequireWildcard(require("./public/Environment"));
 var _IdentifierRegistry = require("./IdentifierRegistry");
+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; }
 const DEFAULT_ENGINES = {
@@ -108,15 +109,15 @@ function createEnvironment({
     loc
   };
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+  return (0, _EnvironmentManager.toEnvironmentRef)(Object.freeze(res));
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return (0, _EnvironmentManager.toEnvironmentRef)(a);
   }
   if (b instanceof _Environment.default) {
-    return (0, _Environment.environmentToInternalEnvironment)(b);
+    return (0, _EnvironmentManager.toEnvironmentRef)((0, _Environment.environmentToInternalEnvironment)(b));
   }
 
   // $FlowFixMe - ignore the `id` that is already on a

package/lib/EnvironmentManager.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromEnvironmentId = fromEnvironmentId;
+exports.loadEnvironmentsFromCache = loadEnvironmentsFromCache;
+exports.toEnvironmentId = toEnvironmentId;
+exports.toEnvironmentRef = toEnvironmentRef;
+exports.writeEnvironmentsToCache = writeEnvironmentsToCache;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _constants = require("./constants");
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+const localEnvironmentCache = new Map();
+
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+function toEnvironmentRef(env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return env;
+  }
+  const id = toEnvironmentId(env);
+  return id;
+}
+
+/**
+ * Convert environment to a string ID
+ */
+function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return typeof env === 'string' ? env : env.id;
+  }
+  if (typeof env === 'string') {
+    return env;
+  }
+  (0, _rust().addEnvironment)(env);
+  return env.id;
+}
+function fromEnvironmentId(id) {
+  if (!(0, _featureFlags().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((0, _rust().getEnvironment)(id));
+  localEnvironmentCache.set(id, env);
+  return env;
+}
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function writeEnvironmentsToCache(cache) {
+  const environments = (0, _rust().getAllEnvironments)();
+  const environmentIds = new Set();
+
+  // Store each environment individually
+  for (const env of environments) {
+    environmentIds.add(env.id);
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${env.id}`;
+    await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${envKey})`, async () => {
+      await cache.set(envKey, env);
+    });
+  }
+
+  // Store the list of environment IDs
+  await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${_constants.ATLASPACK_VERSION}`})`, async () => {
+    await cache.set(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`, Array.from(environmentIds));
+  });
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function loadEnvironmentsFromCache(cache) {
+  const cachedEnvIds = await cache.get(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`);
+  if (cachedEnvIds == null) {
+    return;
+  }
+  const environments = [];
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    (0, _rust().setAllEnvironments)(environments);
+  }
+}

package/lib/InternalConfig.js

@@ -14,6 +14,7 @@ function _rust() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function createConfig({
   plugin,
   isSource,
@@ -30,11 +31,11 @@ function createConfig({
   invalidateOnBuild
 }) {
   let environment = env ?? (0, _Environment.createEnvironment)();
-  const configId = (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + environment.id + String(isSource));
+  const configId = (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + (0, _EnvironmentManager.toEnvironmentId)(environment) + String(isSource));
   _IdentifierRegistry.identifierRegistry.addIdentifier('config_request', configId, {
     plugin,
     searchPath,
-    environmentId: environment.id,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(environment),
     isSource
   });
   return {

package/lib/PackagerRunner.js

@@ -92,6 +92,7 @@ function _profiler() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _featureFlags() {
   const data = require("@atlaspack/feature-flags");
   _featureFlags = function () {
@@ -397,23 +398,28 @@ class PackagerRunner {
     let fullPath = (0, _projectPath.fromProjectPath)(this.options.projectRoot, filePath);
     let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), this.options.projectRoot);
     let inlineSources = false;
+    const bundleEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
     if (bundle.target) {
-      if (bundle.env.sourceMap && bundle.env.sourceMap.sourceRoot !== undefined) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
-      } else if (this.options.serveOptions && bundle.target.env.context === 'browser') {
+      const bundleTargetEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.target.env);
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+        sourceRoot = bundleEnv.sourceMap.sourceRoot;
+      } else if (this.options.serveOptions && bundleTargetEnv.context === 'browser') {
         sourceRoot = '/__parcel_source_root';
       }
-      if (bundle.env.sourceMap && bundle.env.sourceMap.inlineSources !== undefined) {
-        inlineSources = bundle.env.sourceMap.inlineSources;
-      } else if (bundle.target.env.context !== 'node') {
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources !== undefined) {
+        inlineSources = bundleEnv.sourceMap.inlineSources;
+      } else if (bundleTargetEnv.context !== 'node') {
         // inlining should only happen in production for browser targets by default
         inlineSources = this.options.mode === 'production';
       }
     }
-    let mapFilename = fullPath + '.map';
-    let isInlineMap = bundle.env.sourceMap && bundle.env.sourceMap.inline;
+    if (process.env.ATLASPACK_SUPER_BUILD === 'true') {
+      // Set source root to 'atlaspack' so stack traces are clean in Sentry
+      sourceRoot = 'atlaspack';
+    }
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
     let stringified = await map.stringify({
-      file: _path().default.basename(mapFilename),
+      file: _path().default.basename(fullPath + '.map'),
       // $FlowFixMe
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,