@atlaspack/core 2.32.1 → 2.33.1

package/lib/requests/BundleGraphRequestRust.js

@@ -0,0 +1,378 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createBundleGraphRequestRust;
+exports.getBundleGraph = getBundleGraph;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
+var _applyRuntimes = _interopRequireDefault(require("../applyRuntimes"));
+var _constants = require("../constants");
+var _utils = require("../utils");
+var _DevDepRequest = require("./DevDepRequest");
+var _RequestTracker = require("../RequestTracker");
+var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
+var _BundleGraphRequestUtils = require("./BundleGraphRequestUtils");
+var _EnvironmentManager = require("../EnvironmentManager");
+var _Environment = require("../Environment");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createBundleGraphRequestRust(input) {
+  return {
+    type: _RequestTracker.requestTypes.bundle_graph_request,
+    id: 'BundleGraphRust',
+    run: async runInput => {
+      const {
+        api,
+        options,
+        rustAtlaspack
+      } = runInput;
+      (0, _assert().default)(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
+      let {
+        bundleGraphPromise,
+        commitPromise
+      } = await rustAtlaspack.buildBundleGraph();
+      let [serializedBundleGraph, bundleGraphError] = await bundleGraphPromise;
+      if (bundleGraphError) {
+        throw new (_diagnostic().default)({
+          diagnostic: bundleGraphError
+        });
+      }
+
+      // Don’t reuse previous JS result yet; we just rebuild from scratch.
+      let {
+        bundleGraph,
+        changedAssets
+      } = (0, _logger().instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+      const runner = new NativeBundlerRunner({
+        api,
+        options
+      }, 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 => (0, _BundleGraphRequestUtils.nameBundle)(namers, b, bundleGraph, options, runner.pluginOptions, runner.configs)));
+
+      // Apply runtimes
+      const changedRuntimes = await (0, _logger().instrumentAsync)('applyRuntimes', () => (0, _applyRuntimes.default)({
+        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 (0, _DevDepRequest.createDevDependency)({
+          specifier: namer.name,
+          resolveFrom: namer.resolveFrom
+        }, runner.previousDevDeps, options);
+        await (0, _BundleGraphRequestUtils.runDevDepRequest)(api, devDepRequest, runner.devDepRequests);
+      }
+      (0, _BundleGraphRequestUtils.validateBundles)(bundleGraph);
+      bundleGraph.getBundleGraphHash();
+      await (0, _dumpGraphToGraphViz.default)(
+      // @ts-expect-error Accessing internal graph for debug output
+      bundleGraph._graph, 'after_runtimes_native', _BundleGraph.bundleGraphEdgeTypes);
+      let [_commitResult, commitError] = await commitPromise;
+      if (commitError) {
+        throw new (_diagnostic().default)({
+          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
+}) {
+  let jsSymbol = {
+    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) {
+  if (!env) return env;
+  env.id = env.id || (0, _Environment.getEnvironmentHash)(env);
+  return (0, _EnvironmentManager.toEnvironmentRef)(env);
+}
+function getBundleGraph(serializedGraph) {
+  // 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 _BundleGraph.default({
+    // We intentionally start with an empty graph and add nodes/edges from the Rust payload.
+    // `ContentGraph` will allocate as needed.
+    graph: new (_graph().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();
+  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 = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ? (0, _Environment.getEnvironmentHash)(asset.env) : (0, _Environment.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 = {
+        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 = (0, _Environment.getEnvironmentHash)(dependency.env);
+      dependency.env = normalizeEnv(dependency.env);
+      if (dependency.symbols != null) {
+        var _dependency$symbols;
+        dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _dependency$symbols.map(mapSymbols));
+      }
+      let usedSymbolsDown = new Set();
+      let usedSymbolsUp = new Map();
+      if (dependency.isEntry && dependency.isLibrary) {
+        usedSymbolsDown.add('*');
+        usedSymbolsUp.set('*', undefined);
+      }
+      const depNode = {
+        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);
+      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);
+      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 === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : 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 === _BundleGraph.bundleGraphEdgeTypes.references && graph._graph.hasEdge(from, to, _BundleGraph.bundleGraphEdgeTypes.null)) {
+      graph._graph.removeEdge(from, to, _BundleGraph.bundleGraphEdgeTypes.null);
+    }
+    graph._graph.addEdge(from, to, type);
+  }
+  return {
+    bundleGraph: graph,
+    changedAssets
+  };
+}
+class NativeBundlerRunner {
+  constructor({
+    api,
+    options
+  }, optionsRef) {
+    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.default((0, _utils.optionsProxy)(this.options, api.invalidateOnOptionChange));
+    const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+    this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
+  }
+  async loadConfigs() {
+    const configResult = (0, _nullthrows().default)(await this.api.runRequest((0, _AtlaspackConfigRequest.default)()));
+    this.config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, this.options);
+    const {
+      devDeps,
+      invalidDevDeps
+    } = await (0, _DevDepRequest.getDevDepRequests)(this.api);
+    this.previousDevDeps = devDeps;
+    (0, _DevDepRequest.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(plugin) {
+    await (0, _BundleGraphRequestUtils.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
+  }
+}

package/lib/requests/BundleGraphRequestUtils.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
+exports.nameBundle = nameBundle;
+exports.runDevDepRequest = runDevDepRequest;
+exports.validateBundles = validateBundles;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
+var _Bundle = require("../public/Bundle");
+var _InternalConfig = require("../InternalConfig");
+var _DevDepRequest = require("./DevDepRequest");
+var _ConfigRequest = require("./ConfigRequest");
+var _projectPath = require("../projectPath");
+function _profiler() {
+  const data = require("@atlaspack/profiler");
+  _profiler = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+function validateBundles(bundleGraph) {
+  const bundles = bundleGraph.getBundles();
+  const bundleNames = bundles.map(b => (0, _projectPath.joinProjectPath)(b.target.distDir, (0, _nullthrows().default)(b.name)));
+  _assert().default.deepEqual(bundleNames, (0, _utils().unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' + [...(0, _utils().setSymmetricDifference)(new Set(bundleNames), new Set((0, _utils().unique)(bundleNames)))].join());
+}
+
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
+  const bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, options);
+  const bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
+  for (const namer of namers) {
+    let measurement;
+    try {
+      var _configs$get;
+      measurement = _profiler().tracer.createMeasurement(namer.name, 'namer', bundle.id);
+      const name = await namer.plugin.name({
+        bundle,
+        bundleGraph,
+        config: (_configs$get = configs.get(namer.name)) === null || _configs$get === void 0 ? void 0 : _configs$get.result,
+        options: pluginOptions,
+        logger: new (_logger().PluginLogger)({
+          origin: namer.name
+        }),
+        tracer: new (_profiler().PluginTracer)({
+          origin: namer.name,
+          category: 'namer'
+        })
+      });
+      if (name != null) {
+        internalBundle.name = name;
+        const {
+          hashReference
+        } = internalBundle;
+        internalBundle.displayName = name.includes(hashReference) ? name.replace(hashReference, '[hash]') : name;
+        return;
+      }
+    } catch (e) {
+      throw new (_diagnostic().default)({
+        diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+          origin: namer.name
+        })
+      });
+    } finally {
+      measurement && measurement.end();
+    }
+  }
+  throw new Error('Unable to name bundle');
+}
+
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+async function loadPluginConfigWithDevDeps(plugin, options, api, previousDevDeps, devDepRequests, configs) {
+  const config = (0, _InternalConfig.createConfig)({
+    plugin: plugin.name,
+    searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
+  });
+  await (0, _ConfigRequest.loadPluginConfig)(plugin, config, options);
+  await (0, _ConfigRequest.runConfigRequest)(api, config);
+  for (const devDep of config.devDeps) {
+    const devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, previousDevDeps, options);
+    await runDevDepRequest(api, devDepRequest, devDepRequests);
+  }
+  configs.set(plugin.name, config);
+}
+
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+async function runDevDepRequest(api, devDepRequest, devDepRequests) {
+  const {
+    specifier,
+    resolveFrom
+  } = devDepRequest;
+  const key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
+  devDepRequests.set(key, devDepRequest);
+  await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
+}

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -25,6 +25,7 @@ export declare class AtlaspackV3 {
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
     buildAssetGraph(): Promise<any>;
+    buildBundleGraph(): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
     package(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;

package/lib/types/atlaspack-v3/worker/worker.d.ts

@@ -23,6 +23,7 @@ export declare class AtlaspackWorker {
         env: {
             [k: string]: string | undefined;
         };
+        disableCache: boolean | undefined;
     } | undefined>;
 }
 type LoadPluginOptions = {

package/lib/types/requests/BundleGraphRequestRust.d.ts

@@ -0,0 +1,34 @@
+import type { Async } from '@atlaspack/types';
+import InternalBundleGraph from '../BundleGraph';
+import { requestTypes, StaticRunOpts } from '../RequestTracker';
+import type { BundleGraphResult } from './BundleGraphRequest';
+import type { Asset } from '../types';
+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;
+export declare function getBundleGraph(serializedGraph: SerializedBundleGraph): {
+    bundleGraph: InternalBundleGraph;
+    changedAssets: Map<string, Asset>;
+};
+export {};

package/lib/types/requests/BundleGraphRequestUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+import type { Namer } from '@atlaspack/types';
+import type { LoadedPlugin } from '../AtlaspackConfig';
+import type { RunAPI } from '../RequestTracker';
+import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from '../types';
+import InternalBundleGraph from '../BundleGraph';
+import PluginOptions from '../public/PluginOptions';
+import { PluginWithLoadConfig } from './ConfigRequest';
+import type { BundleGraphResult } from './BundleGraphRequest';
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+export declare function validateBundles(bundleGraph: InternalBundleGraph): void;
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+export declare function nameBundle(namers: Array<LoadedPlugin<Namer<unknown>>>, internalBundle: InternalBundle, internalBundleGraph: InternalBundleGraph, options: AtlaspackOptions, pluginOptions: PluginOptions, configs: Map<string, Config>): Promise<void>;
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+export declare function loadPluginConfigWithDevDeps<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>, options: AtlaspackOptions, api: RunAPI<BundleGraphResult>, previousDevDeps: Map<string, string>, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>, configs: Map<string, Config>): Promise<void>;
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+export declare function runDevDepRequest(api: RunAPI<BundleGraphResult>, devDepRequest: DevDepRequest | DevDepRequestRef, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.32.1",
+  "version": "2.33.1",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,22 +23,22 @@
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.9",
-    "@atlaspack/cache": "3.2.46",
+    "@atlaspack/build-cache": "2.13.11",
+    "@atlaspack/cache": "3.2.48",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.28.0",
-    "@atlaspack/fs": "2.15.46",
-    "@atlaspack/graph": "3.6.13",
-    "@atlaspack/logger": "2.14.43",
-    "@atlaspack/package-manager": "2.14.51",
-    "@atlaspack/plugin": "2.14.51",
-    "@atlaspack/profiler": "2.15.12",
-    "@atlaspack/rust": "3.21.0",
-    "@atlaspack/types": "2.15.41",
-    "@atlaspack/utils": "3.3.3",
-    "@atlaspack/workers": "2.14.51",
-    "@atlaspack/source-map": "3.2.6",
+    "@atlaspack/feature-flags": "2.29.1",
+    "@atlaspack/fs": "2.15.48",
+    "@atlaspack/graph": "3.6.15",
+    "@atlaspack/logger": "2.14.45",
+    "@atlaspack/package-manager": "2.14.53",
+    "@atlaspack/plugin": "2.14.53",
+    "@atlaspack/profiler": "2.15.14",
+    "@atlaspack/rust": "3.22.1",
+    "@atlaspack/types": "2.15.43",
+    "@atlaspack/utils": "3.3.5",
+    "@atlaspack/workers": "2.14.53",
+    "@atlaspack/source-map": "3.2.8",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -1,6 +1,7 @@
 import {
   atlaspackNapiCreate,
   atlaspackNapiBuildAssetGraph,
+  atlaspackNapiBuildBundleGraph,
   atlaspackNapiRespondToFsEvents,
   atlaspackNapiCompleteSession,
   atlaspackNapiLoadBundleGraph,
@@ -101,6 +102,10 @@ export class AtlaspackV3 {
     return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
+  buildBundleGraph(): Promise<any> {
+    return atlaspackNapiBuildBundleGraph(this._atlaspack_napi) as Promise<any>;
+  }
+
   loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {
     const {nodesJson, edges, publicIdByAssetId, environmentsJson} =
       bundleGraph.serializeForNative();

package/src/atlaspack-v3/worker/worker.ts

@@ -424,6 +424,7 @@ export class AtlaspackWorker {
         conditions: setupResult?.conditions,
         config,
         env: allowedEnv,
+        disableCache: setupResult?.disableCache,
       };
     }