@atlaspack/packager-js 2.14.5-canary.36 → 2.14.5-canary.361

package/src/{ScopeHoistingPackager.js → ScopeHoistingPackager.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   Asset,
   BundleGraph,
@@ -15,8 +13,10 @@ import {
   relativeBundlePath,
   countLines,
   normalizeSeparators,
+  debugTools,
+  globToRegex,
 } from '@atlaspack/utils';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import nullthrows from 'nullthrows';
 import invariant, {AssertionError} from 'assert';
 import ThrowableDiagnostic, {
@@ -25,11 +25,18 @@ import ThrowableDiagnostic, {
 import globals from 'globals';
 import path from 'path';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {outdent} from 'outdent';
 
 import {ESMOutputFormat} from './ESMOutputFormat';
 import {CJSOutputFormat} from './CJSOutputFormat';
 import {GlobalOutputFormat} from './GlobalOutputFormat';
-import {prelude, helpers, bundleQueuePrelude, fnExpr} from './helpers';
+import {
+  preludeOld,
+  preludeNew,
+  helpers,
+  bundleQueuePrelude,
+  fnExpr,
+} from './helpers';
 import {
   replaceScriptDependencies,
   getSpecifier,
@@ -39,7 +46,6 @@ import {
 
 // General regex used to replace imports with the resolved code, references with resolutions,
 // and count the number of newlines in the file for source maps.
-//
 // For conditional bundling the only difference in this regex is adding `importCond` where we have `importAsync` etc..
 const REPLACEMENT_RE_CONDITIONAL =
   /\n|import\s+"([0-9a-f]{16,20}:.+?)";|(?:\$[0-9a-f]{16,20}\$exports)|(?:\$[0-9a-f]{16,20}\$(?:import|importAsync|require|importCond)\$[0-9a-f]+(?:\$[0-9a-f]+)?)/g;
@@ -55,6 +61,7 @@ const GLOBALS_BY_CONTEXT = {
     ...Object.keys(globals.serviceworker),
   ]),
   worklet: new Set([...BUILTINS]),
+  tesseract: new Set([...BUILTINS, ...Object.keys(globals.worker)]),
   node: new Set([...BUILTINS, ...Object.keys(globals.node)]),
   'electron-main': new Set([...BUILTINS, ...Object.keys(globals.node)]),
   'electron-renderer': new Set([
@@ -62,19 +69,28 @@ const GLOBALS_BY_CONTEXT = {
     ...Object.keys(globals.node),
     ...Object.keys(globals.browser),
   ]),
-};
+} as const;
 
 const OUTPUT_FORMATS = {
   esmodule: ESMOutputFormat,
   commonjs: CJSOutputFormat,
   global: GlobalOutputFormat,
-};
+} as const;
 
 export interface OutputFormat {
   buildBundlePrelude(): [string, number];
   buildBundlePostlude(): [string, number];
 }
 
+export type PackageResult = {
+  contents: string;
+  map: SourceMap | null | undefined;
+  scopeHoistingStats?: {
+    totalAssets: number;
+    wrappedAssets: number;
+  };
+};
+
 export class ScopeHoistingPackager {
   options: PluginOptions;
   bundleGraph: BundleGraph<NamedBundle>;
@@ -83,27 +99,39 @@ export class ScopeHoistingPackager {
   useAsyncBundleRuntime: boolean;
   outputFormat: OutputFormat;
   isAsyncBundle: boolean;
-  globalNames: $ReadOnlySet<string>;
-  assetOutputs: Map<string, {|code: string, map: ?Buffer|}>;
+  globalNames: ReadonlySet<string>;
+  manualStaticBindingExports: RegExp[] | null;
+  assetOutputs: Map<
+    Asset,
+    {
+      code: string;
+      map: Buffer | null | undefined;
+    }
+  > = new Map();
   exportedSymbols: Map<
     string,
-    {|
-      asset: Asset,
-      exportSymbol: string,
-      local: string,
-      exportAs: Array<string>,
-    |},
+    {
+      asset: Asset;
+      exportSymbol: string;
+      local: string;
+      exportAs: Array<string>;
+    }
   > = new Map();
   externals: Map<string, Map<string, string>> = new Map();
   topLevelNames: Map<string, number> = new Map();
-  seenAssets: Set<string> = new Set();
-  wrappedAssets: Set<string> = new Set();
-  hoistedRequires: Map<string, Map<string, string>> = new Map();
+  seenAssets: Set<Asset> = new Set();
+  wrappedAssets: Set<Asset> = new Set();
+  constantAssets: Set<Asset> = new Set();
+  hoistedRequires: Map<Dependency, Map<Asset, string>> = new Map();
+  seenHoistedRequires: Set<string> = new Set();
   needsPrelude: boolean = false;
   usedHelpers: Set<string> = new Set();
   externalAssets: Set<Asset> = new Set();
-  forceSkipWrapAssets: Array<string> = [];
   logger: PluginLogger;
+  useBothScopeHoistingImprovements: boolean =
+    getFeatureFlag('applyScopeHoistingImprovementV2') ||
+    getFeatureFlag('applyScopeHoistingImprovement');
+  referencedAssetsCache: Map<string, Set<Asset>> = new Map();
 
   constructor(
     options: PluginOptions,
@@ -111,7 +139,7 @@ export class ScopeHoistingPackager {
     bundle: NamedBundle,
     parcelRequireName: string,
     useAsyncBundleRuntime: boolean,
-    forceSkipWrapAssets: Array<string>,
+    manualStaticBindingExports: string[] | null,
     logger: PluginLogger,
   ) {
     this.options = options;
@@ -119,7 +147,8 @@ export class ScopeHoistingPackager {
     this.bundle = bundle;
     this.parcelRequireName = parcelRequireName;
     this.useAsyncBundleRuntime = useAsyncBundleRuntime;
-    this.forceSkipWrapAssets = forceSkipWrapAssets ?? [];
+    this.manualStaticBindingExports =
+      manualStaticBindingExports?.map((glob) => globToRegex(glob)) ?? null;
     this.logger = logger;
 
     let OutputFormat = OUTPUT_FORMATS[this.bundle.env.outputFormat];
@@ -128,13 +157,14 @@ export class ScopeHoistingPackager {
     this.isAsyncBundle =
       this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') &&
       !this.bundle.env.isIsolated() &&
-      this.bundle.bundleBehavior !== 'isolated';
+      this.bundle.bundleBehavior !== 'isolated' &&
+      this.bundle.bundleBehavior !== 'inlineIsolated';
 
     this.globalNames = GLOBALS_BY_CONTEXT[bundle.env.context];
   }
 
-  async package(): Promise<{|contents: string, map: ?SourceMap|}> {
-    let wrappedAssets = await this.loadAssets();
+  async package(): Promise<PackageResult> {
+    await this.loadAssets();
     this.buildExportedSymbols();
 
     // If building a library, the target is actually another bundler rather
@@ -155,9 +185,11 @@ export class ScopeHoistingPackager {
 
     let res = '';
     let lineCount = 0;
-    let sourceMap = null;
-    let processAsset = (asset) => {
+    let sourceMap: SourceMap | null | undefined = null;
+    let processAsset = (asset: Asset) => {
+      this.seenHoistedRequires.clear();
       let [content, map, lines] = this.visitAsset(asset);
+
       if (sourceMap && map) {
         sourceMap.addSourceMap(map, lineCount);
       } else if (this.bundle.env.sourceMap) {
@@ -168,10 +200,22 @@ export class ScopeHoistingPackager {
       lineCount += lines + 1;
     };
 
+    if (
+      getFeatureFlag('inlineConstOptimisationFix') ||
+      this.useBothScopeHoistingImprovements
+    ) {
+      // Write out all constant modules used by this bundle
+      for (let asset of this.constantAssets) {
+        if (!this.seenAssets.has(asset)) {
+          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) {
-      if (!this.seenAssets.has(asset.id)) {
+    for (let asset of this.wrappedAssets) {
+      if (!this.seenAssets.has(asset)) {
         processAsset(asset);
       }
     }
@@ -179,7 +223,7 @@ export class ScopeHoistingPackager {
     // Add each asset that is directly connected to the bundle. Dependencies will be handled
     // by replacing `import` statements in the code.
     this.bundle.traverseAssets((asset, _, actions) => {
-      if (this.seenAssets.has(asset.id)) {
+      if (this.seenAssets.has(asset)) {
         actions.skipChildren();
         return;
       }
@@ -191,14 +235,28 @@ export class ScopeHoistingPackager {
     let [prelude, preludeLines] = this.buildBundlePrelude();
     res = prelude + res;
     lineCount += preludeLines;
+    // @ts-expect-error TS2339 - offsetLines method exists but missing from @parcel/source-map type definitions
     sourceMap?.offsetLines(1, preludeLines);
 
     let entries = this.bundle.getEntryAssets();
     let mainEntry = this.bundle.getMainEntry();
     if (this.isAsyncBundle) {
-      // In async bundles we don't want the main entry to execute until we require it
-      // as there might be dependencies in a sibling bundle that hasn't loaded yet.
-      entries = entries.filter((a) => a.id !== mainEntry?.id);
+      if (
+        this.useBothScopeHoistingImprovements ||
+        getFeatureFlag('supportWebpackChunkName')
+      ) {
+        // Generally speaking, async bundles should not be executed on load, as
+        // they're just collections of assets that other assets require.
+        // However, there are some special cases where a runtime asset needs to be
+        // injected, but no other asset will require it (mostly the bundle
+        // manifest).
+        // In this case, those assets need to be required on load.
+        entries = entries.filter(
+          (a) => a.meta?.runtimeAssetRequiringExecutionOnLoad,
+        );
+      } else {
+        entries = entries.filter((a) => a.id !== mainEntry?.id);
+      }
       mainEntry = null;
     }
 
@@ -206,7 +264,7 @@ export class ScopeHoistingPackager {
 
     // If any of the entry assets are wrapped, call parcelRequire so they are executed.
     for (let entry of entries) {
-      if (this.wrappedAssets.has(entry.id) && !this.isScriptEntry(entry)) {
+      if (this.wrappedAssets.has(entry) && !this.isScriptEntry(entry)) {
         let parcelRequire = `parcelRequire(${JSON.stringify(
           this.bundleGraph.getAssetPublicId(entry),
         )});\n`;
@@ -250,9 +308,7 @@ export class ScopeHoistingPackager {
       lineCount++;
 
       let mainEntry = nullthrows(this.bundle.getMainEntry());
-      let {code, map: mapBuffer} = nullthrows(
-        this.assetOutputs.get(mainEntry.id),
-      );
+      let {code, map: mapBuffer} = nullthrows(this.assetOutputs.get(mainEntry));
       let map;
       if (mapBuffer) {
         map = new SourceMap(this.options.projectRoot, mapBuffer);
@@ -265,14 +321,21 @@ export class ScopeHoistingPackager {
         this.parcelRequireName,
       );
       if (sourceMap && map) {
+        // @ts-expect-error TS2339 - addSourceMap method exists but missing from @parcel/source-map type definitions
         sourceMap.addSourceMap(map, lineCount);
       }
     }
 
-    return {
-      contents: res,
-      map: sourceMap,
-    };
+    const result: PackageResult = {contents: res, map: sourceMap};
+
+    if (debugTools['scope-hoisting-stats']) {
+      result.scopeHoistingStats = {
+        totalAssets: this.assetOutputs.size,
+        wrappedAssets: this.wrappedAssets.size,
+      };
+    }
+
+    return result;
   }
 
   shouldBundleQueue(bundle: NamedBundle): boolean {
@@ -281,10 +344,7 @@ export class ScopeHoistingPackager {
 
     let hasConditionalReference = false;
     let isConditionalBundle = false;
-    if (
-      getFeatureFlag('conditionalBundlingApi') &&
-      getFeatureFlag('conditionalBundlingAsyncRuntime')
-    ) {
+    if (getFeatureFlag('conditionalBundlingApi')) {
       // If the bundle has a conditional bundle reference (has an importCond)
       hasConditionalReference =
         this.bundleGraph.getReferencedConditionalBundles(bundle).length > 0;
@@ -296,6 +356,7 @@ export class ScopeHoistingPackager {
       this.useAsyncBundleRuntime &&
       bundle.type === 'js' &&
       bundle.bundleBehavior !== 'inline' &&
+      bundle.bundleBehavior !== 'inlineIsolated' &&
       bundle.env.outputFormat === 'esmodule' &&
       !bundle.env.isIsolated() &&
       bundle.bundleBehavior !== 'isolated' &&
@@ -309,11 +370,8 @@ export class ScopeHoistingPackager {
       .filter((b) => this.shouldBundleQueue(b))
       .map((b) => b.publicId);
 
-    const conditions = [];
-    if (
-      getFeatureFlag('conditionalBundlingApi') &&
-      getFeatureFlag('conditionalBundlingAsyncRuntime')
-    ) {
+    const conditions: Array<string> = [];
+    if (getFeatureFlag('conditionalBundlingApi')) {
       const conditionSet = this.bundleGraph
         .getConditionalBundleMapping()
         .get(bundle.id);
@@ -354,22 +412,58 @@ export class ScopeHoistingPackager {
     return `$parcel$global.rwr(${params.join(', ')});`;
   }
 
-  async loadAssets(): Promise<Array<Asset>> {
-    let queue = new PromiseQueue({maxConcurrent: 32});
-    let wrapped = [];
+  // Helper to check if an asset is referenced, with cache-first + fast-check hybrid approach
+  isAssetReferencedInBundle(bundle: NamedBundle, asset: Asset): boolean {
+    // STEP 1: Check expensive computation cache first (fastest when it hits)
+
+    let bundleId = bundle.id;
+    let referencedAssets = this.referencedAssetsCache.get(bundleId);
+
+    if (referencedAssets) {
+      // Cache hit - fastest path (~0.001ms)
+      return referencedAssets.has(asset);
+    }
+
+    // STEP 2: Cache miss - try fast checks (~0.01ms)
+    let fastCheckResult = this.bundleGraph.isAssetReferencedFastCheck(
+      bundle,
+      asset,
+    );
+
+    if (fastCheckResult === true) {
+      // Fast check succeeded - asset is referenced
+      return true;
+    }
+
+    // STEP 3: Need expensive computation (~20-2000ms)
+
+    // Compute and cache expensive results for this bundle
+    referencedAssets = this.bundleGraph.getReferencedAssets(bundle);
+    this.referencedAssetsCache.set(bundleId, referencedAssets);
+
+    return referencedAssets.has(asset);
+  }
+
+  async loadAssets() {
+    type QueueItem = [Asset, {code: string; map: Buffer | undefined | null}];
+    let queue = new PromiseQueue<QueueItem>({
+      maxConcurrent: 32,
+    });
+
     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}];
+
+        return [asset, {code, map}];
       });
 
       if (
         asset.meta.shouldWrap ||
         this.bundle.env.sourceType === 'script' ||
-        this.bundleGraph.isAssetReferenced(this.bundle, asset) ||
+        this.isAssetReferencedInBundle(this.bundle, asset) ||
         this.bundleGraph
           .getIncomingDependencies(asset)
           .some((dep) => dep.meta.shouldWrap && dep.specifierType !== 'url')
@@ -381,52 +475,113 @@ export class ScopeHoistingPackager {
             .getIncomingDependencies(asset)
             .some((dep) => dep.priority === 'lazy')
         ) {
-          this.wrappedAssets.add(asset.id);
-          wrapped.push(asset);
+          this.wrappedAssets.add(asset);
+        } else if (
+          (getFeatureFlag('inlineConstOptimisationFix') ||
+            this.useBothScopeHoistingImprovements) &&
+          asset.meta.isConstantModule
+        ) {
+          this.constantAssets.add(asset);
         }
       }
     });
 
-    for (let wrappedAssetRoot of [...wrapped]) {
-      this.bundle.traverseAssets((asset, _, actions) => {
-        if (asset === wrappedAssetRoot) {
-          return;
+    if (this.useBothScopeHoistingImprovements) {
+      // Tracks which assets have been assigned to a wrap group
+      let assignedAssets = new Set<Asset>();
+
+      // In V2 scope hoisting, we iterate from the main entry, rather than
+      // wrapping the entry assets
+      if (!getFeatureFlag('applyScopeHoistingImprovementV2')) {
+        // Make all entry assets wrapped, to avoid any top level hoisting
+        for (let entryAsset of this.bundle.getEntryAssets()) {
+          if (!this.wrappedAssets.has(entryAsset)) {
+            this.wrappedAssets.add(entryAsset);
+          }
         }
+      }
 
-        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);
+      // We need to make a new copy here so that we can add to the list and
+      // iterate the newly added items, without mutating the wrappedAssets set
+      let moduleGroupParents = [...this.wrappedAssets.values()];
+
+      if (getFeatureFlag('applyScopeHoistingImprovementV2')) {
+        // The main entry needs to be check to find assets that would have gone in
+        // the top level scope
+        let mainEntry = this.bundle.getMainEntry();
+        if (mainEntry && !this.wrappedAssets.has(mainEntry)) {
+          moduleGroupParents.unshift(mainEntry);
         }
-      }, wrappedAssetRoot);
+      }
+
+      for (let moduleGroupParentAsset of moduleGroupParents) {
+        this.bundle.traverseAssets((asset, _, actions) => {
+          if (asset === moduleGroupParentAsset) {
+            return;
+          }
+
+          if (this.wrappedAssets.has(asset)) {
+            actions.skipChildren();
+            return;
+          }
+
+          if (
+            !asset.meta.isConstantModule &&
+            (assignedAssets.has(asset) || this.isReExported(asset))
+          ) {
+            this.wrappedAssets.add(asset);
+
+            // This also needs to be added to the traversal so that we iterate
+            // it during this check.
+            moduleGroupParents.push(asset);
+
+            actions.skipChildren();
+            return;
+          }
+
+          assignedAssets.add(asset);
+        }, moduleGroupParentAsset);
+      }
+    } else {
+      for (let wrappedAssetRoot of this.wrappedAssets) {
+        this.bundle.traverseAssets((asset, _, actions) => {
+          if (asset === wrappedAssetRoot) {
+            return;
+          }
+
+          if (this.wrappedAssets.has(asset)) {
+            actions.skipChildren();
+            return;
+          }
+
+          if (!asset.meta.isConstantModule) {
+            this.wrappedAssets.add(asset);
+          }
+        }, wrappedAssetRoot);
+      }
     }
 
     this.assetOutputs = new Map(await queue.run());
-    return wrapped;
+  }
+
+  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,
+      ),
+    );
   }
 
   buildExportedSymbols() {
@@ -439,7 +594,7 @@ export class ScopeHoistingPackager {
 
     // TODO: handle ESM exports of wrapped entry assets...
     let entry = this.bundle.getMainEntry();
-    if (entry && !this.wrappedAssets.has(entry.id)) {
+    if (entry && !this.wrappedAssets.has(entry)) {
       let hasNamespace = entry.symbols.hasExportSymbol('*');
 
       for (let {
@@ -464,6 +619,7 @@ export class ScopeHoistingPackager {
             symbols = [];
             this.exportedSymbols.set(symbol, {
               asset,
+
               exportSymbol,
               local: symbol,
               exportAs: symbols,
@@ -519,20 +675,24 @@ export class ScopeHoistingPackager {
     return `${obj}[${JSON.stringify(property)}]`;
   }
 
-  visitAsset(asset: Asset): [string, ?SourceMap, number] {
-    invariant(!this.seenAssets.has(asset.id), 'Already visited asset');
-    this.seenAssets.add(asset.id);
+  visitAsset(asset: Asset): [string, SourceMap | null | undefined, number] {
+    invariant(!this.seenAssets.has(asset), 'Already visited asset');
+    this.seenAssets.add(asset);
 
-    let {code, map} = nullthrows(this.assetOutputs.get(asset.id));
+    let {code, map} = nullthrows(this.assetOutputs.get(asset));
     return this.buildAsset(asset, code, map);
   }
 
+  getAssetFilePath(asset: Asset): string {
+    return path.relative(this.options.projectRoot, asset.filePath);
+  }
+
   buildAsset(
     asset: Asset,
     code: string,
-    map: ?Buffer,
-  ): [string, ?SourceMap, number] {
-    let shouldWrap = this.wrappedAssets.has(asset.id);
+    map?: Buffer | null,
+  ): [string, SourceMap | null | undefined, number] {
+    let shouldWrap = this.wrappedAssets.has(asset);
     let deps = this.bundleGraph.getDependencies(asset);
 
     let sourceMap =
@@ -559,16 +719,29 @@ export class ScopeHoistingPackager {
           continue;
         }
 
-        if (
-          this.bundle.hasAsset(resolved) &&
-          !this.seenAssets.has(resolved.id)
-        ) {
-          let [code, map, lines] = this.visitAsset(resolved);
-          depCode += code + '\n';
-          if (sourceMap && map) {
-            sourceMap.addSourceMap(map, lineCount);
+        if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved)) {
+          if (
+            this.useBothScopeHoistingImprovements &&
+            this.wrappedAssets.has(resolved)
+          ) {
+            if (this.wrappedAssets.has(asset)) {
+              // If both the asset and the dep are wrapped there's no need to
+              // drop a side-effect require. This is an extremely rare case.
+              continue;
+            }
+
+            // When the dep is wrapped then we just need to drop a side effect
+            // require instead of inlining
+            depCode += `parcelRequire("${this.bundleGraph.getAssetPublicId(resolved)}");\n`;
+            lineCount += 1;
+          } else {
+            let [code, map, lines] = this.visitAsset(resolved);
+            depCode += code + '\n';
+            if (sourceMap && map) {
+              sourceMap.addSourceMap(map, lineCount);
+            }
+            lineCount += lines + 1;
           }
-          lineCount += lines + 1;
         }
       }
 
@@ -602,7 +775,7 @@ export class ScopeHoistingPackager {
     code += append;
 
     let lineCount = 0;
-    let depContent = [];
+    let depContent: Array<[string, SourceMap | null | undefined, number]> = [];
     if (depMap.size === 0 && replacements.size === 0) {
       // If there are no dependencies or replacements, use a simple function to count the number of lines.
       lineCount = countLines(code) - 1;
@@ -647,27 +820,68 @@ export class ScopeHoistingPackager {
                 // after the dependency is declared. This handles the case where the resulting asset
                 // is wrapped, but the dependency in this asset is not marked as wrapped. This means
                 // that it was imported/required at the top-level, so its side effects should run immediately.
-                let [res, lines] = this.getHoistedParcelRequires(
-                  asset,
-                  dep,
-                  resolved,
-                );
+                let res = '';
+                let lines = 0;
                 let map;
+
+                if (!getFeatureFlag('applyScopeHoistingImprovementV2')) {
+                  [res, lines] = this.getHoistedParcelRequires(
+                    asset,
+                    dep,
+                    resolved,
+                  );
+                }
+
                 if (
                   this.bundle.hasAsset(resolved) &&
-                  !this.seenAssets.has(resolved.id)
+                  !this.seenAssets.has(resolved)
                 ) {
                   // If this asset is wrapped, we need to hoist the code for the dependency
                   // 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 (shouldWrap) {
-                    depContent.push(this.visitAsset(resolved));
+                  if (this.useBothScopeHoistingImprovements) {
+                    if (
+                      !resolved.meta.isConstantModule &&
+                      !this.wrappedAssets.has(resolved)
+                    ) {
+                      let [depCode, depMap, depLines] =
+                        this.visitAsset(resolved);
+                      if (debugTools['asset-file-names-in-output']) {
+                        let resolvedPath = this.getAssetFilePath(resolved);
+                        res = outdent`
+                          /* Scope hoisted asset: ${resolvedPath} */
+                          ${depCode}
+                          /* End: ${resolvedPath} */
+                          ${res}
+                        `;
+                        lines += 3 + depLines;
+                      } else {
+                        res = depCode + '\n' + res;
+                        lines += 1 + depLines;
+                      }
+                      map = depMap;
+                    }
                   } else {
-                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                    res = depCode + '\n' + res;
-                    lines += 1 + depLines;
-                    map = depMap;
+                    if (shouldWrap) {
+                      depContent.push(this.visitAsset(resolved));
+                    } else {
+                      let [depCode, depMap, depLines] =
+                        this.visitAsset(resolved);
+                      res = depCode + '\n' + res;
+                      lines += 1 + depLines;
+                      map = depMap;
+                    }
+                  }
+                }
+
+                if (getFeatureFlag('applyScopeHoistingImprovementV2')) {
+                  let [requiresCode, requiresLines] =
+                    this.getHoistedParcelRequires(asset, dep, resolved);
+
+                  if (requiresCode) {
+                    res = requiresCode + '\n' + res;
+                    lines += requiresLines + 1;
                   }
                 }
 
@@ -726,6 +940,11 @@ ${code}
 
       lineCount += 2;
 
+      if (debugTools['asset-file-names-in-output']) {
+        code = `/* ${this.getAssetFilePath(asset)} */\n` + code;
+        lineCount += 1;
+      }
+
       for (let [depCode, map, lines] of depContent) {
         if (!depCode) continue;
         code += depCode + '\n';
@@ -803,7 +1022,7 @@ ${code}
           referencedBundle &&
           referencedBundle.getMainEntry() === resolved &&
           referencedBundle.type === 'js' &&
-          !this.bundleGraph.isAssetReferenced(referencedBundle, resolved)
+          !this.isAssetReferencedInBundle(referencedBundle, resolved)
         ) {
           this.addExternal(dep, replacements, referencedBundle);
           this.externalAssets.add(resolved);
@@ -848,7 +1067,7 @@ ${code}
     // If this asset is wrapped, we need to replace the exports namespace with `module.exports`,
     // which will be provided to us by the wrapper.
     if (
-      this.wrappedAssets.has(asset.id) ||
+      this.wrappedAssets.has(asset) ||
       (this.bundle.env.outputFormat === 'commonjs' &&
         asset === this.bundle.getMainEntry())
     ) {
@@ -895,7 +1114,9 @@ ${code}
 
     for (let [imported, {local}] of dep.symbols) {
       // If already imported, just add the already renamed variable to the mapping.
+
       let renamed = external.get(imported);
+
       if (renamed && local !== '*' && replacements) {
         replacements.set(local, renamed);
         continue;
@@ -908,6 +1129,7 @@ ${code}
         if (!renamed) {
           if (referencedBundle) {
             let entry = nullthrows(referencedBundle.getMainEntry());
+
             renamed =
               entry.symbols.get('*')?.local ??
               `$${String(entry.meta.id)}$exports`;
@@ -922,6 +1144,7 @@ ${code}
 
         if (local !== '*' && replacements) {
           let replacement;
+
           if (imported === '*') {
             replacement = renamed;
           } else if (imported === 'default') {
@@ -946,10 +1169,12 @@ ${code}
         let property;
         if (referencedBundle) {
           let entry = nullthrows(referencedBundle.getMainEntry());
+
           if (entry.symbols.hasExportSymbol('*')) {
             // If importing * and the referenced module has a * export (e.g. CJS), use default instead.
             // This mirrors the logic in buildExportedSymbols.
             property = imported;
+
             imported =
               referencedBundle?.env.outputFormat === 'esmodule'
                 ? 'default'
@@ -957,6 +1182,7 @@ ${code}
           } else {
             if (imported === '*') {
               let exportedSymbols = this.bundleGraph.getExportedSymbols(entry);
+
               if (local === '*') {
                 // Re-export all symbols.
                 for (let exported of exportedSymbols) {
@@ -967,11 +1193,10 @@ ${code}
                 continue;
               }
             }
-            renamed = this.bundleGraph.getSymbolResolution(
-              entry,
-              imported,
-              this.bundle,
-            ).symbol;
+
+            renamed =
+              this.bundleGraph.getSymbolResolution(entry, imported, this.bundle)
+                .symbol || undefined;
           }
         }
 
@@ -993,8 +1218,10 @@ ${code}
         }
 
         external.set(imported, renamed);
+
         if (local !== '*' && replacements) {
           let replacement = renamed;
+
           if (property === '*') {
             replacement = renamed;
           } else if (property === 'default') {
@@ -1003,6 +1230,7 @@ ${code}
           } else if (property) {
             replacement = this.getPropertyAccess(renamed, property);
           }
+
           replacements.set(local, replacement);
         }
       }
@@ -1026,7 +1254,7 @@ ${code}
     }
     return (
       (!this.bundle.hasAsset(resolved) && !this.externalAssets.has(resolved)) ||
-      (this.wrappedAssets.has(resolved.id) && resolved !== parentAsset)
+      (this.wrappedAssets.has(resolved) && resolved !== parentAsset)
     );
   }
 
@@ -1076,14 +1304,14 @@ ${code}
       (!this.bundle.hasAsset(resolvedAsset) ||
         !this.shouldSkipAsset(resolvedAsset))
     ) {
-      let hoisted = this.hoistedRequires.get(dep.id);
+      let hoisted = this.hoistedRequires.get(dep);
       if (!hoisted) {
         hoisted = new Map();
-        this.hoistedRequires.set(dep.id, hoisted);
+        this.hoistedRequires.set(dep, hoisted);
       }
 
       hoisted.set(
-        resolvedAsset.id,
+        resolvedAsset,
         `var $${publicId} = parcelRequire(${JSON.stringify(publicId)});`,
       );
     }
@@ -1117,6 +1345,7 @@ ${code}
       obj = `$${publicId}`;
     } else {
       obj = resolvedAsset.symbols.get('*')?.local || `$${assetId}$exports`;
+
       obj = replacements?.get(obj) || obj;
     }
 
@@ -1124,7 +1353,7 @@ ${code}
       // Resolve to the namespace object if requested or this is a CJS default interop reqiure.
       if (
         parentAsset === resolvedAsset &&
-        this.wrappedAssets.has(resolvedAsset.id)
+        this.wrappedAssets.has(resolvedAsset)
       ) {
         // Directly use module.exports for wrapped assets importing themselves.
         return 'module.exports';
@@ -1152,7 +1381,16 @@ ${code}
         return this.getPropertyAccess(obj, exportSymbol);
       }
     } else if (!symbol) {
-      invariant(false, 'Asset was skipped or not found.');
+      let parentPath =
+        path.relative(this.options.projectRoot, parentAsset.filePath) ||
+        '<unknown>';
+      let resolvedPath =
+        path.relative(this.options.projectRoot, resolvedAsset.filePath) ||
+        '<unknown>';
+      invariant(
+        false,
+        `Asset was skipped or not found when packaging ${this.bundle.name}.\nSearching for exported symbol "${imported}" (resolved as "${exportSymbol}") in asset with id "${resolvedAsset.meta.id}" (public id: "${publicId}", path: "${resolvedPath}") from parent asset "${parentAsset.meta.id}" (path: "${parentPath}").`,
+      );
     } else {
       return replacements?.get(symbol) || symbol;
     }
@@ -1167,7 +1405,7 @@ ${code}
       return ['', 0];
     }
 
-    let hoisted = this.hoistedRequires.get(dep.id);
+    let hoisted = this.hoistedRequires.get(dep);
     let res = '';
     let lineCount = 0;
     let isWrapped = this.isWrapped(resolved, parentAsset);
@@ -1179,7 +1417,7 @@ ${code}
     if (
       isWrapped &&
       !dep.meta.shouldWrap &&
-      (!hoisted || hoisted.keys().next().value !== resolved.id) &&
+      (!hoisted || hoisted.keys().next().value !== resolved) &&
       !this.bundleGraph.isDependencySkipped(dep) &&
       !this.shouldSkipAsset(resolved)
     ) {
@@ -1191,8 +1429,22 @@ ${code}
 
     if (hoisted) {
       this.needsPrelude = true;
-      res += '\n' + [...hoisted.values()].join('\n');
-      lineCount += hoisted.size;
+
+      if (getFeatureFlag('applyScopeHoistingImprovementV2')) {
+        let hoistedValues = [...hoisted.values()].filter(
+          (val) => !this.seenHoistedRequires.has(val),
+        );
+
+        for (let val of hoistedValues) {
+          this.seenHoistedRequires.add(val);
+        }
+
+        res += '\n' + hoistedValues.join('\n');
+        lineCount += hoisted.size;
+      } else {
+        res += '\n' + [...hoisted.values()].join('\n');
+        lineCount += hoisted.size;
+      }
     }
 
     return [res, lineCount];
@@ -1207,7 +1459,7 @@ ${code}
     let prependLineCount = 0;
     let append = '';
 
-    let shouldWrap = this.wrappedAssets.has(asset.id);
+    let shouldWrap = this.wrappedAssets.has(asset);
     let usedSymbols = nullthrows(this.bundleGraph.getUsedSymbols(asset));
     let assetId = asset.meta.id;
     invariant(typeof assetId === 'string');
@@ -1220,34 +1472,51 @@ ${code}
       usedSymbols.has('default') &&
       !asset.symbols.hasExportSymbol('__esModule');
 
-    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());
+    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());
+    }
 
     // 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
@@ -1274,6 +1543,7 @@ ${code}
       // Insert the __esModule interop flag for this module if it has a `default` export
       // and the namespace symbol is used.
       // TODO: only if required by CJS?
+
       if (asset.symbols.hasExportSymbol('default') && usedSymbols.has('*')) {
         prepend += `\n$parcel$defineInteropFlag($${assetId}$exports);\n`;
         prependLineCount += 2;
@@ -1337,6 +1607,7 @@ ${code}
                 let resolvedSymbol = this.getSymbolResolution(
                   asset,
                   resolved,
+
                   symbol,
                   undefined,
                   replacements,
@@ -1388,28 +1659,39 @@ ${code}
         // for the symbol so that when the value changes the object property also changes. This is
         // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
         // additional assignments after each mutation of the original binding.
-        prepend += `\n${usedExports
-          .map((exp) => {
-            let resolved = this.getSymbolResolution(
-              asset,
-              asset,
+        for (let exp of usedExports) {
+          let resolved = this.getSymbolResolution(
+            asset,
+            asset,
+            exp,
+            undefined,
+            replacements,
+          );
+          const meta = asset.symbols.get(exp)?.meta;
+          if (
+            getFeatureFlag('exportsRebindingOptimisation') &&
+            (meta?.isStaticBindingSafe ||
+              this.manualStaticBindingExports?.some((regex) =>
+                regex.test(asset.filePath),
+              ))
+          ) {
+            append += `$${assetId}$exports[${JSON.stringify(
               exp,
-              undefined,
-              replacements,
-            );
+            )}] = ${resolved};\n`;
+          } else {
             let get = this.buildFunctionExpression([], resolved);
             let isEsmExport = !!asset.symbols.get(exp)?.meta?.isEsm;
             let set =
               !isEsmExport && asset.meta.hasCJSExports
                 ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`)
                 : '';
-            return `$parcel$export($${assetId}$exports, ${JSON.stringify(
+            prepend += `$parcel$export($${assetId}$exports, ${JSON.stringify(
               exp,
-            )}, ${get}${set});`;
-          })
-          .join('\n')}\n`;
-        this.usedHelpers.add('$parcel$export');
-        prependLineCount += 1 + usedExports.length;
+            )}, ${get}${set});\n`;
+            this.usedHelpers.add('$parcel$export');
+            prependLineCount += 1 + usedExports.length;
+          }
+        }
       }
     }
 
@@ -1448,9 +1730,11 @@ ${code}
     }
 
     for (let helper of this.usedHelpers) {
-      let currentHelper = helpers[helper];
+      let currentHelper = (helpers as Record<string, any>)[helper];
       if (typeof currentHelper === 'function') {
-        currentHelper = helpers[helper](this.bundle.env);
+        currentHelper = (helpers as Record<string, any>)[helper](
+          this.bundle.env,
+        );
       }
       res += currentHelper;
       if (enableSourceMaps) {
@@ -1470,11 +1754,14 @@ ${code}
           .some((g) => this.bundleGraph.isEntryBundleGroup(g)) ||
         this.bundle.env.isIsolated() ||
         this.bundle.bundleBehavior === 'isolated' ||
+        this.bundle.bundleBehavior === 'inlineIsolated' ||
         // Conditional deps may be loaded before entrypoints on the server
         this.hasConditionalDependency();
 
       if (mightBeFirstJS) {
-        let preludeCode = prelude(this.parcelRequireName);
+        let preludeCode = (
+          getFeatureFlag('useNewPrelude') ? preludeNew : preludeOld
+        )(this.parcelRequireName);
         res += preludeCode;
         if (enableSourceMaps) {
           lines += countLines(preludeCode) - 1;
@@ -1498,7 +1785,11 @@ ${code}
     }
 
     // Add importScripts for sibling bundles in workers.
-    if (this.bundle.env.isWorker() || this.bundle.env.isWorklet()) {
+    if (
+      this.bundle.env.isWorker() ||
+      this.bundle.env.isTesseract() ||
+      this.bundle.env.isWorklet()
+    ) {
       let importScripts = '';
       let bundles = this.bundleGraph.getReferencedBundles(this.bundle);
       for (let b of bundles) {
@@ -1539,7 +1830,7 @@ ${code}
     return (
       asset.sideEffects === false &&
       nullthrows(this.bundleGraph.getUsedSymbols(asset)).size == 0 &&
-      !this.bundleGraph.isAssetReferenced(this.bundle, asset)
+      !this.isAssetReferencedInBundle(this.bundle, asset)
     );
   }