@atlaspack/core 2.34.0 → 2.36.0

package/src/requests/AssetGraphRequest.ts

@@ -18,7 +18,6 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -85,10 +84,12 @@ export default function createAssetGraphRequest(
       let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
-      assetGraphRequest.assetGraph.setDisableIncrementalBundling(
+      if (
         !input.options.shouldBundleIncrementally ||
-          input.options.mode === 'production',
-      );
+        input.options.mode === 'production'
+      ) {
+        assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
+      }
 
       if (
         !input.options.shouldBundleIncrementally ||
@@ -171,21 +172,12 @@ export class AssetGraphBuilder {
     this.lazyExcludes = lazyExcludes ?? [];
     this.skipSymbolProp = input.skipSymbolProp ?? false;
 
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const key = hashString(
+    this.cacheKey =
+      hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      );
-      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey =
-        hashString(
-          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
-            options.mode
-          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-        ) + '-AssetGraph';
-    }
+      ) + '-AssetGraph';
 
     this.isSingleChangeRebuild =
       api
@@ -535,7 +527,6 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
-        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -590,12 +581,10 @@ export class AssetGraphBuilder {
             invariant(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
-              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
-            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -604,7 +593,6 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
-      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;

package/src/requests/AssetGraphRequestRust.ts

@@ -238,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);
 
@@ -246,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;
+      }
     }
   }
 
@@ -305,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;
 
@@ -325,12 +377,12 @@ export function getAssetGraph(
 
       if (node.used_symbols_up) {
         for (let usedSymbol of node.used_symbols_up) {
-          // Transform Rust UsedSymbol { symbol: Symbol, asset: string }
-          // to JS format { symbol: string, asset: string } where symbol is the exported name
+          // 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: exportedName,
+            symbol: usedSymbol.resolved_symbol ?? exportedName,
           });
         }
       }
@@ -355,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,19 +35,15 @@ import {
   createDevDependency,
   getDevDepRequests,
   invalidateDevDeps,
-  runDevDepRequest,
 } from './DevDepRequest';
-import {
-  loadPluginConfig,
-  runConfigRequest,
-  PluginWithLoadConfig,
-} from './ConfigRequest';
+import {PluginWithLoadConfig} from './ConfigRequest';
 import {fromProjectPathRelative} from '../projectPath';
 import {
   validateBundles,
   nameBundle,
   loadPluginConfigWithDevDeps,
   runDevDepRequest as runDevDepRequestShared,
+  dumpBundleGraphSnapshot,
 } from './BundleGraphRequestUtils';
 import createAssetGraphRequestJS from './AssetGraphRequest';
 import {createAssetGraphRequestRust} from './AssetGraphRequestRust';
