@atlaspack/packager-js 2.14.5-canary.17 → 2.14.5-canary.171

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   Asset,
   BundleGraph,
@@ -15,6 +13,7 @@ import {
   relativeBundlePath,
   countLines,
   normalizeSeparators,
+  debugTools,
 } from '@atlaspack/utils';
 import SourceMap from '@parcel/source-map';
 import nullthrows from 'nullthrows';
@@ -25,6 +24,7 @@ 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';
@@ -39,7 +39,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 +54,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,13 +62,13 @@ 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];
@@ -83,16 +83,23 @@ export class ScopeHoistingPackager {
   useAsyncBundleRuntime: boolean;
   outputFormat: OutputFormat;
   isAsyncBundle: boolean;
-  globalNames: $ReadOnlySet<string>;
-  assetOutputs: Map<string, {|code: string, map: ?Buffer|}>;
+  globalNames: ReadonlySet<string>;
+  // @ts-expect-error TS2564
+  assetOutputs: Map<
+    string,
+    {
+      code: string;
+      map: Buffer | null | undefined;
+    }
+  >;
   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();
@@ -102,7 +109,6 @@ export class ScopeHoistingPackager {
   needsPrelude: boolean = false;
   usedHelpers: Set<string> = new Set();
   externalAssets: Set<Asset> = new Set();
-  forceSkipWrapAssets: Array<string> = [];
   logger: PluginLogger;
 
   constructor(
@@ -111,7 +117,6 @@ export class ScopeHoistingPackager {
     bundle: NamedBundle,
     parcelRequireName: string,
     useAsyncBundleRuntime: boolean,
-    forceSkipWrapAssets: Array<string>,
     logger: PluginLogger,
   ) {
     this.options = options;
@@ -119,7 +124,6 @@ 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];
@@ -128,13 +132,18 @@ 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<{
+    contents: string;
+    map: SourceMap | null | undefined;
+  }> {
+    let {wrapped: wrappedAssets, constant: constantAssets} =
+      await this.loadAssets();
     this.buildExportedSymbols();
 
     // If building a library, the target is actually another bundler rather
@@ -155,9 +164,11 @@ export class ScopeHoistingPackager {
 
     let res = '';
     let lineCount = 0;
+    // @ts-expect-error TS7034
     let sourceMap = null;
-    let processAsset = (asset) => {
+    let processAsset = (asset: Asset) => {
       let [content, map, lines] = this.visitAsset(asset);
+      // @ts-expect-error TS7005
       if (sourceMap && map) {
         sourceMap.addSourceMap(map, lineCount);
       } else if (this.bundle.env.sourceMap) {
@@ -168,6 +179,18 @@ 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) {
@@ -191,14 +214,28 @@ export class ScopeHoistingPackager {
     let [prelude, preludeLines] = this.buildBundlePrelude();
     res = prelude + res;
     lineCount += preludeLines;
+    // @ts-expect-error TS2339
     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 (
+        getFeatureFlag('applyScopeHoistingImprovement') ||
+        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;
     }
 
@@ -211,17 +248,20 @@ export class ScopeHoistingPackager {
           this.bundleGraph.getAssetPublicId(entry),
         )});\n`;
 
+        // @ts-expect-error TS2345
         let entryExports = entry.symbols.get('*')?.local;
 
         if (
           entryExports &&
           entry === mainEntry &&
+          // @ts-expect-error TS2345
           this.exportedSymbols.has(entryExports)
         ) {
           invariant(
             !needsBundleQueue,
             'Entry exports are not yet compaitble with async bundles',
           );
+          // @ts-expect-error TS2731
           res += `\nvar ${entryExports} = ${parcelRequire}`;
         } else {
           if (needsBundleQueue) {
@@ -265,6 +305,7 @@ export class ScopeHoistingPackager {
         this.parcelRequireName,
       );
       if (sourceMap && map) {
+        // @ts-expect-error TS2339
         sourceMap.addSourceMap(map, lineCount);
       }
     }
@@ -281,10 +322,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 +334,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 +348,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,15 +390,21 @@ export class ScopeHoistingPackager {
     return `$parcel$global.rwr(${params.join(', ')});`;
   }
 
-  async loadAssets(): Promise<Array<Asset>> {
+  async loadAssets(): Promise<{
+    wrapped: Array<Asset>;
+    constant: Array<Asset>;
+  }> {
     let queue = new PromiseQueue({maxConcurrent: 32});
-    let wrapped = [];
+    let wrapped: Array<Asset> = [];
+    let constant: Array<Asset> = [];
+
     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}];
       });
 
@@ -383,50 +425,96 @@ export class ScopeHoistingPackager {
         ) {
           this.wrappedAssets.add(asset.id);
           wrapped.push(asset);
+        } else if (
+          (getFeatureFlag('inlineConstOptimisationFix') ||
+            getFeatureFlag('applyScopeHoistingImprovement')) &&
+          asset.meta.isConstantModule
+        ) {
+          constant.push(asset);
         }
       }
     });
 
-    for (let wrappedAssetRoot of [...wrapped]) {
-      this.bundle.traverseAssets((asset, _, actions) => {
-        if (asset === wrappedAssetRoot) {
-          return;
+    if (getFeatureFlag('applyScopeHoistingImprovement')) {
+      // Make all entry assets wrapped, to avoid any top level hoisting
+      for (let entryAsset of this.bundle.getEntryAssets()) {
+        if (!this.wrappedAssets.has(entryAsset.id)) {
+          this.wrappedAssets.add(entryAsset.id);
+          wrapped.push(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);
-        }
-      }, wrappedAssetRoot);
+      // 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;
+          }
+
+          if (!asset.meta.isConstantModule) {
+            this.wrappedAssets.add(asset.id);
+            wrapped.push(asset);
+          }
+        }, wrappedAssetRoot);
+      }
     }
 
+    // @ts-expect-error TS2769
     this.assetOutputs = new Map(await queue.run());
-    return wrapped;
+    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,
+      ),
+    );
   }
 
   buildExportedSymbols() {
@@ -440,6 +528,7 @@ export class ScopeHoistingPackager {
     // TODO: handle ESM exports of wrapped entry assets...
     let entry = this.bundle.getMainEntry();
     if (entry && !this.wrappedAssets.has(entry.id)) {
+      // @ts-expect-error TS2345
       let hasNamespace = entry.symbols.hasExportSymbol('*');
 
       for (let {
@@ -457,6 +546,7 @@ export class ScopeHoistingPackager {
           }
 
           let symbols = this.exportedSymbols.get(
+            // @ts-expect-error TS2345
             symbol === '*' ? nullthrows(entry.symbols.get('*')?.local) : symbol,
           )?.exportAs;
 
@@ -464,6 +554,7 @@ export class ScopeHoistingPackager {
             symbols = [];
             this.exportedSymbols.set(symbol, {
               asset,
+              // @ts-expect-error TS2322
               exportSymbol,
               local: symbol,
               exportAs: symbols,
@@ -474,6 +565,7 @@ export class ScopeHoistingPackager {
             exportAs = 'default';
           }
 
+          // @ts-expect-error TS2345
           symbols.push(exportAs);
         } else if (symbol === null) {
           // TODO `meta.exportsIdentifier[exportSymbol]` should be exported
@@ -519,7 +611,7 @@ export class ScopeHoistingPackager {
     return `${obj}[${JSON.stringify(property)}]`;
   }
 
-  visitAsset(asset: Asset): [string, ?SourceMap, number] {
+  visitAsset(asset: Asset): [string, SourceMap | null | undefined, number] {
     invariant(!this.seenAssets.has(asset.id), 'Already visited asset');
     this.seenAssets.add(asset.id);
 
@@ -527,11 +619,15 @@ export class ScopeHoistingPackager {
     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] {
+    map?: Buffer | null,
+  ): [string, SourceMap | null | undefined, number] {
     let shouldWrap = this.wrappedAssets.has(asset.id);
     let deps = this.bundleGraph.getDependencies(asset);
 
@@ -566,6 +662,7 @@ export class ScopeHoistingPackager {
           let [code, map, lines] = this.visitAsset(resolved);
           depCode += code + '\n';
           if (sourceMap && map) {
+            // @ts-expect-error TS2551
             sourceMap.addSourceMap(map, lineCount);
           }
           lineCount += lines + 1;
@@ -602,7 +699,9 @@ export class ScopeHoistingPackager {
     code += append;
 
     let lineCount = 0;
-    let depContent = [];
+    // @ts-expect-error TS2552
+    let depContent: Array<[string, NodeSourceMap | 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;
@@ -661,13 +760,38 @@ 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 (shouldWrap) {
-                    depContent.push(this.visitAsset(resolved));
+                  if (getFeatureFlag('applyScopeHoistingImprovement')) {
+                    if (
+                      !resolved.meta.isConstantModule &&
+                      !this.wrappedAssets.has(resolved.id)
+                    ) {
+                      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;
+                    }
                   }
                 }
 
@@ -679,6 +803,7 @@ export class ScopeHoistingPackager {
                   }
 
                   if (map) {
+                    // @ts-expect-error TS2551
                     sourceMap.addSourceMap(map, lineCount);
                   }
                 }
@@ -726,10 +851,16 @@ ${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';
         if (sourceMap && map) {
+          // @ts-expect-error TS2551
           sourceMap.addSourceMap(map, lineCount);
         }
         lineCount += lines + 1;
@@ -812,10 +943,12 @@ ${code}
       }
 
       for (let [imported, {local}] of dep.symbols) {
+        // @ts-expect-error TS2367
         if (local === '*') {
           continue;
         }
 
+        // @ts-expect-error TS2345
         let symbol = this.getSymbolResolution(asset, resolved, imported, dep);
         replacements.set(
           local,
@@ -852,6 +985,7 @@ ${code}
       (this.bundle.env.outputFormat === 'commonjs' &&
         asset === this.bundle.getMainEntry())
     ) {
+      // @ts-expect-error TS2345
       let exportsName = asset.symbols.get('*')?.local || `$${assetId}$exports`;
       replacements.set(exportsName, 'module.exports');
     }
@@ -895,8 +1029,11 @@ ${code}
 
     for (let [imported, {local}] of dep.symbols) {
       // If already imported, just add the already renamed variable to the mapping.
+      // @ts-expect-error TS2345
       let renamed = external.get(imported);
+      // @ts-expect-error TS2367
       if (renamed && local !== '*' && replacements) {
+        // @ts-expect-error TS2345
         replacements.set(local, renamed);
         continue;
       }
@@ -908,7 +1045,9 @@ ${code}
         if (!renamed) {
           if (referencedBundle) {
             let entry = nullthrows(referencedBundle.getMainEntry());
+            // @ts-expect-error TS2322
             renamed =
+              // @ts-expect-error TS2345
               entry.symbols.get('*')?.local ??
               `$${String(entry.meta.id)}$exports`;
           } else {
@@ -917,13 +1056,17 @@ ${code}
             );
           }
 
+          // @ts-expect-error TS2345
           external.set('*', renamed);
         }
 
+        // @ts-expect-error TS2367
         if (local !== '*' && replacements) {
           let replacement;
+          // @ts-expect-error TS2367
           if (imported === '*') {
             replacement = renamed;
+            // @ts-expect-error TS2367
           } else if (imported === 'default') {
             let needsDefaultInterop = true;
             if (referencedBundle) {
@@ -937,36 +1080,44 @@ ${code}
               replacement = `${renamed}.default`;
             }
           } else {
+            // @ts-expect-error TS2345
             replacement = this.getPropertyAccess(renamed, imported);
           }
 
+          // @ts-expect-error TS2345
           replacements.set(local, replacement);
         }
       } else {
         let property;
         if (referencedBundle) {
           let entry = nullthrows(referencedBundle.getMainEntry());
+          // @ts-expect-error TS2345
           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;
+            // @ts-expect-error TS2322
             imported =
               referencedBundle?.env.outputFormat === 'esmodule'
                 ? 'default'
                 : '*';
           } else {
+            // @ts-expect-error TS2367
             if (imported === '*') {
               let exportedSymbols = this.bundleGraph.getExportedSymbols(entry);
+              // @ts-expect-error TS2367
               if (local === '*') {
                 // Re-export all symbols.
                 for (let exported of exportedSymbols) {
                   if (exported.symbol) {
+                    // @ts-expect-error TS2345
                     external.set(exported.exportSymbol, exported.symbol);
                   }
                 }
                 continue;
               }
             }
+            // @ts-expect-error TS2322
             renamed = this.bundleGraph.getSymbolResolution(
               entry,
               imported,
@@ -979,30 +1130,40 @@ ${code}
         // are deduplicated. We have to prefix the imported name with the bundle id so that
         // local variables do not shadow it.
         if (!renamed) {
+          // @ts-expect-error TS2345
           if (this.exportedSymbols.has(local)) {
+            // @ts-expect-error TS2322
             renamed = local;
+            // @ts-expect-error TS2367
           } else if (imported === 'default' || imported === '*') {
             renamed = this.getTopLevelName(
               `$${this.bundle.publicId}$${specifier}`,
             );
           } else {
             renamed = this.getTopLevelName(
+              // @ts-expect-error TS2731
               `$${this.bundle.publicId}$${imported}`,
             );
           }
         }
 
+        // @ts-expect-error TS2345
         external.set(imported, renamed);
+        // @ts-expect-error TS2367
         if (local !== '*' && replacements) {
           let replacement = renamed;
+          // @ts-expect-error TS2367
           if (property === '*') {
             replacement = renamed;
+            // @ts-expect-error TS2367
           } else if (property === 'default') {
             replacement = `($parcel$interopDefault(${renamed}))`;
             this.usedHelpers.add('$parcel$interopDefault');
           } else if (property) {
+            // @ts-expect-error TS2345
             replacement = this.getPropertyAccess(renamed, property);
           }
+          // @ts-expect-error TS2345
           replacements.set(local, replacement);
         }
       }
@@ -1041,6 +1202,7 @@ ${code}
       asset: resolvedAsset,
       exportSymbol,
       symbol,
+      // @ts-expect-error TS2345
     } = this.bundleGraph.getSymbolResolution(resolved, imported, this.bundle);
 
     if (
@@ -1099,8 +1261,11 @@ ${code}
       staticExports &&
       !isWrapped &&
       (dep?.meta.kind === 'Import' || dep?.meta.kind === 'Export') &&
+      // @ts-expect-error TS2345
       resolvedAsset.symbols.hasExportSymbol('*') &&
+      // @ts-expect-error TS2345
       resolvedAsset.symbols.hasExportSymbol('default') &&
+      // @ts-expect-error TS2345
       !resolvedAsset.symbols.hasExportSymbol('__esModule');
 
     // Find the namespace object for the resolved module. If wrapped and this
@@ -1116,7 +1281,9 @@ ${code}
     } else if (isWrapped && dep) {
       obj = `$${publicId}`;
     } else {
+      // @ts-expect-error TS2345
       obj = resolvedAsset.symbols.get('*')?.local || `$${assetId}$exports`;
+      // @ts-expect-error TS2345
       obj = replacements?.get(obj) || obj;
     }
 
@@ -1129,6 +1296,7 @@ ${code}
         // Directly use module.exports for wrapped assets importing themselves.
         return 'module.exports';
       } else {
+        // @ts-expect-error TS2322
         return obj;
       }
     } else if (
@@ -1143,17 +1311,21 @@ ${code}
       if (
         (!dep || kind === 'Import' || kind === 'Export') &&
         exportSymbol === 'default' &&
+        // @ts-expect-error TS2345
         resolvedAsset.symbols.hasExportSymbol('*') &&
         this.needsDefaultInterop(resolvedAsset)
       ) {
         this.usedHelpers.add('$parcel$interopDefault');
+        // @ts-expect-error TS2731
         return `(/*@__PURE__*/$parcel$interopDefault(${obj}))`;
       } else {
+        // @ts-expect-error TS2345
         return this.getPropertyAccess(obj, exportSymbol);
       }
     } else if (!symbol) {
       invariant(false, 'Asset was skipped or not found.');
     } else {
+      // @ts-expect-error TS2322
       return replacements?.get(symbol) || symbol;
     }
   }
@@ -1216,38 +1388,56 @@ ${code}
     // If there's no __esModule flag, and default is a used symbol, we need
     // to insert an interop helper.
     let defaultInterop =
+      // @ts-expect-error TS2345
       asset.symbols.hasExportSymbol('*') &&
+      // @ts-expect-error TS2345
       usedSymbols.has('default') &&
+      // @ts-expect-error TS2345
       !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(
+    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) &&
+          // @ts-expect-error TS2345
+          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.
+        // @ts-expect-error TS2345
+        (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) &&
+                // @ts-expect-error TS2345
                 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 a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
+        // we fallback on the namespace object.
+        // @ts-expect-error TS2345
+        (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 +1464,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?
+      // @ts-expect-error TS2345
       if (asset.symbols.hasExportSymbol('default') && usedSymbols.has('*')) {
         prepend += `\n$parcel$defineInteropFlag($${assetId}$exports);\n`;
         prependLineCount += 2;
@@ -1292,6 +1483,7 @@ ${code}
         let isWrapped = resolved && resolved.meta.shouldWrap;
 
         for (let [imported, {local}] of dep.symbols) {
+          // @ts-expect-error TS2367
           if (imported === '*' && local === '*') {
             if (!resolved) {
               // Re-exporting an external module. This should have already been handled in buildReplacements.
@@ -1309,9 +1501,11 @@ ${code}
             if (
               isWrapped ||
               resolved.meta.staticExports === false ||
+              // @ts-expect-error TS2345
               nullthrows(this.bundleGraph.getUsedSymbols(resolved)).has('*') ||
               // an empty asset
               (!resolved.meta.hasCJSExports &&
+                // @ts-expect-error TS2345
                 resolved.symbols.hasExportSymbol('*'))
             ) {
               let obj = this.getSymbolResolution(
@@ -1328,7 +1522,9 @@ ${code}
                 this.bundleGraph.getUsedSymbols(dep),
               )) {
                 if (
+                  // @ts-expect-error TS2367
                   symbol === 'default' || // `export * as ...` does not include the default export
+                  // @ts-expect-error TS2367
                   symbol === '__esModule'
                 ) {
                   continue;
@@ -1337,6 +1533,7 @@ ${code}
                 let resolvedSymbol = this.getSymbolResolution(
                   asset,
                   resolved,
+                  // @ts-expect-error TS2345
                   symbol,
                   undefined,
                   replacements,
@@ -1362,6 +1559,7 @@ ${code}
       // re-exported symbols rather than only symbols declared in this asset.
       let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
       let usedExports = [...asset.symbols.exportSymbols()].filter((symbol) => {
+        // @ts-expect-error TS2367
         if (symbol === '*') {
           return false;
         }
@@ -1378,6 +1576,7 @@ ${code}
           // No used symbols available for the asset, make sure we keep all of them
           if (!symbols) return false;
 
+          // @ts-expect-error TS2345
           return !symbols.has(symbol) && !symbols.has('*');
         });
         return !unused;
@@ -1393,6 +1592,7 @@ ${code}
             let resolved = this.getSymbolResolution(
               asset,
               asset,
+              // @ts-expect-error TS2345
               exp,
               undefined,
               replacements,
@@ -1448,8 +1648,10 @@ ${code}
     }
 
     for (let helper of this.usedHelpers) {
+      // @ts-expect-error TS7053
       let currentHelper = helpers[helper];
       if (typeof currentHelper === 'function') {
+        // @ts-expect-error TS7053
         currentHelper = helpers[helper](this.bundle.env);
       }
       res += currentHelper;
@@ -1470,6 +1672,7 @@ ${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();
 
@@ -1498,7 +1701,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) {
@@ -1522,7 +1729,9 @@ ${code}
 
   needsDefaultInterop(asset: Asset): boolean {
     if (
+      // @ts-expect-error TS2345
       asset.symbols.hasExportSymbol('*') &&
+      // @ts-expect-error TS2345
       !asset.symbols.hasExportSymbol('default')
     ) {
       return true;