@atlaspack/core 2.26.3-dev-compiled-hash-e5f8a1735.0 → 2.28.0

package/lib/public/BundleGraph.js

@@ -114,6 +114,19 @@ class BundleGraph {
   isAssetReferenced(bundle, asset) {
     return this.#graph.isAssetReferenced((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
   }
+  isAssetReferencedFastCheck(bundle, asset) {
+    return this.#graph.isAssetReferencedFastCheck((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
+  }
+  getReferencedAssets(bundle) {
+    let internalReferencedAssets = this.#graph.getReferencedAssets((0, _Bundle.bundleToInternalBundle)(bundle));
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add((0, _Asset.assetFromValue)(internalAsset, this.#options));
+    }
+    return publicReferencedAssets;
+  }
   hasParentBundleOfType(bundle, type) {
     return this.#graph.hasParentBundleOfType((0, _Bundle.bundleToInternalBundle)(bundle), type);
   }

package/lib/requests/AssetGraphRequest.js

@@ -73,7 +73,7 @@ function createAssetGraphRequest(requestInput) {
     run: async input => {
       let prevResult = await input.api.getPreviousResult();
       let builder = new AssetGraphBuilder(input, prevResult);
-      let assetGraphRequest = await await builder.build();
+      let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
       assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally || input.options.mode === 'production');

package/lib/requests/AssetGraphRequestRust.js

@@ -38,6 +38,7 @@ var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
 var _Environment = require("../Environment");
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
@@ -47,12 +48,24 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       let options = input.options;
       let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
 
-      // @ts-expect-error TS7006
+      // Newly created nodes
       serializedAssetGraph.nodes = serializedAssetGraph.nodes.map(node => JSON.parse(node));
+
+      // Updated existing nodes
+      serializedAssetGraph.updates = serializedAssetGraph.updates.map(node => JSON.parse(node));
+
+      // Don't reuse a previous asset graph result if Rust didn't have one too
+      let prevResult = null;
+      if (serializedAssetGraph.hadPreviousGraph) {
+        prevResult = await input.api.getPreviousResult();
+      }
       let {
         assetGraph,
         changedAssets
-      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
+      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => {
+        var _prevResult;
+        return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
+      });
       let changedAssetsPropagation = new Set(changedAssets.keys());
       let errors = (0, _SymbolPropagation.propagateSymbols)({
         options,
@@ -69,7 +82,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
           diagnostic: [...errors.values()][0]
         });
       }
-      return {
+      await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
+      let result = {
         assetGraph,
         assetRequests: [],
         assetGroupsWithRemovedParents: new Set(),
@@ -77,17 +91,54 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined
       };
+      await input.api.storeResult(result);
+      input.api.invalidateOnBuild();
+      return result;
     },
     input
   });
 }
