@atlaspack/core 2.27.0 → 2.28.0

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/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/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.27.0",
+  "version": "2.28.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,21 +24,21 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.33",
+    "@atlaspack/cache": "3.2.34",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.26.2",
-    "@atlaspack/fs": "2.15.33",
-    "@atlaspack/graph": "3.6.0",
-    "@atlaspack/logger": "2.14.30",
-    "@atlaspack/package-manager": "2.14.38",
-    "@atlaspack/plugin": "2.14.38",
-    "@atlaspack/profiler": "2.14.35",
-    "@atlaspack/rust": "3.10.0",
-    "@atlaspack/types": "2.15.28",
-    "@atlaspack/utils": "3.1.2",
-    "@atlaspack/workers": "2.14.38",
-    "@parcel/source-map": "^2.1.1",
+    "@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",

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.

package/src/BundleGraph.ts

@@ -1435,6 +1435,158 @@ export default class BundleGraph {
     });
   }
 
+  // New method: Fast checks only (no caching of results)
+  isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null {
+    // Fast Check #1: If asset is in multiple bundles in same target, it's referenced
+    let bundlesWithAsset = this.getBundlesWithAsset(asset).filter(
+      (b) =>
+        b.target.name === bundle.target.name &&
+        b.target.distDir === bundle.target.distDir,
+    );
+
+    if (bundlesWithAsset.length > 1) {
+      return true;
+    }
+
+    // Fast Check #2: If asset is referenced by any async/conditional dependency, it's referenced
+    let assetNodeId = nullthrows(this._graph.getNodeIdByContentKey(asset.id));
+
+    if (
+      this._graph
+        .getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references)
+        .map((id) => this._graph.getNode(id))
+        .some(
+          (node) =>
+            node?.type === 'dependency' &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
+            node.value.specifierType !== SpecifierType.url,
+        )
+    ) {
+      return true;
+    }
+
+    // Fast checks failed - return null to indicate expensive computation needed
+    return null;
+  }
+
+  getReferencedAssets(bundle: Bundle): Set<Asset> {
+    let referencedAssets = new Set<Asset>();
+
+    // Build a map of all assets in this bundle with their dependencies
+    // This allows us to check all assets in a single traversal
+    let assetDependenciesMap = new Map<Asset, Array<Dependency>>();
+
+    this.traverseAssets(bundle, (asset) => {
+      // Always do fast checks (no caching)
+      let fastCheckResult = this.isAssetReferencedFastCheck(bundle, asset);
+
+      if (fastCheckResult === true) {
+        referencedAssets.add(asset);
+        return;
+      }
+
+      // Fast checks failed (fastCheckResult === null), need expensive computation
+      // Check if it's actually referenced via traversal
+
+      // Store dependencies for later batch checking
+      let dependencies = this._graph
+        .getNodeIdsConnectedTo(
+          nullthrows(this._graph.getNodeIdByContentKey(asset.id)),
+        )
+        .map((id) => nullthrows(this._graph.getNode(id)))
+        .filter((node) => node.type === 'dependency')
+        .map((node) => {
+          invariant(node.type === 'dependency');
+          return node.value;
+        });
+
+      if (dependencies.length > 0) {
+        assetDependenciesMap.set(asset, dependencies);
+      }
+    });
+
+    // If no assets need the expensive check, return early
+    if (assetDependenciesMap.size === 0) {
+      return referencedAssets;
+    }
+
+    // Get the assets we need to check once
+    let assetsToCheck = Array.from(assetDependenciesMap.keys());
+
+    // Helper function to check if all assets from assetDependenciesMap are in referencedAssets
+    const allAssetsReferenced = (): boolean =>
+      assetsToCheck.length <= referencedAssets.size &&
+      assetsToCheck.every((asset) => referencedAssets.has(asset));
+
+    // Do ONE traversal to check all remaining assets
+    // We can share visitedBundles across all assets because we check every asset
+    // against every visited bundle, which matches the original per-asset behavior
+    let siblingBundles = new Set(
+      this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) =>
+        this.getBundlesInBundleGroup(bundleGroup, {includeInline: true}),
+      ),
+    );
+
+    let visitedBundles: Set<Bundle> = new Set();
+
+    // Single traversal from all referencers
+    for (let referencer of siblingBundles) {
+      this.traverseBundles((descendant, _, actions) => {
+        if (descendant.id === bundle.id) {
+          return;
+        }
+
+        if (visitedBundles.has(descendant)) {
+          actions.skipChildren();
+          return;
+        }
+
+        visitedBundles.add(descendant);
+
+        if (
+          descendant.type !== bundle.type ||
+          fromEnvironmentId(descendant.env).context !==
+            fromEnvironmentId(bundle.env).context
+        ) {
+          // Don't skip children - they might be the right type!
+          return;
+        }
+
+        // Check ALL assets at once in this descendant bundle
+        for (let [asset, dependencies] of assetDependenciesMap) {
+          // Skip if already marked as referenced
+          if (referencedAssets.has(asset)) {
+            continue;
+          }
+
+          // Check if this descendant bundle references the asset
+          if (
+            !this.bundleHasAsset(descendant, asset) &&
+            dependencies.some((dependency) =>
+              this.bundleHasDependency(descendant, dependency),
+            )
+          ) {
+            referencedAssets.add(asset);
+          }
+        }
+
+        // If all assets from assetDependenciesMap are now marked as referenced, we can stop early
+        if (allAssetsReferenced()) {
+          actions.stop();
+          return;
+        }
+      }, referencer);
+
+      // If all assets from assetDependenciesMap are referenced, no need to check more sibling bundles
+      if (allAssetsReferenced()) {
+        break;
+      }
+    }
+
+    return referencedAssets;
+  }
+
   hasParentBundleOfType(bundle: Bundle, type: string): boolean {
     let parents = this.getParentBundles(bundle);
     return (

package/src/CommittedAsset.ts

@@ -3,7 +3,7 @@ import {Readable} from 'stream';
 import {deserializeRaw} from '@atlaspack/build-cache';
 import type {AST, Blob} from '@atlaspack/types';
 import {bufferStream, blobToStream, streamFromPromise} from '@atlaspack/utils';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 
 import {generateFromAST} from './assetUtils';
 import type {Asset, Dependency, AtlaspackOptions} from './types';

package/src/PackagerRunner.ts

@@ -7,7 +7,7 @@ import type {
   NamedBundle as NamedBundleType,
   Async,
 } from '@atlaspack/types';
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {
   Bundle as InternalBundle,
   Config,

package/src/Transformation.ts

@@ -69,6 +69,7 @@ import {
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
 import invariant from 'assert';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import SourceMap from '@atlaspack/source-map';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
@@ -460,7 +461,7 @@ export default class Transformation {
           if (asset.isASTDirty && asset.generate) {
             let output = await asset.generate();
             asset.content = output.content;
-            asset.mapBuffer = output.map?.toBuffer();
+            asset.mapBuffer = SourceMap.safeToBuffer(output.map);
           }
 
           asset.clearAST();
@@ -634,7 +635,7 @@ export default class Transformation {
     ) {
       let output = await asset.generate();
       asset.content = output.content;
-      asset.mapBuffer = output.map?.toBuffer();
+      asset.mapBuffer = SourceMap.safeToBuffer(output.map);
     }
 
     // Load config for the transformer.

package/src/UncommittedAsset.ts

@@ -11,7 +11,7 @@ import type {Asset, Dependency, AtlaspackOptions, Invalidations} from './types';
 
 import invariant from 'assert';
 import {Readable} from 'stream';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {serializeRaw} from '@atlaspack/build-cache';
 import {
   blobToStream,
@@ -249,7 +249,7 @@ export default class UncommittedAsset {
 
     if (map) {
       this.map = map;
-      this.mapBuffer = map.toBuffer();
+      this.mapBuffer = SourceMap.safeToBuffer(map);
       this.setCode(code.replace(SOURCEMAP_RE, ''));
     }
 
@@ -425,7 +425,7 @@ export default class UncommittedAsset {
       content,
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
-      mapBuffer: result.map ? result.map.toBuffer() : null,
+      mapBuffer: SourceMap.safeToBuffer(result.map),
       code: this.code,
       invalidations: this.invalidations,
     });

package/src/assetUtils.ts

@@ -39,6 +39,7 @@ import {PluginTracer} from '@atlaspack/profiler';
 import {identifierRegistry} from './IdentifierRegistry';
 import type {EnvironmentRef} from './EnvironmentManager';
 import {toEnvironmentId} from './EnvironmentManager';
+import SourceMap from '@atlaspack/source-map';
 
 export type AssetOptions = {
   id?: string;
@@ -180,7 +181,7 @@ async function _generateFromAST(asset: CommittedAsset | UncommittedAsset) {
     tracer: new PluginTracer({origin: pluginName, category: 'asset-generate'}),
   });
 
-  let mapBuffer = map?.toBuffer();
+  let mapBuffer = SourceMap.safeToBuffer(map);
   // Store the results in the cache so we can avoid generating again next time
   await Promise.all([
     asset.options.cache.setStream(

package/src/atlaspack-v3/worker/compat/mutable-asset.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 {

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

@@ -171,7 +171,7 @@ export class AtlaspackWorker {
           type: 'resolved',
           filePath: result.filePath || '',
           canDefer: result.canDefer || false,
-          sideEffects: result.sideEffects || false,
+          sideEffects: result.sideEffects ?? true,
           code: result.code || undefined,
           meta: result.meta || undefined,
           pipeline: result.pipeline || undefined,

package/src/public/Asset.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';
 

package/src/public/BundleGraph.ts

@@ -198,6 +198,27 @@ export default class BundleGraph<TBundle extends IBundle>
     );
   }
 
+  isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null {
+    return this.#graph.isAssetReferencedFastCheck(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  getReferencedAssets(bundle: IBundle): Set<IAsset> {
+    let internalReferencedAssets = this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+    );
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set<IAsset>();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add(assetFromValue(internalAsset, this.#options));
+    }
+
+    return publicReferencedAssets;
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),

package/src/requests/BundleGraphRequest.ts

@@ -17,7 +17,7 @@ import fs from 'fs';
 import invariant from 'assert';
 import assert from 'assert';
 import nullthrows from 'nullthrows';
-import {PluginLogger} from '@atlaspack/logger';
+import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
@@ -155,12 +155,14 @@ export default function createBundleGraphRequest(
         requestedAssetIds,
       });
 
-      let {assetGraph, changedAssets, assetRequests} = await api.runRequest(
-        request,
-        {
-          force:
-            Boolean(input.rustAtlaspack) ||
-            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+      let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(
+        'asset-graph-request',
+        () => {
+          return api.runRequest(request, {
+            force:
+              Boolean(input.rustAtlaspack) ||
+              (options.shouldBuildLazily && requestedAssetIds.size > 0),
+          });
         },
       );
 

package/src/resolveOptions.ts

@@ -269,6 +269,7 @@ export default async function resolveOptions(
       : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,

package/src/types.ts

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

package/src/worker.ts

@@ -21,7 +21,7 @@ import Validation, {ValidationOpts} from './Validation';
 import {AtlaspackConfig} from './AtlaspackConfig';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {clearBuildCaches} from '@atlaspack/build-cache';
-import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initSourcemaps} from '@atlaspack/source-map';
 // @ts-expect-error TS2305
 import {init as initRust} from '@atlaspack/rust';
 import WorkerFarm from '@atlaspack/workers';

package/tsconfig.json

@@ -52,6 +52,9 @@
     },
     {
       "path": "../workers/tsconfig.json"
+    },
+    {
+      "path": "../source-map/tsconfig.json"
     }
   ]
 }