@atlaspack/core 2.32.1 → 2.33.1

package/src/requests/AtlaspackBuildRequest.ts

@@ -9,6 +9,7 @@ import type BundleGraph from '../BundleGraph';
 import createBundleGraphRequest, {
   BundleGraphResult,
 } from './BundleGraphRequest';
+import createBundleGraphRequestRust from './BundleGraphRequestRust';
 import createWriteBundlesRequest from './WriteBundlesRequest';
 import {assertSignalNotAborted} from '../utils';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
@@ -73,11 +74,18 @@ async function run({
 }: RunInput<AtlaspackBuildRequestResult>) {
   let {optionsRef, requestedAssetIds, signal} = input;
 
-  let bundleGraphRequest = createBundleGraphRequest({
-    optionsRef,
-    requestedAssetIds,
-    signal,
-  });
+  let bundleGraphRequest =
+    getFeatureFlag('nativeBundling') && rustAtlaspack
+      ? createBundleGraphRequestRust({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        })
+      : createBundleGraphRequest({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        });
 
   let {bundleGraph, changedAssets, assetRequests}: BundleGraphResult =
     await api.runRequest(bundleGraphRequest, {

package/src/requests/BundleGraphRequest.ts

@@ -1,11 +1,10 @@
-import type {Async, Bundle as IBundle, Namer} from '@atlaspack/types';
+import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
 import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
 import type {StaticRunOpts, RunAPI} from '../RequestTracker';
 import type {
   Asset,
   AssetGroup,
-  Bundle as InternalBundle,
   Config,
   DevDepRequest,
   AtlaspackOptions,
@@ -21,13 +20,10 @@ import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
-import BundleGraph from '../public/BundleGraph';
 import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
 import MutableBundleGraph from '../public/MutableBundleGraph';
-import {Bundle, NamedBundle} from '../public/Bundle';
 import {report} from '../ReporterRunner';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
-import {unique, setSymmetricDifference} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import PluginOptions from '../public/PluginOptions';
 import applyRuntimes from '../applyRuntimes';
@@ -42,17 +38,18 @@ import {
   invalidateDevDeps,
   runDevDepRequest,
 } from './DevDepRequest';
-import {createConfig} from '../InternalConfig';
 import {
   loadPluginConfig,
   runConfigRequest,
   PluginWithLoadConfig,
 } from './ConfigRequest';
+import {fromProjectPathRelative} from '../projectPath';
 import {
-  joinProjectPath,
-  fromProjectPathRelative,
-  toProjectPathUnsafe,
-} from '../projectPath';
+  validateBundles,
+  nameBundle,
+  loadPluginConfigWithDevDeps,
+  runDevDepRequest as runDevDepRequestShared,
+} from './BundleGraphRequestUtils';
 import createAssetGraphRequestJS from './AssetGraphRequest';
 import {createAssetGraphRequestRust} from './AssetGraphRequestRust';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
@@ -319,30 +316,18 @@ class BundlerRunner {
   }
 
   async loadConfig<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>) {
-    let config = createConfig({
-      plugin: plugin.name,
-      searchPath: toProjectPathUnsafe('index'),
-    });
-
-    await loadPluginConfig(plugin, config, this.options);
-    await runConfigRequest(this.api, config);
-    for (let devDep of config.devDeps) {
-      let devDepRequest = await createDevDependency(
-        devDep,
-        this.previousDevDeps,
-        this.options,
-      );
-      await this.runDevDepRequest(devDepRequest);
-    }
-
-    this.configs.set(plugin.name, config);
+    await loadPluginConfigWithDevDeps(
+      plugin,
+      this.options,
+      this.api,
+      this.previousDevDeps,
+      this.devDepRequests,
+      this.configs,
+    );
   }
 
   async runDevDepRequest(devDepRequest: DevDepRequest | DevDepRequestRef) {
-    let {specifier, resolveFrom} = devDepRequest;
-    let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
-    this.devDepRequests.set(key, devDepRequest);
-    await runDevDepRequest(this.api, devDepRequest);
+    await runDevDepRequestShared(this.api, devDepRequest, this.devDepRequests);
   }
 
   async bundle({
@@ -520,7 +505,14 @@ class BundlerRunner {
       let bundles = internalBundleGraph.getBundles({includeInline: true});
       await Promise.all(
         bundles.map((bundle) =>
-          this.nameBundle(namers, bundle, internalBundleGraph),
+          nameBundle(
+            namers,
+            bundle,
+            internalBundleGraph,
+            this.options,
+            this.pluginOptions,
+            this.configs,
+          ),
         ),
       );
 
@@ -551,7 +543,7 @@ class BundlerRunner {
         await this.runDevDepRequest(devDepRequest);
       }
 
-      this.validateBundles(internalBundleGraph);
+      validateBundles(internalBundleGraph);
 
       // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
       internalBundleGraph.getBundleGraphHash();
@@ -581,71 +573,4 @@ class BundlerRunner {
       assetRequests,
     };
   }
-
-  validateBundles(bundleGraph: InternalBundleGraph): void {
-    let bundles = bundleGraph.getBundles();
-
-    let bundleNames = bundles.map((b) =>
-      joinProjectPath(b.target.distDir, nullthrows(b.name)),
-    );
-    assert.deepEqual(
-      bundleNames,
-      unique(bundleNames),
-      'Bundles must have unique name. Conflicting names: ' +
-        [
-          ...setSymmetricDifference(
-            new Set(bundleNames),
-            new Set(unique(bundleNames)),
-          ),
-        ].join(),
-    );
-  }
-
-  async nameBundle(
-    namers: Array<LoadedPlugin<Namer<unknown>>>,
-    internalBundle: InternalBundle,
-    internalBundleGraph: InternalBundleGraph,
-  ): Promise<void> {
-    let bundle = Bundle.get(internalBundle, internalBundleGraph, this.options);
-    let bundleGraph = new BundleGraph<IBundle>(
-      internalBundleGraph,
-      NamedBundle.get.bind(NamedBundle),
-      this.options,
-    );
-
-    for (let namer of namers) {
-      let measurement;
-      try {
-        measurement = tracer.createMeasurement(namer.name, 'namer', bundle.id);
-        let name = await namer.plugin.name({
-          bundle,
-          bundleGraph,
-          config: this.configs.get(namer.name)?.result,
-          options: this.pluginOptions,
-          logger: new PluginLogger({origin: namer.name}),
-          tracer: new PluginTracer({origin: namer.name, category: 'namer'}),
-        });
-
-        if (name != null) {
-          internalBundle.name = name;
-          let {hashReference} = internalBundle;
-          internalBundle.displayName = name.includes(hashReference)
-            ? name.replace(hashReference, '[hash]')
-            : name;
-
-          return;
-        }
-      } catch (e: any) {
-        throw new ThrowableDiagnostic({
-          diagnostic: errorToDiagnostic(e, {
-            origin: namer.name,
-          }),
-        });
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-
-    throw new Error('Unable to name bundle');
-  }
 }

package/src/requests/BundleGraphRequestRust.ts

@@ -0,0 +1,464 @@
+import invariant from 'assert';
+
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import type {Async} from '@atlaspack/types';
+import {ContentGraph} from '@atlaspack/graph';
+import {instrument, instrumentAsync, PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
+import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
+import nullthrows from 'nullthrows';
+import {hashString} from '@atlaspack/rust';
+import PluginOptions from '../public/PluginOptions';
+import applyRuntimes from '../applyRuntimes';
+import {ATLASPACK_VERSION} from '../constants';
+import {optionsProxy} from '../utils';
+import {
+  createDevDependency,
+  getDevDepRequests,
+  invalidateDevDeps,
+} from './DevDepRequest';
+import {PluginWithLoadConfig} from './ConfigRequest';
+import {requestTypes, StaticRunOpts} from '../RequestTracker';
+import type {AtlaspackV3} from '../atlaspack-v3';
+import type {BundleGraphResult} from './BundleGraphRequest';
+import createAtlaspackConfigRequest, {
+  getCachedAtlaspackConfig,
+  ConfigAndCachePath,
+} from './AtlaspackConfigRequest';
+import {
+  validateBundles,
+  nameBundle,
+  loadPluginConfigWithDevDeps,
+  runDevDepRequest,
+} from './BundleGraphRequestUtils';
+import {toEnvironmentRef} from '../EnvironmentManager';
+import {getEnvironmentHash} from '../Environment';
+import type {
+  Asset,
+  BundleGraphNode,
+  BundleNode,
+  BundleGroupNode,
+  DependencyNode,
+  AssetNode,
+  Environment,
+} from '../types';
+import {tracer, PluginTracer} from '@atlaspack/profiler';
+import ThrowableDiagnostic2, {errorToDiagnostic} from '@atlaspack/diagnostic';
+import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
+import type {RunAPI} from '../RequestTracker';
+import type {
+  Config,
+  DevDepRequest,
+  AtlaspackOptions,
+  DevDepRequestRef,
+  Bundle as InternalBundle,
+} from '../types';
+import type {Namer, Bundle as IBundle} from '@atlaspack/types';
+import BundleGraph from '../public/BundleGraph';
+import {Bundle, NamedBundle} from '../public/Bundle';
+
+type BundleGraphRequestInput = {
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+  optionsRef: any;
+};
+
+type RunInput = {
+  input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+
+type BundleGraphRequestRust = {
+  id: string;
+  readonly type: typeof requestTypes.bundle_graph_request;
+  run: (arg1: RunInput) => Async<BundleGraphResult>;
+  input: BundleGraphRequestInput;
+};
+
+type SerializedBundleGraph = {
+  nodes: Array<any>;
+  edges: Array<number>;
+  publicIdByAssetId: {[k: string]: string};
+  assetPublicIds: Array<string>;
+  hadPreviousGraph: boolean;
+};
+
+export default function createBundleGraphRequestRust(
+  input: BundleGraphRequestInput,
+): BundleGraphRequestRust {
+  return {
+    type: requestTypes.bundle_graph_request,
+    id: 'BundleGraphRust',
+    run: async (runInput) => {
+      const {api, options, rustAtlaspack} = runInput;
+      invariant(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
+
+      let {bundleGraphPromise, commitPromise} =
+        await rustAtlaspack.buildBundleGraph();
+      let [serializedBundleGraph, bundleGraphError] =
+        (await bundleGraphPromise) as [SerializedBundleGraph, Error | null];
+
+      if (bundleGraphError) {
+        throw new ThrowableDiagnostic({diagnostic: bundleGraphError});
+      }
+
+      // Don’t reuse previous JS result yet; we just rebuild from scratch.
+      let {bundleGraph, changedAssets} = instrument(
+        'atlaspack_v3_getBundleGraph',
+        () => getBundleGraph(serializedBundleGraph),
+      );
+
+      const runner = new NativeBundlerRunner(
+        {api, options} as any,
+        input.optionsRef,
+      );
+      await runner.loadConfigs();
+
+      // Name all bundles
+      const namers = await runner.config.getNamers();
+      const bundles = bundleGraph.getBundles({includeInline: true});
+      await Promise.all(
+        bundles.map((b) =>
+          nameBundle(
+            namers,
+            b,
+            bundleGraph,
+            options,
+            runner.pluginOptions,
+            runner.configs,
+          ),
+        ),
+      );
+
+      // Apply runtimes
+      const changedRuntimes = await instrumentAsync('applyRuntimes', () =>
+        applyRuntimes({
+          bundleGraph,
+          api,
+          config: runner.config,
+          options,
+          optionsRef: input.optionsRef,
+          pluginOptions: runner.pluginOptions,
+          previousDevDeps: runner.previousDevDeps,
+          devDepRequests: runner.devDepRequests,
+          configs: runner.configs,
+        }),
+      );
+
+      // Add dev deps for namers
+      for (const namer of namers) {
+        const devDepRequest = await createDevDependency(
+          {
+            specifier: namer.name,
+            resolveFrom: namer.resolveFrom,
+          },
+          runner.previousDevDeps,
+          options,
+        );
+        await runDevDepRequest(api, devDepRequest, runner.devDepRequests);
+      }
+
+      validateBundles(bundleGraph);
+      bundleGraph.getBundleGraphHash();
+
+      await dumpGraphToGraphViz(
+        // @ts-expect-error Accessing internal graph for debug output
+        bundleGraph._graph,
+        'after_runtimes_native',
+        bundleGraphEdgeTypes,
+      );
+
+      let [_commitResult, commitError] = await commitPromise;
+      if (commitError) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message:
+              'Error committing bundle graph in Rust: ' + commitError.message,
+          },
+        });
+      }
+
+      return {
+        bundleGraph,
+        // Not accurate yet — ok for now.
+        assetGraphBundlingVersion: 0,
+        changedAssets: changedRuntimes,
+        assetRequests: [],
+      };
+    },
+    input,
+  };
+}
+
+function mapSymbols({exported, ...symbol}: any) {
+  let jsSymbol: any = {
+    local: symbol.local ?? undefined,
+    loc: symbol.loc ?? undefined,
+    isWeak: symbol.isWeak,
+    meta: {
+      isEsm: symbol.isEsmExport,
+      isStaticBindingSafe: symbol.isStaticBindingSafe,
+    },
+  };
+
+  if (symbol.exported) {
+    jsSymbol.exported = symbol.exported;
+  }
+
+  return [exported, jsSymbol];
+}
+
+function normalizeEnv(env: Environment): any {
+  if (!env) return env;
+  env.id = env.id || getEnvironmentHash(env);
+  return toEnvironmentRef(env);
+}
+
+export function getBundleGraph(serializedGraph: SerializedBundleGraph): {
+  bundleGraph: InternalBundleGraph;
+  changedAssets: Map<string, Asset>;
+} {
+  // Build a fresh internal bundle graph.
+  const publicIdByAssetId = new Map(
+    Object.entries(serializedGraph.publicIdByAssetId ?? {}),
+  );
+  const assetPublicIds = new Set(serializedGraph.assetPublicIds ?? []);
+
+  // BundleGraph constructor expects a ContentGraph under `_graph`.
+  // We reuse the internal graph class by creating an empty instance and then adding nodes.
+  const graph = new InternalBundleGraph({
+    // We intentionally start with an empty graph and add nodes/edges from the Rust payload.
+    // `ContentGraph` will allocate as needed.
+    graph: new ContentGraph(),
+    bundleContentHashes: new Map(),
+    publicIdByAssetId,
+    assetPublicIds,
+    conditions: new Map(),
+  });
+
+  // Root must exist at node id 0.
+  const rootNodeId = graph._graph.addNodeByContentKey('@@root', {
+    id: '@@root',
+    type: 'root',
+    value: null,
+  });
+  graph._graph.setRootNodeId(rootNodeId);
+
+  let entry = 0;
+  const changedAssets = new Map<string, Asset>();
+
+  const decoder = new TextDecoder();
+
+  // Create nodes in order.
+  for (let i = 0; i < serializedGraph.nodes.length; i++) {
+    // Nodes come back as buffers (same as AssetGraphRequestRust)
+    let node = JSON.parse(decoder.decode(serializedGraph.nodes[i]));
+
+    if (node.type === 'root') {
+      continue;
+    }
+
+    if (node.type === 'entry') {
+      let id = 'entry:' + ++entry;
+      graph._graph.addNodeByContentKey(id, {id, type: 'root', value: null});
+      continue;
+    }
+
+    if (node.type === 'asset') {
+      let asset = node.value;
+      let id = asset.id;
+
+      asset.committed = true;
+      asset.contentKey = id;
+      asset.env = {...asset.env};
+      asset.env.id = getFeatureFlag('environmentDeduplication')
+        ? getEnvironmentHash(asset.env)
+        : getEnvironmentHash(asset.env);
+      asset.env = normalizeEnv(asset.env);
+      asset.mapKey = `map:${asset.id}`;
+      asset.dependencies = new Map();
+      asset.meta.isV3 = true;
+      if (asset.symbols != null) {
+        asset.symbols = new Map(asset.symbols.map(mapSymbols));
+      }
+
+      changedAssets.set(id, asset);
+
+      const assetNode: AssetNode = {
+        id,
+        type: 'asset',
+        usedSymbols: new Set(),
+        usedSymbolsDownDirty: true,
+        usedSymbolsUpDirty: true,
+        value: asset,
+      };
+      graph._graph.addNodeByContentKey(id, assetNode);
+      continue;
+    }
+
+    if (node.type === 'dependency') {
+      let {dependency, id} = node.value;
+      dependency.id = id;
+      dependency.env = {...dependency.env};
+      dependency.env.id = getEnvironmentHash(dependency.env);
+      dependency.env = normalizeEnv(dependency.env);
+      if (dependency.symbols != null) {
+        dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+      }
+
+      let usedSymbolsDown = new Set();
+      let usedSymbolsUp = new Map();
+      if (dependency.isEntry && dependency.isLibrary) {
+        usedSymbolsDown.add('*');
+        usedSymbolsUp.set('*', undefined);
+      }
+
+      const depNode: DependencyNode = {
+        id,
+        type: 'dependency',
+        deferred: false,
+        excluded: false,
+        hasDeferred: node.has_deferred,
+        // @ts-expect-error Flow types expect a more specific symbol set type
+        usedSymbolsDown,
+        usedSymbolsDownDirty: true,
+        usedSymbolsUp,
+        usedSymbolsUpDirtyDown: true,
+        usedSymbolsUpDirtyUp: true,
+        value: dependency,
+      };
+      graph._graph.addNodeByContentKey(id, depNode);
+      continue;
+    }
+
+    if (node.type === 'bundle') {
+      node.value.env = normalizeEnv(node.value.env);
+      node.value.target.env = normalizeEnv(node.value.target.env);
+      graph._graph.addNodeByContentKey(node.id, node as BundleNode);
+      continue;
+    }
+
+    if (node.type === 'bundle_group' || node.type === 'bundleGroup') {
+      // Rust serializer may emit bundleGroup nodes either as `{id,type,value:{...}}`
+      // or as `{type:"bundleGroup", id, target, entryAssetId}`.
+      if (node.value == null) {
+        node.value = {
+          target: node.target,
+          entryAssetId: node.entryAssetId ?? node.entry_asset_id,
+        };
+      }
+
+      // Normalize entry asset id field naming
+      if (
+        node.value.entryAssetId == null &&
+        node.value.entry_asset_id != null
+      ) {
+        node.value.entryAssetId = node.value.entry_asset_id;
+      }
+
+      node.value.target.env = normalizeEnv(node.value.target.env);
+      // Normalise to the expected snake_case type
+      node.type = 'bundle_group';
+      graph._graph.addNodeByContentKey(node.id, node as BundleGroupNode);
+      continue;
+    }
+  }
+
+  // Apply edges
+  for (let i = 0; i < serializedGraph.edges.length; i += 3) {
+    const from = serializedGraph.edges[i];
+    const to = serializedGraph.edges[i + 1];
+    const type = serializedGraph.edges[i + 2];
+
+    const fromNode = graph._graph.getNode(from);
+    const toNode = graph._graph.getNode(to);
+
+    if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+    }
+
+    // If we are adding a references edge, remove existing null edge.
+    if (
+      type === bundleGraphEdgeTypes.references &&
+      graph._graph.hasEdge(from, to, bundleGraphEdgeTypes.null)
+    ) {
+      graph._graph.removeEdge(from, to, bundleGraphEdgeTypes.null);
+    }
+
+    graph._graph.addEdge(from, to, type as any);
+  }
+
+  return {bundleGraph: graph, changedAssets};
+}
+
+class NativeBundlerRunner {
+  options: AtlaspackOptions;
+  optionsRef: any;
+  config!: AtlaspackConfig;
+  pluginOptions: PluginOptions;
+  api: RunAPI<BundleGraphResult>;
+  previousDevDeps: Map<string, string>;
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+  configs: Map<string, Config>;
+  cacheKey: string;
+
+  constructor({api, options}: any, optionsRef: any) {
+    this.options = options;
+    this.api = api;
+    this.optionsRef = optionsRef;
+    this.previousDevDeps = new Map();
+    this.devDepRequests = new Map();
+    this.configs = new Map();
+    this.pluginOptions = new PluginOptions(
+      optionsProxy(this.options, api.invalidateOnOptionChange),
+    );
+
+    const key = hashString(
+      `${ATLASPACK_VERSION}:BundleGraph:${
+        JSON.stringify(options.entries) ?? ''
+      }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+    );
+    this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+  }
+
+  async loadConfigs() {
+    const configResult = nullthrows(
+      await this.api.runRequest<null, ConfigAndCachePath>(
+        createAtlaspackConfigRequest(),
+      ),
+    );
+
+    this.config = getCachedAtlaspackConfig(configResult, this.options);
+
+    const {devDeps, invalidDevDeps} = await getDevDepRequests(this.api);
+    this.previousDevDeps = devDeps;
+    invalidateDevDeps(invalidDevDeps, this.options, this.config);
+
+    const bundler = await this.config.getBundler();
+    await this.loadPluginConfig(bundler);
+
+    const namers = await this.config.getNamers();
+    for (const namer of namers) {
+      await this.loadPluginConfig(namer);
+    }
+
+    const runtimes = await this.config.getRuntimes();
+    for (const runtime of runtimes) {
+      await this.loadPluginConfig(runtime);
+    }
+  }
+
+  async loadPluginConfig<T extends PluginWithLoadConfig>(
+    plugin: LoadedPlugin<T>,
+  ) {
+    await loadPluginConfigWithDevDeps(
+      plugin,
+      this.options,
+      this.api,
+      this.previousDevDeps,
+      this.devDepRequests,
+      this.configs,
+    );
+  }
+}