@@ -74,9 +69,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 = {
@@ -214,7 +209,6 @@ export default function createBundleGraphRequest(
 
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
-        assetGraph.setNeedsBundling();
       }
 
       let configResult = nullthrows(
@@ -283,21 +277,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() {
@@ -344,7 +329,7 @@ class BundlerRunner {
       type: 'buildProgress',
       phase: 'bundling',
     });
-
+    let didIncrementallyBundle = false;
     await this.loadConfigs();
 
     let plugin = await this.config.getBundler();
@@ -354,14 +339,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;
@@ -382,6 +363,7 @@ class BundlerRunner {
           invariant(changedAssetNode.type === 'asset');
           internalBundleGraph.updateAsset(changedAssetNode);
         }
+        didIncrementallyBundle = true;
       } else {
         internalBundleGraph = InternalBundleGraph.fromAssetGraph(
           graph,
@@ -415,16 +397,20 @@ class BundlerRunner {
         }
 
         // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-        await bundler.bundle({
-          bundleGraph: mutableBundleGraph,
-          config: this.configs.get(plugin.name)?.result,
-          options: this.pluginOptions,
-          logger,
-          tracer,
+        await instrumentAsync('bundle (V2)', async () => {
+          await bundler.bundle({
+            bundleGraph: mutableBundleGraph,
+            config: this.configs.get(plugin.name)?.result,
+            options: this.pluginOptions,
+            logger,
+            tracer,
+          });
         });
 
         measurement && measurement.end();
 
+        dumpBundleGraphSnapshot(internalBundleGraph, 'js');
+
         if (this.pluginOptions.mode === 'production') {
           let optimizeMeasurement;
           try {
@@ -474,9 +460,9 @@ class BundlerRunner {
         this.api.storeResult(
           {
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
           },
           this.cacheKey,
         );
@@ -560,18 +546,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

@@ -32,6 +32,7 @@ import {
   nameBundle,
   loadPluginConfigWithDevDeps,
   runDevDepRequest,
+  dumpBundleGraphSnapshot,
 } from './BundleGraphRequestUtils';
 import {toEnvironmentRef} from '../EnvironmentManager';
 import {getEnvironmentHash} from '../Environment';
@@ -109,6 +110,8 @@ export default function createBundleGraphRequestRust(
         () => getBundleGraph(serializedBundleGraph),
       );
 
+      dumpBundleGraphSnapshot(bundleGraph, 'rust');
+
       const runner = new NativeBundlerRunner(
         {api, options} as any,
         input.optionsRef,
@@ -181,10 +184,9 @@ export default function createBundleGraphRequestRust(
 
       return {
         bundleGraph,
-        // Not accurate yet — ok for now.
-        assetGraphBundlingVersion: 0,
         changedAssets: changedRuntimes,
         assetRequests: [],
+        didIncrementallyBundle: false,
       };
     },
     input,

package/src/requests/BundleGraphRequestUtils.ts

@@ -17,11 +17,13 @@ import type {
 } from '../types';
 
 import assert from 'assert';
+import fs from 'fs';
 import nullthrows from 'nullthrows';
+import path from 'path';
 import {PluginLogger} from '@atlaspack/logger';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {unique, setSymmetricDifference} from '@atlaspack/utils';
-import InternalBundleGraph from '../BundleGraph';
+import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
 import BundleGraph from '../public/BundleGraph';
 import {Bundle, NamedBundle} from '../public/Bundle';
 import PluginOptions from '../public/PluginOptions';
@@ -66,6 +68,160 @@ export function validateBundles(bundleGraph: InternalBundleGraph): void {
   );
 }
 
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+export function dumpBundleGraphSnapshot(
+  bundleGraph: InternalBundleGraph,
+  variant: 'js' | 'rust',
+): void {
+  let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+  if (!outDir) return;
+
+  let filename =
+    variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+  let outPath = path.join(outDir, filename);
+
+  fs.mkdirSync(outDir, {recursive: true});
+
+  let bundles = bundleGraph.getBundles();
+  let bundlesSnapshot = bundles
+    .map((bundle) => {
+      let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+      let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(
+        bundleNodeId,
+        bundleGraphEdgeTypes.contains,
+      );
+      let containedAssets = containedAssetNodeIds
+        .map((nodeId) => bundleGraph._graph.getNode(nodeId))
+        .flatMap((node) => {
+          if (node?.type !== 'asset') return [];
+          return [
+            {
+              id: node.value.id,
+              filePath: fromProjectPathRelative(node.value.filePath),
+            },
+          ];
+        })
+        .sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+      // Resolve mainEntry and entry asset file paths
+      let mainEntryPath: string | null = null;
+      let entryAssetPaths: string[] = [];
+      if (bundle.mainEntryId) {
+        let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(
+          bundle.mainEntryId,
+        );
+        let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+        if (mainEntryNode?.type === 'asset') {
+          mainEntryPath = fromProjectPathRelative(mainEntryNode.value.filePath);
+        }
+      }
+      for (let entryId of bundle.entryAssetIds) {
+        let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+        let entryNode = bundleGraph._graph.getNode(entryNodeId);
+        if (entryNode?.type === 'asset') {
+          entryAssetPaths.push(
+            fromProjectPathRelative(entryNode.value.filePath),
+          );
+        }
+      }
+      entryAssetPaths.sort();
+
+      return {
+        id: bundle.id,
+        type: bundle.type,
+        bundleBehavior: bundle.bundleBehavior ?? null,
+        needsStableName: bundle.needsStableName,
+        isSplittable: bundle.isSplittable,
+        isPlaceholder: bundle.isPlaceholder,
+        mainEntryPath,
+        entryAssetPaths,
+        assets: containedAssets.map((a) => a.filePath),
+      };
+    })
+    .sort((a, b) => {
+      // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+      let aKey = a.mainEntryPath || a.assets.join(',');
+      let bKey = b.mainEntryPath || b.assets.join(',');
+      return aKey.localeCompare(bKey);
+    });
+
+  let bundleGroupsSnapshot = bundleGraph._graph.nodes
+    .flatMap((node) => {
+      if (node?.type !== 'bundle_group') return [];
+
+      let bundleGroup = node.value;
+
+      // Resolve entry asset file path
+      let entryAssetPath: string | null = null;
+      try {
+        let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(
+          bundleGroup.entryAssetId,
+        );
+        let entryNode = bundleGraph._graph.getNode(entryNodeId);
+        if (entryNode?.type === 'asset') {
+          entryAssetPath = fromProjectPathRelative(entryNode.value.filePath);
+        }
+      } catch {
+        // Content key not found
+      }
+
+      let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+      let bundlePaths = bundlesInGroup
+        .map((b) => {
+          // Use mainEntry file path if available, otherwise bundle id as fallback
+          if (b.mainEntryId) {
+            try {
+              let nodeId = bundleGraph._graph.getNodeIdByContentKey(
+                b.mainEntryId,
+              );
+              let node = bundleGraph._graph.getNode(nodeId);
+              if (node?.type === 'asset') {
+                return fromProjectPathRelative(node.value.filePath);
+              }
+            } catch {
+              // fallback
+            }
+          }
+          return `[bundle:${b.id}]`;
+        })
+        .sort();
+
+      return [
+        {
+          entryAssetPath:
+            entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+          bundlePaths,
+        },
+      ];
+    })
+    .sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+
+  let totalAssets = bundleGraph._graph.nodes.filter(
+    (node) => node?.type === 'asset',
+  ).length;
+
+  let snapshot = {
+    version: 1,
+    variant,
+    stats: {
+      totalBundles: bundlesSnapshot.length,
+      totalBundleGroups: bundleGroupsSnapshot.length,
+      totalAssets,
+    },
+    bundles: bundlesSnapshot,
+    bundleGroups: bundleGroupsSnapshot,
+  };
+
+  fs.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
+
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */

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