@atlaspack/packager-js 2.14.5-dev.1c70d50f9.99 → 2.14.5-dev.69

package/CHANGELOG.md

@@ -1,62 +1,5 @@
 # @atlaspack/packager-js
 
-## 2.16.1
-
-### Patch Changes
-
-- Updated dependencies [[`644b157`](https://github.com/atlassian-labs/atlaspack/commit/644b157dee72a871acc2d0facf0b87b8eea51956)]:
-  - @atlaspack/feature-flags@2.18.2
-  - @atlaspack/utils@2.15.2
-  - @atlaspack/types@2.15.4
-  - @atlaspack/plugin@2.14.14
-
-## 2.16.0
-
-### Minor Changes
-
-- [#644](https://github.com/atlassian-labs/atlaspack/pull/644) [`fc59be7`](https://github.com/atlassian-labs/atlaspack/commit/fc59be71f43dd87d3e6fb7f3f50c424d2b664858) Thanks [@marcins](https://github.com/marcins)! - Removes the unused unstable `forceSkipWrapAssets` feature
-
-### Patch Changes
-
-- [#633](https://github.com/atlassian-labs/atlaspack/pull/633) [`26aa9c5`](https://github.com/atlassian-labs/atlaspack/commit/26aa9c599d2be45ce1438a74c5fa22f39b9b554b) Thanks [@sbhuiyan-atlassian](https://github.com/sbhuiyan-atlassian)! - Ported various HMR changes from Parcel
-
-- Updated dependencies [[`26aa9c5`](https://github.com/atlassian-labs/atlaspack/commit/26aa9c599d2be45ce1438a74c5fa22f39b9b554b), [`0501255`](https://github.com/atlassian-labs/atlaspack/commit/05012550da35b05ce7d356a8cc29311e7f9afdca)]:
-  - @atlaspack/feature-flags@2.18.1
-  - @atlaspack/types@2.15.3
-  - @atlaspack/utils@2.15.1
-  - @atlaspack/plugin@2.14.13
-
-## 2.15.0
-
-### Minor Changes
-
-- [#627](https://github.com/atlassian-labs/atlaspack/pull/627) [`85c52d3`](https://github.com/atlassian-labs/atlaspack/commit/85c52d3f7717b3c84a118d18ab98cfbfd71dcbd2) Thanks [@benjervis](https://github.com/benjervis)! - Expands the situations where scope hoisting may be applied to include assets with no dependencies, regardless of whether if they have a wrapped ancestor.
-
-  Can be enabled with the `applyScopeHoistingImprovement` feature flag.
-
-### Patch Changes
-
-- [#632](https://github.com/atlassian-labs/atlaspack/pull/632) [`10fbcfb`](https://github.com/atlassian-labs/atlaspack/commit/10fbcfbfa49c7a83da5d7c40983e36e87f524a75) Thanks [@marcins](https://github.com/marcins)! - Added a new feature flag `inlineConstOptimisationFix` which when enabled changes the behaviour for output of constant modules. This fixes two issues with constant modules:
-
-  - Previously constant modules, if they needed a namespace anywhere, would have a namespace everywhere, with this change they only have a namespace in the bundles where needed.
-  - Previously in the case of wrapped assets, a constant module dependnecy of that wrapped asset would be rendered after the module - which meant the minifier would not be able to inline the constants safely. With this flag all constant modules are rendered at the top of the bundle.
-
-- Updated dependencies [[`10fbcfb`](https://github.com/atlassian-labs/atlaspack/commit/10fbcfbfa49c7a83da5d7c40983e36e87f524a75), [`85c52d3`](https://github.com/atlassian-labs/atlaspack/commit/85c52d3f7717b3c84a118d18ab98cfbfd71dcbd2), [`e39c6cf`](https://github.com/atlassian-labs/atlaspack/commit/e39c6cf05f7e95ce5420dbcea66f401b1cbd397c)]:
-  - @atlaspack/feature-flags@2.18.0
-  - @atlaspack/utils@2.15.0
-  - @atlaspack/types@2.15.2
-  - @atlaspack/plugin@2.14.12
-
-## 2.14.11
-
-### 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/utils@2.14.11
-  - @atlaspack/types@2.15.1
-  - @atlaspack/plugin@2.14.11
-
 ## 2.14.10
 
 ### Patch Changes

package/lib/DevPackager.js

@@ -18,13 +18,6 @@ function _sourceMap() {
   };
   return data;
 }
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -115,17 +108,6 @@ class DevPackager {
             deps[specifier] = dep.specifier;
           }
         }
-        if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
-          // Add dependencies for parcelRequire calls added by runtimes
-          // so that the HMR runtime can correctly traverse parents.
-          let hmrDeps = asset.meta.hmrDeps;
-          if (this.options.hmrOptions && Array.isArray(hmrDeps)) {
-            for (let id of hmrDeps) {
-              (0, _assert().default)(typeof id === 'string');
-              deps[id] = id;
-            }
-          }
-        }
         let {
           code,
           mapBuffer

package/lib/ScopeHoistingPackager.js

@@ -99,12 +99,14 @@ class ScopeHoistingPackager {
   needsPrelude = false;
   usedHelpers = new Set();
   externalAssets = new Set();
-  constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime, logger) {
+  forceSkipWrapAssets = [];
+  constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime, forceSkipWrapAssets, logger) {
     this.options = options;
     this.bundleGraph = bundleGraph;
     this.bundle = bundle;
     this.parcelRequireName = parcelRequireName;
     this.useAsyncBundleRuntime = useAsyncBundleRuntime;
+    this.forceSkipWrapAssets = forceSkipWrapAssets ?? [];
     this.logger = logger;
     let OutputFormat = OUTPUT_FORMATS[this.bundle.env.outputFormat];
     this.outputFormat = new OutputFormat(this);
@@ -113,10 +115,7 @@ class ScopeHoistingPackager {
   }
   async package() {
     var _sourceMap;
-    let {
-      wrapped: wrappedAssets,
-      constant: constantAssets
-    } = await this.loadAssets();
+    let wrappedAssets = await this.loadAssets();
     this.buildExportedSymbols();
 
     // If building a library, the target is actually another bundler rather
@@ -128,6 +127,12 @@ class ScopeHoistingPackager {
       for (let b of this.bundleGraph.getReferencedBundles(this.bundle, {
         recursive: false
       })) {
+        // If the referenced bundle is a native node bundle then don't require it as
+        // an external as we don't want to require native node bundles from other
+        // OS architectures
+        if (process.env.ATLASPACK_SUPER_BUILD === 'true' && b.type === 'node') {
+          continue;
+        }
         this.externals.set((0, _utils().relativeBundlePath)(this.bundle, b), new Map());
       }
     }
@@ -144,14 +149,6 @@ class ScopeHoistingPackager {
       res += content + '\n';
       lineCount += lines + 1;
     };
-    if ((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') || (0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovement')) {
-      // Write out all constant modules used by this bundle
-      for (let asset of constantAssets) {
-        if (!this.seenAssets.has(asset.id)) {
-          processAsset(asset);
-        }
-      }
-    }
 
     // Hoist wrapped asset to the top of the bundle to ensure that they are registered
     // before they are used.
@@ -274,7 +271,6 @@ class ScopeHoistingPackager {
       maxConcurrent: 32
     });
     let wrapped = [];
-    let constant = [];
     this.bundle.traverseAssets(asset => {
       queue.add(async () => {
         let [code, map] = await Promise.all([asset.getCode(), this.bundle.env.sourceMap ? asset.getMapBuffer() : null]);
@@ -288,64 +284,38 @@ class ScopeHoistingPackager {
         if (!asset.meta.isConstantModule || this.bundleGraph.getIncomingDependencies(asset).some(dep => dep.priority === 'lazy')) {
           this.wrappedAssets.add(asset.id);
           wrapped.push(asset);
-        } else if (((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') || (0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovement')) && asset.meta.isConstantModule) {
-          constant.push(asset);
         }
       }
     });
-    if ((0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovement')) {
-      // Tracks which assets have been assigned to a wrap group
-      let assignedAssets = new Set();
-      for (let wrappedAsset of wrapped) {
-        this.bundle.traverseAssets((asset, _, actions) => {
-          if (asset === wrappedAsset) {
-            return;
-          }
-          if (this.wrappedAssets.has(asset.id)) {
-            actions.skipChildren();
-            return;
-          }
-          if (!asset.meta.isConstantModule && (assignedAssets.has(asset) || this.isReExported(asset))) {
-            wrapped.push(asset);
-            this.wrappedAssets.add(asset.id);
-            actions.skipChildren();
-            return;
-          }
-          assignedAssets.add(asset);
-        }, wrappedAsset);
-      }
-    } else {
-      for (let wrappedAssetRoot of [...wrapped]) {
-        this.bundle.traverseAssets((asset, _, actions) => {
-          if (asset === wrappedAssetRoot) {
-            return;
-          }
-          if (this.wrappedAssets.has(asset.id)) {
-            actions.skipChildren();
-            return;
-          }
-          if (!asset.meta.isConstantModule) {
-            this.wrappedAssets.add(asset.id);
-            wrapped.push(asset);
-          }
-        }, wrappedAssetRoot);
-      }
+    for (let wrappedAssetRoot of [...wrapped]) {
+      this.bundle.traverseAssets((asset, _, actions) => {
+        if (asset === wrappedAssetRoot) {
+          return;
+        }
+        if (this.wrappedAssets.has(asset.id)) {
+          actions.skipChildren();
+          return;
+        }
+        // This prevents children of a wrapped asset also being wrapped - it's an "unsafe" optimisation
+        // that should only be used when you know (or think you know) what you're doing.
+        //
+        // In particular this can force an async bundle to be scope hoisted where it previously would not be
+        // due to the entry asset being wrapped.
+        if (this.forceSkipWrapAssets.length > 0 && this.forceSkipWrapAssets.some(p => p === _path().default.relative(this.options.projectRoot, asset.filePath))) {
+          this.logger.verbose({
+            message: `Force skipping wrapping of ${_path().default.relative(this.options.projectRoot, asset.filePath)}`
+          });
+          actions.skipChildren();
+          return;
+        }
+        if (!asset.meta.isConstantModule) {
+          this.wrappedAssets.add(asset.id);
+          wrapped.push(asset);
+        }
+      }, wrappedAssetRoot);
     }
     this.assetOutputs = new Map(await queue.run());
-    return {
-      wrapped,
-      constant
-    };
-  }
-  isReExported(asset) {
-    let parentSymbols = this.bundleGraph.getIncomingDependencies(asset).map(dep => this.bundleGraph.getAssetWithDependency(dep)).flatMap(parent => {
-      if (parent == null) {
-        return [];
-      }
-      return this.bundleGraph.getExportedSymbols(parent, this.bundle);
-    });
-    let assetSymbols = this.bundleGraph.getExportedSymbols(asset, this.bundle);
-    return assetSymbols.some(assetSymbol => parentSymbols.some(parentSymbol => parentSymbol.symbol === assetSymbol.symbol));
+    return wrapped;
   }
   buildExportedSymbols() {
     if (!this.bundle.env.isLibrary || this.bundle.env.outputFormat !== 'esmodule') {
@@ -525,22 +495,13 @@ class ScopeHoistingPackager {
                 // outside our parcelRequire.register wrapper. This is safe because all
                 // assets referenced by this asset will also be wrapped. Otherwise, inline the
                 // asset content where the import statement was.
-                if ((0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovement')) {
-                  if (!resolved.meta.isConstantModule && !this.wrappedAssets.has(resolved.id)) {
-                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                    res = depCode + '\n' + res;
-                    lines += 1 + depLines;
-                    map = depMap;
-                  }
+                if (shouldWrap) {
+                  depContent.push(this.visitAsset(resolved));
                 } else {
-                  if (shouldWrap) {
-                    depContent.push(this.visitAsset(resolved));
-                  } else {
-                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                    res = depCode + '\n' + res;
-                    lines += 1 + depLines;
-                    map = depMap;
-                  }
+                  let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                  res = depCode + '\n' + res;
+                  lines += 1 + depLines;
+                  map = depMap;
                 }
               }
 
@@ -633,6 +594,14 @@ ${code}
           this.externalAssets.add(resolved);
           continue;
         }
+
+        // If the referencedBundle is a native node import then require it
+        // directly
+        // Only enabled for internal builds for now
+        if (process.env.ATLASPACK_SUPER_BUILD === 'true' && referencedBundle && referencedBundle.type === 'node') {
+          replacements.set((0, _nullthrows().default)(dep.symbols.get('*')).local, `require('${(0, _utils().relativeBundlePath)(this.bundle, referencedBundle)}')`);
+          continue;
+        }
       }
       for (let [imported, {
         local
@@ -919,26 +888,20 @@ ${code}
     // If there's no __esModule flag, and default is a used symbol, we need
     // to insert an interop helper.
     let defaultInterop = asset.symbols.hasExportSymbol('*') && usedSymbols.has('default') && !asset.symbols.hasExportSymbol('__esModule');
-    let usedNamespace;
-    if ((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') && asset.meta.isConstantModule) {
-      // Only set usedNamespace if there is an incoming dependency in the current bundle that uses '*'
-      usedNamespace = this.bundleGraph.getIncomingDependencies(asset).some(dep => this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'));
-    } else {
-      usedNamespace =
-      // If the asset has * in its used symbols, we might need the exports namespace.
-      // The one case where this isn't true is in ESM library entries, where the only
-      // dependency on * is the entry dependency. In this case, we will use ESM exports
-      // instead of the namespace object.
-      usedSymbols.has('*') && (this.bundle.env.outputFormat !== 'esmodule' || !this.bundle.env.isLibrary || asset !== this.bundle.getMainEntry() || this.bundleGraph.getIncomingDependencies(asset).some(dep => !dep.isEntry && this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'))) ||
-      // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
-      // we fallback on the namespace object.
-      asset.symbols.hasExportSymbol('*') && [...usedSymbols].some(s => !asset.symbols.hasExportSymbol(s)) ||
-      // If the exports has this asset's namespace (e.g. ESM output from CJS input),
-      // include the namespace object for the default export.
-      this.exportedSymbols.has(`$${assetId}$exports`) ||
-      // CommonJS library bundle entries always need a namespace.
-      this.bundle.env.isLibrary && this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry();
-    }
+    let usedNamespace =
+    // If the asset has * in its used symbols, we might need the exports namespace.
+    // The one case where this isn't true is in ESM library entries, where the only
+    // dependency on * is the entry dependency. In this case, we will use ESM exports
+    // instead of the namespace object.
+    usedSymbols.has('*') && (this.bundle.env.outputFormat !== 'esmodule' || !this.bundle.env.isLibrary || asset !== this.bundle.getMainEntry() || this.bundleGraph.getIncomingDependencies(asset).some(dep => !dep.isEntry && this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'))) ||
+    // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
+    // we fallback on the namespace object.
+    asset.symbols.hasExportSymbol('*') && [...usedSymbols].some(s => !asset.symbols.hasExportSymbol(s)) ||
+    // If the exports has this asset's namespace (e.g. ESM output from CJS input),
+    // include the namespace object for the default export.
+    this.exportedSymbols.has(`$${assetId}$exports`) ||
+    // CommonJS library bundle entries always need a namespace.
+    this.bundle.env.isLibrary && this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry();
 
     // If the asset doesn't have static exports, should wrap, the namespace is used,
     // or we need default interop, then we need to synthesize a namespace object for

package/lib/index.js

@@ -47,6 +47,12 @@ const CONFIG_SCHEMA = {
   properties: {
     unstable_asyncBundleRuntime: {
       type: 'boolean'
+    },
+    unstable_forceSkipWrapAssets: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
     }
   },
   additionalProperties: false
@@ -56,7 +62,7 @@ var _default = exports.default = new (_plugin().Packager)({
     config,
     options
   }) {
-    var _conf$contents;
+    var _conf$contents, _conf$contents2;
     let packageKey = '@atlaspack/packager-js';
     let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
       packageKey
@@ -78,7 +84,8 @@ var _default = exports.default = new (_plugin().Packager)({
     let name = (packageName === null || packageName === void 0 ? void 0 : packageName.contents) ?? '';
     return {
       parcelRequireName: 'parcelRequire' + (0, _rust().hashString)(name).slice(-4),
-      unstable_asyncBundleRuntime: Boolean(conf === null || conf === void 0 || (_conf$contents = conf.contents) === null || _conf$contents === void 0 ? void 0 : _conf$contents.unstable_asyncBundleRuntime)
+      unstable_asyncBundleRuntime: Boolean(conf === null || conf === void 0 || (_conf$contents = conf.contents) === null || _conf$contents === void 0 ? void 0 : _conf$contents.unstable_asyncBundleRuntime),
+      unstable_forceSkipWrapAssets: (conf === null || conf === void 0 || (_conf$contents2 = conf.contents) === null || _conf$contents2 === void 0 ? void 0 : _conf$contents2.unstable_forceSkipWrapAssets) ?? []
     };
   },
   async package({
@@ -101,7 +108,7 @@ var _default = exports.default = new (_plugin().Packager)({
       }
     }
     if (contents == null) {
-      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName, (0, _nullthrows().default)(config).unstable_asyncBundleRuntime, logger) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName);
+      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName, (0, _nullthrows().default)(config).unstable_asyncBundleRuntime, (0, _nullthrows().default)(config).unstable_forceSkipWrapAssets, logger) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName);
       ({
         contents,
         map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/packager-js",
-  "version": "2.14.5-dev.1c70d50f9.99+1c70d50f9",
+  "version": "2.14.5-dev.69+67cb517ae",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -15,16 +15,16 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-dev.1c70d50f9.167+1c70d50f9",
-    "@atlaspack/feature-flags": "2.14.1-dev.1c70d50f9.167+1c70d50f9",
-    "@atlaspack/plugin": "2.14.5-dev.1c70d50f9.99+1c70d50f9",
-    "@atlaspack/rust": "3.2.1-dev.1c70d50f9.99+1c70d50f9",
-    "@atlaspack/types": "2.14.5-dev.1c70d50f9.99+1c70d50f9",
-    "@atlaspack/utils": "2.14.5-dev.1c70d50f9.99+1c70d50f9",
+    "@atlaspack/diagnostic": "2.14.1-dev.137+67cb517ae",
+    "@atlaspack/feature-flags": "2.14.1-dev.137+67cb517ae",
+    "@atlaspack/plugin": "2.14.5-dev.69+67cb517ae",
+    "@atlaspack/rust": "3.2.1-dev.69+67cb517ae",
+    "@atlaspack/types": "2.14.5-dev.69+67cb517ae",
+    "@atlaspack/utils": "2.14.5-dev.69+67cb517ae",
     "@parcel/source-map": "^2.1.1",
     "globals": "^13.2.0",
     "nullthrows": "^1.1.1"
   },
   "type": "commonjs",
-  "gitHead": "1c70d50f914cb662515b0b61053e51a06f3af234"
+  "gitHead": "67cb517ae793046fb5a0d2ef02ba74510fefccf3"
 }

package/src/DevPackager.js

@@ -8,7 +8,6 @@ import {
   normalizeSeparators,
 } from '@atlaspack/utils';
 import SourceMap from '@parcel/source-map';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 import invariant from 'assert';
 import path from 'path';
 import fs from 'fs';
@@ -113,18 +112,6 @@ export class DevPackager {
           }
         }
 
-        if (getFeatureFlag('hmrImprovements')) {
-          // Add dependencies for parcelRequire calls added by runtimes
-          // so that the HMR runtime can correctly traverse parents.
-          let hmrDeps = asset.meta.hmrDeps;
-          if (this.options.hmrOptions && Array.isArray(hmrDeps)) {
-            for (let id of hmrDeps) {
-              invariant(typeof id === 'string');
-              deps[id] = id;
-            }
-          }
-        }
-
         let {code, mapBuffer} = results[i];
         let output = code || '';
         wrapped +=

package/src/ScopeHoistingPackager.js

@@ -102,6 +102,7 @@ export class ScopeHoistingPackager {
   needsPrelude: boolean = false;
   usedHelpers: Set<string> = new Set();
   externalAssets: Set<Asset> = new Set();
+  forceSkipWrapAssets: Array<string> = [];
   logger: PluginLogger;
 
   constructor(
@@ -110,6 +111,7 @@ export class ScopeHoistingPackager {
     bundle: NamedBundle,
     parcelRequireName: string,
     useAsyncBundleRuntime: boolean,
+    forceSkipWrapAssets: Array<string>,
     logger: PluginLogger,
   ) {
     this.options = options;
@@ -117,6 +119,7 @@ export class ScopeHoistingPackager {
     this.bundle = bundle;
     this.parcelRequireName = parcelRequireName;
     this.useAsyncBundleRuntime = useAsyncBundleRuntime;
+    this.forceSkipWrapAssets = forceSkipWrapAssets ?? [];
     this.logger = logger;
 
     let OutputFormat = OUTPUT_FORMATS[this.bundle.env.outputFormat];
@@ -131,8 +134,7 @@ export class ScopeHoistingPackager {
   }
 
   async package(): Promise<{|contents: string, map: ?SourceMap|}> {
-    let {wrapped: wrappedAssets, constant: constantAssets} =
-      await this.loadAssets();
+    let wrappedAssets = await this.loadAssets();
     this.buildExportedSymbols();
 
     // If building a library, the target is actually another bundler rather
@@ -147,6 +149,13 @@ export class ScopeHoistingPackager {
       for (let b of this.bundleGraph.getReferencedBundles(this.bundle, {
         recursive: false,
       })) {
+        // If the referenced bundle is a native node bundle then don't require it as
+        // an external as we don't want to require native node bundles from other
+        // OS architectures
+        if (process.env.ATLASPACK_SUPER_BUILD === 'true' && b.type === 'node') {
+          continue;
+        }
+
         this.externals.set(relativeBundlePath(this.bundle, b), new Map());
       }
     }
@@ -166,18 +175,6 @@ export class ScopeHoistingPackager {
       lineCount += lines + 1;
     };
 
-    if (
-      getFeatureFlag('inlineConstOptimisationFix') ||
-      getFeatureFlag('applyScopeHoistingImprovement')
-    ) {
-      // Write out all constant modules used by this bundle
-      for (let asset of constantAssets) {
-        if (!this.seenAssets.has(asset.id)) {
-          processAsset(asset);
-        }
-      }
-    }
-
     // Hoist wrapped asset to the top of the bundle to ensure that they are registered
     // before they are used.
     for (let asset of wrappedAssets) {
@@ -364,20 +361,15 @@ export class ScopeHoistingPackager {
     return `$parcel$global.rwr(${params.join(', ')});`;
   }
 
-  async loadAssets(): Promise<{|
-    wrapped: Array<Asset>,
-    constant: Array<Asset>,
-  |}> {
+  async loadAssets(): Promise<Array<Asset>> {
     let queue = new PromiseQueue({maxConcurrent: 32});
     let wrapped = [];
-    let constant = [];
     this.bundle.traverseAssets((asset) => {
       queue.add(async () => {
         let [code, map] = await Promise.all([
           asset.getCode(),
           this.bundle.env.sourceMap ? asset.getMapBuffer() : null,
         ]);
-
         return [asset.id, {code, map}];
       });
 
@@ -398,87 +390,50 @@ export class ScopeHoistingPackager {
         ) {
           this.wrappedAssets.add(asset.id);
           wrapped.push(asset);
-        } else if (
-          (getFeatureFlag('inlineConstOptimisationFix') ||
-            getFeatureFlag('applyScopeHoistingImprovement')) &&
-          asset.meta.isConstantModule
-        ) {
-          constant.push(asset);
         }
       }
     });
 
-    if (getFeatureFlag('applyScopeHoistingImprovement')) {
-      // Tracks which assets have been assigned to a wrap group
-      let assignedAssets = new Set<Asset>();
-
-      for (let wrappedAsset of wrapped) {
-        this.bundle.traverseAssets((asset, _, actions) => {
-          if (asset === wrappedAsset) {
-            return;
-          }
-
-          if (this.wrappedAssets.has(asset.id)) {
-            actions.skipChildren();
-            return;
-          }
-
-          if (
-            !asset.meta.isConstantModule &&
-            (assignedAssets.has(asset) || this.isReExported(asset))
-          ) {
-            wrapped.push(asset);
-            this.wrappedAssets.add(asset.id);
-
-            actions.skipChildren();
-            return;
-          }
-
-          assignedAssets.add(asset);
-        }, wrappedAsset);
-      }
-    } else {
-      for (let wrappedAssetRoot of [...wrapped]) {
-        this.bundle.traverseAssets((asset, _, actions) => {
-          if (asset === wrappedAssetRoot) {
-            return;
-          }
-
-          if (this.wrappedAssets.has(asset.id)) {
-            actions.skipChildren();
-            return;
-          }
+    for (let wrappedAssetRoot of [...wrapped]) {
+      this.bundle.traverseAssets((asset, _, actions) => {
+        if (asset === wrappedAssetRoot) {
+          return;
+        }
 
-          if (!asset.meta.isConstantModule) {
-            this.wrappedAssets.add(asset.id);
-            wrapped.push(asset);
-          }
-        }, wrappedAssetRoot);
-      }
+        if (this.wrappedAssets.has(asset.id)) {
+          actions.skipChildren();
+          return;
+        }
+        // This prevents children of a wrapped asset also being wrapped - it's an "unsafe" optimisation
+        // that should only be used when you know (or think you know) what you're doing.
+        //
+        // In particular this can force an async bundle to be scope hoisted where it previously would not be
+        // due to the entry asset being wrapped.
+        if (
+          this.forceSkipWrapAssets.length > 0 &&
+          this.forceSkipWrapAssets.some(
+            (p) =>
+              p === path.relative(this.options.projectRoot, asset.filePath),
+          )
+        ) {
+          this.logger.verbose({
+            message: `Force skipping wrapping of ${path.relative(
+              this.options.projectRoot,
+              asset.filePath,
+            )}`,
+          });
+          actions.skipChildren();
+          return;
+        }
+        if (!asset.meta.isConstantModule) {
+          this.wrappedAssets.add(asset.id);
+          wrapped.push(asset);
+        }
+      }, wrappedAssetRoot);
     }
 
     this.assetOutputs = new Map(await queue.run());
-    return {wrapped, constant};
-  }
-
-  isReExported(asset: Asset): boolean {
-    let parentSymbols = this.bundleGraph
-      .getIncomingDependencies(asset)
-      .map((dep) => this.bundleGraph.getAssetWithDependency(dep))
-      .flatMap((parent) => {
-        if (parent == null) {
-          return [];
-        }
-        return this.bundleGraph.getExportedSymbols(parent, this.bundle);
-      });
-
-    let assetSymbols = this.bundleGraph.getExportedSymbols(asset, this.bundle);
-
-    return assetSymbols.some((assetSymbol) =>
-      parentSymbols.some(
-        (parentSymbol) => parentSymbol.symbol === assetSymbol.symbol,
-      ),
-    );
+    return wrapped;
   }
 
   buildExportedSymbols() {
@@ -713,27 +668,13 @@ export class ScopeHoistingPackager {
                   // outside our parcelRequire.register wrapper. This is safe because all
                   // assets referenced by this asset will also be wrapped. Otherwise, inline the
                   // asset content where the import statement was.
-                  if (getFeatureFlag('applyScopeHoistingImprovement')) {
-                    if (
-                      !resolved.meta.isConstantModule &&
-                      !this.wrappedAssets.has(resolved.id)
-                    ) {
-                      let [depCode, depMap, depLines] =
-                        this.visitAsset(resolved);
-                      res = depCode + '\n' + res;
-                      lines += 1 + depLines;
-                      map = depMap;
-                    }
+                  if (shouldWrap) {
+                    depContent.push(this.visitAsset(resolved));
                   } else {
-                    if (shouldWrap) {
-                      depContent.push(this.visitAsset(resolved));
-                    } else {
-                      let [depCode, depMap, depLines] =
-                        this.visitAsset(resolved);
-                      res = depCode + '\n' + res;
-                      lines += 1 + depLines;
-                      map = depMap;
-                    }
+                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                    res = depCode + '\n' + res;
+                    lines += 1 + depLines;
+                    map = depMap;
                   }
                 }
 
@@ -875,6 +816,21 @@ ${code}
           this.externalAssets.add(resolved);
           continue;
         }
+
+        // If the referencedBundle is a native node import then require it
+        // directly
+        // Only enabled for internal builds for now
+        if (
+          process.env.ATLASPACK_SUPER_BUILD === 'true' &&
+          referencedBundle &&
+          referencedBundle.type === 'node'
+        ) {
+          replacements.set(
+            nullthrows(dep.symbols.get('*')).local,
+            `require('${relativeBundlePath(this.bundle, referencedBundle)}')`,
+          );
+          continue;
+        }
       }
 
       for (let [imported, {local}] of dep.symbols) {
@@ -1286,49 +1242,34 @@ ${code}
       usedSymbols.has('default') &&
       !asset.symbols.hasExportSymbol('__esModule');
 
-    let usedNamespace;
-    if (
-      getFeatureFlag('inlineConstOptimisationFix') &&
-      asset.meta.isConstantModule
-    ) {
-      // Only set usedNamespace if there is an incoming dependency in the current bundle that uses '*'
-      usedNamespace = this.bundleGraph
-        .getIncomingDependencies(asset)
-        .some(
-          (dep) =>
-            this.bundle.hasDependency(dep) &&
-            nullthrows(this.bundleGraph.getUsedSymbols(dep)).has('*'),
-        );
-    } else {
-      usedNamespace =
-        // If the asset has * in its used symbols, we might need the exports namespace.
-        // The one case where this isn't true is in ESM library entries, where the only
-        // dependency on * is the entry dependency. In this case, we will use ESM exports
-        // instead of the namespace object.
-        (usedSymbols.has('*') &&
-          (this.bundle.env.outputFormat !== 'esmodule' ||
-            !this.bundle.env.isLibrary ||
-            asset !== this.bundle.getMainEntry() ||
-            this.bundleGraph
-              .getIncomingDependencies(asset)
-              .some(
-                (dep) =>
-                  !dep.isEntry &&
-                  this.bundle.hasDependency(dep) &&
-                  nullthrows(this.bundleGraph.getUsedSymbols(dep)).has('*'),
-              ))) ||
-        // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
-        // we fallback on the namespace object.
-        (asset.symbols.hasExportSymbol('*') &&
-          [...usedSymbols].some((s) => !asset.symbols.hasExportSymbol(s))) ||
-        // If the exports has this asset's namespace (e.g. ESM output from CJS input),
-        // include the namespace object for the default export.
-        this.exportedSymbols.has(`$${assetId}$exports`) ||
-        // CommonJS library bundle entries always need a namespace.
-        (this.bundle.env.isLibrary &&
-          this.bundle.env.outputFormat === 'commonjs' &&
-          asset === this.bundle.getMainEntry());
-    }
+    let usedNamespace =
+      // If the asset has * in its used symbols, we might need the exports namespace.
+      // The one case where this isn't true is in ESM library entries, where the only
+      // dependency on * is the entry dependency. In this case, we will use ESM exports
+      // instead of the namespace object.
+      (usedSymbols.has('*') &&
+        (this.bundle.env.outputFormat !== 'esmodule' ||
+          !this.bundle.env.isLibrary ||
+          asset !== this.bundle.getMainEntry() ||
+          this.bundleGraph
+            .getIncomingDependencies(asset)
+            .some(
+              (dep) =>
+                !dep.isEntry &&
+                this.bundle.hasDependency(dep) &&
+                nullthrows(this.bundleGraph.getUsedSymbols(dep)).has('*'),
+            ))) ||
+      // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
+      // we fallback on the namespace object.
+      (asset.symbols.hasExportSymbol('*') &&
+        [...usedSymbols].some((s) => !asset.symbols.hasExportSymbol(s))) ||
+      // If the exports has this asset's namespace (e.g. ESM output from CJS input),
+      // include the namespace object for the default export.
+      this.exportedSymbols.has(`$${assetId}$exports`) ||
+      // CommonJS library bundle entries always need a namespace.
+      (this.bundle.env.isLibrary &&
+        this.bundle.env.outputFormat === 'commonjs' &&
+        asset === this.bundle.getMainEntry());
 
     // If the asset doesn't have static exports, should wrap, the namespace is used,
     // or we need default interop, then we need to synthesize a namespace object for

package/src/index.js

@@ -17,6 +17,7 @@ import {ScopeHoistingPackager} from './ScopeHoistingPackager';
 type JSPackagerConfig = {|
   parcelRequireName: string,
   unstable_asyncBundleRuntime: boolean,
+  unstable_forceSkipWrapAssets: Array<string>,
 |};
 
 const CONFIG_SCHEMA: SchemaEntity = {
@@ -25,6 +26,12 @@ const CONFIG_SCHEMA: SchemaEntity = {
     unstable_asyncBundleRuntime: {
       type: 'boolean',
     },
+    unstable_forceSkipWrapAssets: {
+      type: 'array',
+      items: {
+        type: 'string',
+      },
+    },
   },
   additionalProperties: false,
 };
@@ -66,6 +73,8 @@ export default (new Packager({
       unstable_asyncBundleRuntime: Boolean(
         conf?.contents?.unstable_asyncBundleRuntime,
       ),
+      unstable_forceSkipWrapAssets:
+        conf?.contents?.unstable_forceSkipWrapAssets ?? [],
     };
   },
   async package({
@@ -99,6 +108,7 @@ export default (new Packager({
             bundle,
             nullthrows(config).parcelRequireName,
             nullthrows(config).unstable_asyncBundleRuntime,
+            nullthrows(config).unstable_forceSkipWrapAssets,
             logger,
           )
         : new DevPackager(