-function getAssetGraph(serializedGraph) {
-  let graph = new _AssetGraph.default({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length
-  });
-  graph.safeToIncrementallyBundle = false;
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+  let graph;
+  let reuseEdges = false;
+  if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      rootNodeId: prevAssetGraph.rootNodeId,
+      adjacencyList: prevAssetGraph.adjacencyList
+    });
+    reuseEdges = true;
+  } else if (prevAssetGraph && (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+      rootNodeId: prevAssetGraph.rootNodeId
+    });
+    graph.safeToIncrementallyBundle = false;
+  } else {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: new Map(),
+      _nodeIdToContentKey: new Map(),
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: serializedGraph.nodes.length + 1
+    });
+    let rootNodeId = graph.addNodeByContentKey('@@root', {
+      id: '@@root',
+      type: 'root',
+      value: null
+    });
+    graph.setRootNodeId(rootNodeId);
+    graph.safeToIncrementallyBundle = false;
+  }
+  (0, _assert().default)(graph, 'Asset graph not initialized');
+  (0, _assert().default)(graph.rootNodeId != null, 'Asset graph has no root node');
 
   // @ts-expect-error TS7031
   function mapSymbols({
@@ -118,20 +169,26 @@ function getAssetGraph(serializedGraph) {
     let envKey = [env.context, env.engines.atlaspack, env.engines.browsers, env.engines.electron, env.engines.node, env.includeNodeModules, env.isLibrary, env.outputFormat, env.shouldScopeHoist, env.shouldOptimize, env.sourceType].join(':');
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = `${envs.size}`;
+      envId = envs.size.toString();
       envs.set(envKey, envId);
     }
     return envId;
   };
-  for (let node of serializedGraph.nodes) {
-    if (node.type === 'root') {
-      let index = graph.addNodeByContentKey('@@root', {
-        id: '@@root',
-        type: 'root',
-        value: null
-      });
-      graph.setRootNodeId(index);
-    } else if (node.type === 'entry') {
+  function updateNode(newNode, isUpdateNode) {
+    if (isUpdateNode) {
+      let existingNode = graph.getNodeByContentKey(newNode.id);
+      (0, _assert().default)(existingNode && existingNode.type === newNode.type);
+      Object.assign(existingNode, newNode);
+    } else {
+      graph.addNodeByContentKey(newNode.id, newNode);
+    }
+  }
+  let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+  let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+  for (let index = 0; index < nodesCount; index++) {
+    let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+    let node = isUpdateNode ? serializedGraph.updates[index - nodeTypeSwitchoverIndex] : serializedGraph.nodes[index];
+    if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
       graph.addNodeByContentKey(id, {
         id: id,
@@ -159,14 +216,15 @@ function getAssetGraph(serializedGraph) {
         asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
       changedAssets.set(id, asset);
-      graph.addNodeByContentKey(id, {
+      let assetNode = {
         id,
         type: 'asset',
         usedSymbols: new Set(),
         usedSymbolsDownDirty: true,
         usedSymbolsUpDirty: true,
         value: asset
-      });
+      };
+      updateNode(assetNode, isUpdateNode);
     } else if (node.type === 'dependency') {
       let {
         dependency,
@@ -187,7 +245,7 @@ function getAssetGraph(serializedGraph) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
       }
-      graph.addNodeByContentKey(id, {
+      let depNode = {
         id,
         type: 'dependency',
         deferred: false,
@@ -200,21 +258,24 @@ function getAssetGraph(serializedGraph) {
         usedSymbolsUpDirtyDown: true,
         usedSymbolsUpDirtyUp: true,
         value: dependency
-      });
+      };
+      updateNode(depNode, isUpdateNode);
     }
   }
-  for (let i = 0; i < serializedGraph.edges.length; i += 2) {
-    let from = serializedGraph.edges[i];
-    let to = serializedGraph.edges[i + 1];
-    let fromNode = graph.getNode(from);
-    let toNode = graph.getNode(to);
-    if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
-      (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-    }
-    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 (!reuseEdges) {
+    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+      let from = serializedGraph.edges[i];
+      let to = serializedGraph.edges[i + 1];
+      let fromNode = graph.getNode(from);
+      let toNode = graph.getNode(to);
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
+        (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
+      }
+      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);
+      }
+      graph.addEdge(from, to);
     }
-    graph.addEdge(from, to);
   }
   return {
     assetGraph: graph,

package/lib/requests/AtlaspackConfigRequest.js

@@ -161,33 +161,23 @@ async function resolveAtlaspackConfig(options) {
     extendedFiles
   } = await parseAndProcessConfig(configPath, contents, options);
   if (options.additionalReporters.length > 0) {
-    if (options.featureFlags.deduplicateReporters) {
-      var _config$reporters;
-      const reporterMap = new Map();
-      options.additionalReporters.forEach(({
+    var _config$reporters;
+    const reporterMap = new Map();
+    options.additionalReporters.forEach(({
+      packageName,
+      resolveFrom
+    }) => {
+      reporterMap.set(packageName, {
         packageName,
         resolveFrom
-      }) => {
-        reporterMap.set(packageName, {
-          packageName,
-          resolveFrom
-        });
-      });
-      (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
-        if (!reporterMap.has(reporter.packageName)) {
-          reporterMap.set(reporter.packageName, reporter);
-        }
       });
-      config.reporters = Array.from(reporterMap.values());
-    } else {
-      config.reporters = [...options.additionalReporters.map(({
-        packageName,
-        resolveFrom
-      }) => ({
-        packageName,
-        resolveFrom
-      })), ...(config.reporters ?? [])];
-    }
+    });
+    (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
+      if (!reporterMap.has(reporter.packageName)) {
+        reporterMap.set(reporter.packageName, reporter);
+      }
+    });
+    config.reporters = Array.from(reporterMap.values());
   }
   return {
     config,

package/lib/requests/BundleGraphRequest.js

@@ -152,8 +152,10 @@ function createBundleGraphRequest(input) {
         assetGraph,
         changedAssets,
         assetRequests
-      } = await api.runRequest(request, {
-        force: Boolean(input.rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
+      } = await (0, _logger().instrumentAsync)('asset-graph-request', () => {
+        return api.runRequest(request, {
+          force: Boolean(input.rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
+        });
       });
       if ((_input$options$featur = input.options.featureFlags) !== null && _input$options$featur !== void 0 && _input$options$featur.loadableSideEffects) {
         applySideEffectsForLoadableImports(assetGraph);

package/lib/resolveOptions.js

@@ -219,6 +219,7 @@ async function resolveOptions(initialOptions) {
     } : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,

package/lib/types/BundleGraph.d.ts

@@ -129,6 +129,8 @@ export default class BundleGraph {
     getDependencies(asset: Asset): Array<Dependency>;
     traverseAssets<TContext>(bundle: Bundle, visit: GraphVisitor<Asset, TContext>, startAsset?: Asset): TContext | null | undefined;
     isAssetReferenced(bundle: Bundle, asset: Asset): boolean;
+    isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null;
+    getReferencedAssets(bundle: Bundle): Set<Asset>;
     hasParentBundleOfType(bundle: Bundle, type: string): boolean;
     getParentBundles(bundle: Bundle): Array<Bundle>;
     isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;

package/lib/types/CommittedAsset.d.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
 import type { AST, Blob } from '@atlaspack/types';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import type { Asset, Dependency, AtlaspackOptions } from './types';
 export default class CommittedAsset {
     key: string | null | undefined;

package/lib/types/PackagerRunner.d.ts

@@ -1,5 +1,5 @@
 import type { Blob, FilePath, BundleResult, Async } from '@atlaspack/types';
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, ReportFn, RequestInvalidation, DevDepRequestRef } from './types';
 import type { AtlaspackConfig, LoadedPlugin } from './AtlaspackConfig';
 import type InternalBundleGraph from './BundleGraph';

package/lib/types/UncommittedAsset.d.ts

@@ -1,7 +1,7 @@
 import type { AST, Blob, DependencyOptions, FileCreateInvalidation, GenerateOutput, PackageName, TransformerResult } from '@atlaspack/types';
 import type { Asset, Dependency, AtlaspackOptions, Invalidations } from './types';
 import { Readable } from 'stream';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import { ProjectPath } from './projectPath';
 type UncommittedAssetOptions = {
     value: Asset;

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

@@ -1,15 +1,14 @@
 import type { BundleBehavior, DependencyPriority, SpecifierType } from '@atlaspack/types';
-export declare class BitFlags<K, V> {
+export declare class BitFlags<K> {
     #private;
-    constructor(source: Partial<Record<K, V>>);
-    into(key: K): V;
-    intoNullable(key?: K | null): V | null | undefined;
-    intoArray(keys: K[]): V[];
-    from(key: V): K;
-    fromNullable(key?: V | null): K | null | undefined;
-    fromArray(keys: V[]): K[];
+    constructor(source: Partial<Record<K, number>>);
+    into(key: K): number;
+    intoNullable(key?: K | null): number | null | undefined;
+    from(key: number): K;
+    fromNullable(key?: number | null): K | null | undefined;
+    toArray(keys: number): K[];
 }
-export declare const bundleBehaviorMap: BitFlags<BundleBehavior, number>;
-export declare const dependencyPriorityMap: BitFlags<DependencyPriority, number>;
-export declare const packageConditionsMap: BitFlags<string, number>;
-export declare const specifierTypeMap: BitFlags<SpecifierType, number>;
+export declare const bundleBehaviorMap: BitFlags<BundleBehavior>;
+export declare const dependencyPriorityMap: BitFlags<DependencyPriority>;
+export declare const packageConditionsMap: BitFlags<string>;
+export declare const specifierTypeMap: BitFlags<SpecifierType>;

package/lib/types/atlaspack-v3/worker/compat/mutable-asset.d.ts

@@ -1,4 +1,4 @@
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import * as napi from '@atlaspack/rust';
 import { Readable } from 'stream';
 import type { MutableAsset as IMutableAsset, Stats, FileSystem, FilePath, Environment, Meta, BundleBehavior, ASTGenerator, AST, Dependency, DependencyOptions, FileCreateInvalidation, EnvironmentOptions } from '@atlaspack/types';

package/lib/types/public/Asset.d.ts

@@ -1,4 +1,4 @@
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type { Readable } from 'stream';
 import type { FileSystem } from '@atlaspack/fs';
 import type { Asset as IAsset, AST, ASTGenerator, Dependency as IDependency, DependencyOptions, Environment as IEnvironment, EnvironmentOptions, FileCreateInvalidation, FilePath, Meta, MutableAsset as IMutableAsset, Stats, MutableAssetSymbols as IMutableAssetSymbols, AssetSymbols as IAssetSymbols, BundleBehavior } from '@atlaspack/types';

package/lib/types/public/BundleGraph.d.ts

@@ -30,6 +30,8 @@ export default class BundleGraph<TBundle extends IBundle> implements IBundleGrap
     getDependencies(asset: IAsset): Array<IDependency>;
     isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean;
     isAssetReferenced(bundle: IBundle, asset: IAsset): boolean;
+    isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null;
+    getReferencedAssets(bundle: IBundle): Set<IAsset>;
     hasParentBundleOfType(bundle: IBundle, type: string): boolean;
     getBundlesInBundleGroup(bundleGroup: IBundleGroup, opts?: {
         includeInline: boolean;

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

@@ -14,7 +14,7 @@ type AssetGraphRequest = {
     input: AssetGraphRequestInput;
 };
 export declare function createAssetGraphRequestRust(rustAtlaspack: AtlaspackV3): (input: AssetGraphRequestInput) => AssetGraphRequest;
-export declare function getAssetGraph(serializedGraph: any): {
+export declare function getAssetGraph(serializedGraph: any, prevAssetGraph?: AssetGraph): {
     assetGraph: AssetGraph;
     changedAssets: Map<string, Asset>;
 };

package/lib/types/types.d.ts

@@ -241,6 +241,7 @@ export type AtlaspackOptions = {
     logLevel: LogLevel;
     projectRoot: FilePath;
     shouldProfile: boolean;
+    nativeProfiler: 'instruments' | 'samply' | undefined;
     shouldTrace: boolean;
     shouldPatchConsole: boolean;
     detailedReport?: DetailedReportOptions | null | undefined;

package/lib/worker.js

@@ -46,7 +46,7 @@ function _buildCache() {
   return data;
 }
 function _sourceMap() {
-  const data = require("@parcel/source-map");
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.26.3-dev-compiled-hash-e5f8a1735.0",
+  "version": "2.28.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,23 +22,23 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.7-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/cache": "3.2.33-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/diagnostic": "2.14.5-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/events": "2.14.5-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/feature-flags": "2.26.2-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/fs": "2.15.33-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/graph": "3.5.27-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/logger": "2.14.30-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/package-manager": "2.14.38-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/plugin": "2.14.38-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/profiler": "2.14.35-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/rust": "3.9.2-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/types": "2.15.28-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/utils": "3.1.2-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/workers": "2.14.38-dev-compiled-hash-e5f8a1735.0",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@parcel/source-map": "^2.1.1",
+    "@atlaspack/build-cache": "2.13.6",
+    "@atlaspack/cache": "3.2.34",
+    "@atlaspack/diagnostic": "2.14.4",
+    "@atlaspack/events": "2.14.4",
+    "@atlaspack/feature-flags": "2.27.0",
+    "@atlaspack/fs": "2.15.34",
+    "@atlaspack/graph": "3.6.1",
+    "@atlaspack/logger": "2.14.31",
+    "@atlaspack/package-manager": "2.14.39",
+    "@atlaspack/plugin": "2.14.39",
+    "@atlaspack/profiler": "2.15.0",
+    "@atlaspack/rust": "3.11.0",
+    "@atlaspack/types": "2.15.29",
+    "@atlaspack/utils": "3.2.0",
+    "@atlaspack/workers": "2.14.39",
+    "@atlaspack/source-map": "3.1.0",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",
@@ -50,16 +50,15 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.5-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/babel-register": "2.14.4",
     "@types/node": ">= 18",
-    "graphviz": "^0.0.9",
-    "jest-diff": "*",
     "rfdc": "1",
+    "jest-diff": "*",
+    "graphviz": "^0.0.9",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "type": "commonjs",
-  "gitHead": "e5f8a173505611c1fafafd6e7dddb2f6b483f67c"
+  "type": "commonjs"
 }

package/src/Atlaspack.ts

@@ -43,7 +43,7 @@ import createPathRequest from './requests/PathRequest';
 import {createEnvironment} from './Environment';
 import {createDependency} from './Dependency';
 import {Disposable} from '@atlaspack/events';
-import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initSourcemaps} from '@atlaspack/source-map';
 import {LMDBLiteCache} from '@atlaspack/cache';
 import {
   // @ts-expect-error TS2305
@@ -57,7 +57,7 @@ import {
   toProjectPath,
   fromProjectPathRelative,
 } from './projectPath';
-import {tracer} from '@atlaspack/profiler';
+import {tracer, NativeProfiler} from '@atlaspack/profiler';
 import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
@@ -407,6 +407,10 @@ export default class Atlaspack {
       if (options.shouldProfile) {
         await this.startProfiling();
       }
+      if (options.nativeProfiler) {
+        const nativeProfiler = new NativeProfiler();
+        await nativeProfiler.startProfiling(options.nativeProfiler);
+      }
       if (options.shouldTrace) {
         tracer.enable();
         // We need to ensure the tracer is disabled when Atlaspack is disposed as it is a module level object.