@atlaspack/core 2.33.1 → 2.35.0

package/src/requests/AssetGraphRequestRust.ts

@@ -2,7 +2,7 @@ import invariant from 'assert';
 
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Async} from '@atlaspack/types';
-import {instrument} from '@atlaspack/logger';
+import logger, {instrument} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph from '../AssetGraph';
@@ -51,8 +51,8 @@ export function createAssetGraphRequestRust(
   return (input: AssetGraphRequestInput) => ({
     type: requestTypes.asset_graph_request,
     id: input.name,
-    run: async (input) => {
-      let options = input.options;
+    run: async (runInput) => {
+      let options = runInput.options;
       let {assetGraphPromise, commitPromise} =
         await rustAtlaspack.buildAssetGraph();
 
@@ -69,7 +69,7 @@ export function createAssetGraphRequestRust(
       let prevResult = null;
       if (serializedAssetGraph.hadPreviousGraph) {
         prevResult =
-          await input.api.getPreviousResult<AssetGraphRequestResult>();
+          await runInput.api.getPreviousResult<AssetGraphRequestResult>();
       }
 
       let {assetGraph, changedAssets} = instrument(
@@ -78,20 +78,28 @@ export function createAssetGraphRequestRust(
       );
 
       let changedAssetsPropagation = new Set(changedAssets.keys());
-      let errors = propagateSymbols({
-        options,
-        assetGraph,
-        changedAssetsPropagation,
-        assetGroupsWithRemovedParents: new Set(),
-        previousErrors: new Map(), //this.previousSymbolPropagationErrors,
-      });
-
-      if (errors.size > 0) {
-        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-        throw new ThrowableDiagnostic({
-          diagnostic: [...errors.values()][0],
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (input.skipSymbolProp) {
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph',
         });
+      } else {
+        let errors = propagateSymbols({
+          options,
+          assetGraph,
+          changedAssetsPropagation,
+          assetGroupsWithRemovedParents: new Set(),
+          previousErrors: new Map(), //this.previousSymbolPropagationErrors,
+        });
+
+        if (errors.size > 0) {
+          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+          throw new ThrowableDiagnostic({
+            diagnostic: [...errors.values()][0],
+          });
+        }
       }
 
       await dumpGraphToGraphViz(assetGraph, 'AssetGraphV3');
@@ -116,8 +124,8 @@ export function createAssetGraphRequestRust(
         });
       }
 
-      await input.api.storeResult(result);
-      input.api.invalidateOnBuild();
+      await runInput.api.storeResult(result);
+      runInput.api.invalidateOnBuild();
 
       return result;
     },
@@ -230,7 +238,32 @@ export function getAssetGraph(
     return envId;
   };
 
-  function updateNode(newNode: AssetGraphNode, isUpdateNode: boolean) {
+  function describeNode(node: AssetGraphNode): Record<string, unknown> {
+    const base = {type: node.type, id: node.id};
+    if (node.type === 'asset') {
+      return {
+        ...base,
+        filePath: node.value.filePath,
+        fileType: node.value.type,
+        pipeline: node.value.pipeline,
+      };
+    } else if (node.type === 'dependency') {
+      return {
+        ...base,
+        specifier: node.value.specifier,
+        specifierType: node.value.specifierType,
+        sourceAssetId: node.value.sourceAssetId,
+        sourcePath: node.value.sourcePath,
+      };
+    }
+    return base;
+  }
+
+  function updateNode(
+    newNode: AssetGraphNode,
+    isUpdateNode: boolean,
+    index: number,
+  ) {
     if (isUpdateNode) {
       let existingNode = graph.getNodeByContentKey(newNode.id);
 
@@ -238,7 +271,34 @@ export function getAssetGraph(
 
       Object.assign(existingNode, newNode);
     } else {
-      graph.addNodeByContentKey(newNode.id, newNode);
+      try {
+        graph.addNodeByContentKey(newNode.id, newNode);
+      } catch (e) {
+        if (
+          e instanceof Error &&
+          e.message.includes('already has content key')
+        ) {
+          let existingNode = graph.getNodeByContentKey(newNode.id);
+          let diagnostics = {
+            contentKey: newNode.id,
+            newNode: describeNode(newNode),
+            existingNode: existingNode ? describeNode(existingNode) : null,
+            iterationIndex: index,
+            totalSerializedNodes: nodesCount,
+            newNodesCount: serializedGraph.nodes.length,
+            updatesCount: serializedGraph.updates.length,
+            edgesCount: serializedGraph.edges.length,
+            hadPreviousGraph: !!prevAssetGraph,
+            safeToSkipBundling: serializedGraph.safeToSkipBundling,
+            graphNodeCount: graph._contentKeyToNodeId.size,
+          };
+
+          throw new Error(
+            `Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`,
+          );
+        }
+        throw e;
+      }
     }
   }
 
@@ -297,7 +357,7 @@ export function getAssetGraph(
         usedSymbolsUpDirty: true,
         value: asset,
       };
-      updateNode(assetNode, isUpdateNode);
+      updateNode(assetNode, isUpdateNode, index);
     } else if (node.type === 'dependency') {
       let {dependency, id} = node.value;
 
@@ -314,6 +374,19 @@ export function getAssetGraph(
 
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();
+
+      if (node.used_symbols_up) {
+        for (let usedSymbol of node.used_symbols_up) {
+          // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+          // to JS format { symbol: string, asset: string } where symbol is the resolved name
+          const exportedName = usedSymbol.symbol.exported;
+          usedSymbolsUp.set(exportedName, {
+            asset: usedSymbol.asset,
+            symbol: usedSymbol.resolved_symbol ?? exportedName,
+          });
+        }
+      }
+
       if (dependency.isEntry && dependency.isLibrary) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
@@ -334,7 +407,7 @@ export function getAssetGraph(
         value: dependency,
       };
 
-      updateNode(depNode, isUpdateNode);
+      updateNode(depNode, isUpdateNode, index);
     }
   }
 

package/src/requests/AtlaspackBuildRequest.ts

@@ -23,7 +23,6 @@ import {tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {fromEnvironmentId} from '../EnvironmentManager';
-import invariant from 'assert';
 
 type AtlaspackBuildRequestInput = {
   optionsRef: SharedReference;
@@ -87,12 +86,16 @@ async function run({
           signal,
         });
 
-  let {bundleGraph, changedAssets, assetRequests}: BundleGraphResult =
-    await api.runRequest(bundleGraphRequest, {
-      force:
-        Boolean(rustAtlaspack) ||
-        (options.shouldBuildLazily && requestedAssetIds.size > 0),
-    });
+  let {
+    bundleGraph,
+    changedAssets,
+    assetRequests,
+    didIncrementallyBundle,
+  }: BundleGraphResult = await api.runRequest(bundleGraphRequest, {
+    force:
+      Boolean(rustAtlaspack) ||
+      (options.shouldBuildLazily && requestedAssetIds.size > 0),
+  });
 
   if (
     getFeatureFlag('nativePackager') &&
@@ -110,7 +113,12 @@ async function run({
       }
     });
     if (hasSupportedTarget) {
-      await rustAtlaspack.loadBundleGraph(bundleGraph);
+      if (didIncrementallyBundle) {
+        const changedAssetIds = Array.from(changedAssets.keys());
+        await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+      } else {
+        await rustAtlaspack.loadBundleGraph(bundleGraph);
+      }
     }
   }
 

package/src/requests/BundleGraphRequest.ts

@@ -14,7 +14,6 @@ import type {ConfigAndCachePath} from './AtlaspackConfigRequest';
 
 import fs from 'fs';
 import invariant from 'assert';
-import assert from 'assert';
 import nullthrows from 'nullthrows';
 import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
@@ -36,13 +35,8 @@ import {
   createDevDependency,
   getDevDepRequests,
   invalidateDevDeps,
-  runDevDepRequest,
 } from './DevDepRequest';
-import {
-  loadPluginConfig,
-  runConfigRequest,
-  PluginWithLoadConfig,
-} from './ConfigRequest';
+import {PluginWithLoadConfig} from './ConfigRequest';
 import {fromProjectPathRelative} from '../projectPath';
 import {
   validateBundles,
@@ -74,9 +68,9 @@ type RunInput = {
 // TODO: Rename to BundleGraphRequestResult
 export type BundleGraphResult = {
   bundleGraph: InternalBundleGraph;
-  assetGraphBundlingVersion: number;
   changedAssets: Map<string, Asset>;
   assetRequests: Array<AssetGroup>;
+  didIncrementallyBundle: boolean;
 };
 
 type BundleGraphRequest = {
@@ -151,6 +145,7 @@ export default function createBundleGraphRequest(
         lazyIncludes: options.lazyIncludes,
         lazyExcludes: options.lazyExcludes,
         requestedAssetIds,
+        skipSymbolProp: getFeatureFlag('rustSymbolTracker'),
       });
 
       let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(
@@ -213,7 +208,6 @@ export default function createBundleGraphRequest(
 
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
-        assetGraph.setNeedsBundling();
       }
 
       let configResult = nullthrows(
@@ -282,21 +276,12 @@ class BundlerRunner {
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, api.invalidateOnOptionChange),
     );
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const key = hashString(
+    this.cacheKey =
+      hashString(
         `${ATLASPACK_VERSION}:BundleGraph:${
           JSON.stringify(options.entries) ?? ''
         }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      );
-      this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey =
-        hashString(
-          `${ATLASPACK_VERSION}:BundleGraph:${
-            JSON.stringify(options.entries) ?? ''
-          }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-        ) + '-BundleGraph';
-    }
+      ) + '-BundleGraph';
   }
 
   async loadConfigs() {
@@ -343,7 +328,7 @@ class BundlerRunner {
       type: 'buildProgress',
       phase: 'bundling',
     });
-
+    let didIncrementallyBundle = false;
     await this.loadConfigs();
 
     let plugin = await this.config.getBundler();
@@ -353,14 +338,10 @@ class BundlerRunner {
     const previousBundleGraphResult: BundleGraphResult | null | undefined =
       await this.api.getPreviousResult();
     const canIncrementallyBundle =
-      previousBundleGraphResult?.assetGraphBundlingVersion != null &&
-      graph.canIncrementallyBundle(
-        previousBundleGraphResult.assetGraphBundlingVersion,
-      );
+      previousBundleGraphResult != null && graph.canIncrementallyBundle();
 
     if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
-      graph.setNeedsBundling();
     }
 
     let internalBundleGraph;
@@ -381,6 +362,7 @@ class BundlerRunner {
           invariant(changedAssetNode.type === 'asset');
           internalBundleGraph.updateAsset(changedAssetNode);
         }
+        didIncrementallyBundle = true;
       } else {
         internalBundleGraph = InternalBundleGraph.fromAssetGraph(
           graph,
@@ -473,9 +455,9 @@ class BundlerRunner {
         this.api.storeResult(
           {
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
           },
           this.cacheKey,
         );
@@ -559,18 +541,18 @@ class BundlerRunner {
     this.api.storeResult(
       {
         bundleGraph: internalBundleGraph,
-        assetGraphBundlingVersion: graph.getBundlingVersion(),
         changedAssets: new Map(),
         assetRequests: [],
+        didIncrementallyBundle,
       },
       this.cacheKey,
     );
 
     return {
       bundleGraph: internalBundleGraph,
-      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
       assetRequests,
+      didIncrementallyBundle,
     };
   }
 }

package/src/requests/BundleGraphRequestRust.ts

@@ -181,10 +181,9 @@ export default function createBundleGraphRequestRust(
 
       return {
         bundleGraph,
-        // Not accurate yet — ok for now.
-        assetGraphBundlingVersion: 0,
         changedAssets: changedRuntimes,
         assetRequests: [],
+        didIncrementallyBundle: false,
       };
     },
     input,

package/src/requests/PackageRequest.ts

@@ -72,7 +72,7 @@ async function run({input, api, farm, rustAtlaspack}: RunInput<BundleInfo>) {
     bundle.type === 'js'
   ) {
     // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-    let result = await rustAtlaspack.package(bundle.id);
+    let result = await rustAtlaspack.package(bundle.id, {inlineRequires: true});
     let error: Diagnostic | null = null;
     [packagingResult, error] = result;
     if (error) {

package/src/requests/TargetRequest.ts

@@ -332,6 +332,7 @@ export class TargetResolver {
               publicUrl:
                 descriptor.publicUrl ??
                 this.options.defaultTargetOptions.publicUrl,
+              inlineRequires: descriptor.inlineRequires ?? false,
               env: createEnvironment({
                 engines: descriptor.engines,
                 context: descriptor.context,
@@ -426,6 +427,7 @@ export class TargetResolver {
               this.options.serveOptions.distDir,
             ),
             publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+            inlineRequires: false,
             env: createEnvironment({
               context: 'browser',
               engines: {
@@ -930,6 +932,7 @@ export class TargetResolver {
           distEntry,
           publicUrl:
             descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: createEnvironment({
             engines: descriptor.engines ?? pkgEngines,
             // @ts-expect-error TS2322
@@ -1131,6 +1134,7 @@ export class TargetResolver {
           distEntry,
           publicUrl:
             descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: createEnvironment({
             engines: descriptor.engines ?? pkgEngines,
             context: descriptor.context,
@@ -1205,6 +1209,7 @@ export class TargetResolver {
             path.join(pkgDir, DEFAULT_DIST_DIRNAME),
           ),
         publicUrl: this.options.defaultTargetOptions.publicUrl,
+        inlineRequires: false,
         env: createEnvironment({
           engines: pkgEngines,
           // @ts-expect-error TS2322