@atlaspack/core 2.33.1 → 2.34.0

package/lib/requests/AssetGraphRequestRust.js

@@ -20,7 +20,7 @@ function _diagnostic() {
   return data;
 }
 function _logger() {
-  const data = require("@atlaspack/logger");
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
@@ -39,13 +39,15 @@ var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
 var _Environment = require("../Environment");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
+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 createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
     type: _RequestTracker.requestTypes.asset_graph_request,
     id: input.name,
-    run: async input => {
-      let options = input.options;
+    run: async runInput => {
+      let options = runInput.options;
       let {
         assetGraphPromise,
         commitPromise
@@ -60,7 +62,7 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       // 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();
+        prevResult = await runInput.api.getPreviousResult();
       }
       let {
         assetGraph,
@@ -70,20 +72,28 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         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,
-        assetGraph,
-        changedAssetsPropagation,
-        assetGroupsWithRemovedParents: new Set(),
-        previousErrors: new Map() //this.previousSymbolPropagationErrors,
-      });
-
-      if (errors.size > 0) {
-        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-        throw new (_diagnostic().default)({
-          diagnostic: [...errors.values()][0]
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (input.skipSymbolProp) {
+        _logger().default.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph'
+        });
+      } else {
+        let errors = (0, _SymbolPropagation.propagateSymbols)({
+          options,
+          assetGraph,
+          changedAssetsPropagation,
+          assetGroupsWithRemovedParents: new Set(),
+          previousErrors: new Map() //this.previousSymbolPropagationErrors,
         });
+
+        if (errors.size > 0) {
+          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+          throw new (_diagnostic().default)({
+            diagnostic: [...errors.values()][0]
+          });
+        }
       }
       await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
       let result = {
@@ -102,8 +112,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
           }
         });
       }
-      await input.api.storeResult(result);
-      input.api.invalidateOnBuild();
+      await runInput.api.storeResult(result);
+      runInput.api.invalidateOnBuild();
       return result;
     },
     input
@@ -253,6 +263,17 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
       }
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();
+      if (node.used_symbols_up) {
+        for (let usedSymbol of node.used_symbols_up) {
+          // Transform Rust UsedSymbol { symbol: Symbol, asset: string }
+          // to JS format { symbol: string, asset: string } where symbol is the exported name
+          const exportedName = usedSymbol.symbol.exported;
+          usedSymbolsUp.set(exportedName, {
+            asset: usedSymbol.asset,
+            symbol: exportedName
+          });
+        }
+      }
       if (dependency.isEntry && dependency.isLibrary) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);

package/lib/requests/BundleGraphRequest.js

@@ -136,7 +136,8 @@ function createBundleGraphRequest(input) {
         shouldBuildLazily: options.shouldBuildLazily,
         lazyIncludes: options.lazyIncludes,
         lazyExcludes: options.lazyExcludes,
-        requestedAssetIds
+        requestedAssetIds,
+        skipSymbolProp: (0, _featureFlags().getFeatureFlag)('rustSymbolTracker')
       });
       let {
         assetGraph,

package/lib/requests/WriteBundleRequest.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.computeSourceMapRoot = computeSourceMapRoot;
 exports.default = createWriteBundleRequest;
 var _constants = require("../constants");
 function _nullthrows() {
@@ -19,6 +21,13 @@ function _path() {
   };
   return data;
 }
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
 var _Bundle = require("../public/Bundle");
 function _utils() {
   const data = require("@atlaspack/utils");
@@ -68,11 +77,19 @@ function _featureFlags() {
   return data;
 }
 var _EnvironmentManager = require("../EnvironmentManager");
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = 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 }; }
 const HASH_REF_PREFIX_LEN = _constants.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = _constants.HASH_REF_PREFIX.length + 32 - 1;
+const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN;
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -158,11 +175,28 @@ async function run({
     invalidDevDeps
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
-  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
+  const bundleReplacements = (0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') ? [] : undefined;
+  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
   const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
-    const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
-    await writeFiles((0, _utils().blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    let mapStream;
+    if ((0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') && bundleReplacements && bundleReplacements.length > 0) {
+      const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+      const mapBuffer = Buffer.isBuffer(mapEntry) ? mapEntry : Buffer.from(mapEntry);
+      const projectRoot = typeof options.projectRoot === 'string' ? options.projectRoot : String(options.projectRoot);
+      const sourceMap = new (_sourceMap().default)(projectRoot, mapBuffer);
+      applyReplacementsToSourceMap(sourceMap, bundleReplacements);
+      const mapJson = await sourceMap.stringify({
+        format: 'string',
+        file: name,
+        sourceRoot: computeSourceMapRoot(bundle, options)
+      });
+      mapStream = (0, _utils().blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+    } else {
+      const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+      mapStream = (0, _utils().blobToStream)(mapEntry);
+    }
+    await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
@@ -176,12 +210,71 @@ async function run({
   api.storeResult(res);
   return res;
 }
+function applyReplacementsToSourceMap(sourceMap, replacements) {
+  if (replacements.length === 0) return;
+  const sorted = [...replacements].sort((a, b) => a.line - b.line || a.column - b.column);
+  for (const r of sorted) {
+    const delta = r.newLength - r.originalLength;
+    if (delta !== 0) {
+      // r.column is in post-replacement coordinates (matching the already-shifted
+      // source map state after previous offsetColumns calls). The end of the
+      // placeholder in these coordinates is simply r.column + r.originalLength.
+      const offsetStartColumn = r.column + r.originalLength;
+      const line1Based = r.line + 1;
+      if (line1Based >= 1 && offsetStartColumn + delta >= 0) {
+        sourceMap.offsetColumns(line1Based, offsetStartColumn, delta);
+      }
+    }
+  }
+}
+
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+function computeSourceMapRoot(bundle, options) {
+  let name = (0, _nullthrows().default)(bundle.name);
+  let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, name);
+  let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
+  let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), options.projectRoot);
+  let inlineSources = false;
+  const bundleEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
+  if (bundle.target) {
+    const bundleTargetEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.target.env);
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+      sourceRoot = bundleEnv.sourceMap.sourceRoot;
+    } else if (options.serveOptions && bundleTargetEnv.context === 'browser') {
+      sourceRoot = '/__parcel_source_root';
+    }
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources !== undefined) {
+      inlineSources = bundleEnv.sourceMap.inlineSources;
+    } else if (bundleTargetEnv.context !== 'node') {
+      inlineSources = options.mode === 'production';
+    }
+  }
+  let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+  if ((0, _featureFlags().getFeatureFlag)('omitSourcesContentInMemory') && !isInlineMap) {
+    if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+      inlineSources = true;
+    }
+  }
+  if (inlineSources) {
+    return undefined;
+  }
+  return _url().default.format(_url().default.parse(sourceRoot + '/'));
+}
 async function writeFiles(
 // @ts-expect-error TS2503
-inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements) {
   let compressors = await config.getCompressors((0, _projectPath.fromProjectPathRelative)(filePath));
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash)) : inputStream;
+  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements)) : inputStream;
   let promises = [];
   for (let compressor of compressors) {
     promises.push(
@@ -230,9 +323,25 @@ stream, options, outputFS, filePath, writeOptions, devDeps, api) {
     await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
   }
 }
-function replaceStream(hashRefToNameHash) {
+function advanceLineColumn(line, column, buf) {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0x0a) {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return {
+    line,
+    column
+  };
+}
+function replaceStream(hashRefToNameHash, replacements) {
   let boundaryStr = Buffer.alloc(0);
   let replaced = Buffer.alloc(0);
+  let outputLine = 0;
+  let outputColumn = 0;
   return new (_stream().Transform)({
     transform(chunk, encoding, cb) {
       let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
@@ -250,15 +359,29 @@ function replaceStream(hashRefToNameHash) {
         } else {
           let match = str.subarray(matchI, matchI + HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN).toString();
           let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+          // Copy pre-match content FIRST so position calculation includes it
           replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
           replacedLength += matchI - lastMatchI;
+          if (replacements) {
+            const pos = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, replacedLength));
+            replacements.push({
+              line: pos.line,
+              column: pos.column,
+              originalLength: HASH_REF_PLACEHOLDER_LEN,
+              newLength: replacement.byteLength
+            });
+          }
           replaced.set(replacement, replacedLength);
           replacedLength += replacement.byteLength;
           lastMatchI = matchI + HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN;
         }
       }
+      const pushLen = replacedLength - BOUNDARY_LENGTH;
+      const pushed = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, pushLen));
+      outputLine = pushed.line;
+      outputColumn = pushed.column;
       boundaryStr = replaced.subarray(replacedLength - BOUNDARY_LENGTH, replacedLength);
-      let strUpToBoundary = replaced.subarray(0, replacedLength - BOUNDARY_LENGTH);
+      let strUpToBoundary = replaced.subarray(0, pushLen);
       cb(null, strUpToBoundary);
     },
     flush(cb) {

package/lib/requests/WriteBundlesRequest.js

@@ -40,6 +40,13 @@ function _utils() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/** Length of the hash suffix in output filenames (e.g. .runtime.13dc01ac.js). */
+const NAME_HASH_DISPLAY_LEN = 8;
+
+/** Use at most NAME_HASH_DISPLAY_LEN chars for the name hash so filenames stay short. */
+function nameHashForFilename(hash) {
+  return hash.length <= NAME_HASH_DISPLAY_LEN ? hash : hash.slice(-NAME_HASH_DISPLAY_LEN);
+}
 function reportPackagingProgress(completeBundles, totalBundles) {
   if (!(0, _featureFlags().getFeatureFlag)('cliProgressReportingImprovements')) {
     return;
@@ -92,9 +99,9 @@ async function run({
     // Do not package and write placeholder bundles to disk. We just
     // need to update the name so other bundles can reference it.
     if (bundle.isPlaceholder) {
-      let hash = bundle.id.slice(-8);
-      hashRefToNameHash.set(bundle.hashReference, hash);
-      let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
+      const nameHash = nameHashForFilename(bundle.id);
+      hashRefToNameHash.set(bundle.hashReference, nameHash);
+      let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, nameHash);
       res.set(bundle.id, {
         filePath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, name),
         bundleId: bundle.id,
@@ -143,7 +150,7 @@ async function run({
       }
       bundleInfoMap[bundle.id] = info;
       if (!info.hashReferences.length) {
-        hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? info.hash.slice(-8) : bundle.id.slice(-8));
+        hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash ? info.hash : bundle.id));
         let writeBundleRequest = (0, _WriteBundleRequest.default)({
           bundle,
           info,
@@ -195,7 +202,7 @@ function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, opti
     if (hashRefToNameHash.get(bundle.hashReference) != null) {
       continue;
     }
-    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
+    hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')) : bundle.id));
   }
 }
 function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {

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

@@ -1,10 +1,17 @@
 import type { ContentKey } from '@atlaspack/graph';
 import type { Async } from '@atlaspack/types';
 import type { StaticRunOpts } from '../RequestTracker';
-import type { Bundle, PackagedBundleInfo } from '../types';
+import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
 import type BundleGraph from '../BundleGraph';
 import type { BundleInfo } from '../PackagerRunner';
 import { requestTypes } from '../RequestTracker';
+import SourceMap from '@atlaspack/source-map';
+export type HashRefReplacement = {
+    line: number;
+    column: number;
+    originalLength: number;
+    newLength: number;
+};
 type WriteBundleRequestInput = {
     bundleGraph: BundleGraph;
     bundle: Bundle;
@@ -25,4 +32,16 @@ export type WriteBundleRequest = {
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
 export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
+export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+export declare function computeSourceMapRoot(bundle: Bundle, options: AtlaspackOptions): string | undefined;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.33.1",
+  "version": "2.34.0",
   "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.11",
-    "@atlaspack/cache": "3.2.48",
+    "@atlaspack/build-cache": "2.13.12",
+    "@atlaspack/cache": "3.2.49",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@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",
+    "@atlaspack/feature-flags": "2.30.0",
+    "@atlaspack/fs": "2.15.49",
+    "@atlaspack/graph": "3.6.16",
+    "@atlaspack/logger": "2.14.46",
+    "@atlaspack/package-manager": "2.14.54",
+    "@atlaspack/plugin": "2.14.54",
+    "@atlaspack/profiler": "2.15.15",
+    "@atlaspack/rust": "3.23.0",
+    "@atlaspack/types": "2.15.44",
+    "@atlaspack/utils": "3.3.6",
+    "@atlaspack/workers": "2.14.54",
+    "@atlaspack/source-map": "3.2.9",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/PackagerRunner.ts

@@ -30,7 +30,6 @@ import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {Readable} from 'stream';
 import nullthrows from 'nullthrows';
 import path from 'path';
-import url from 'url';
 import {hashString, hashBuffer, Hash} from '@atlaspack/rust';
 
 import {NamedBundle, bundleToInternalBundle} from './public/Bundle';
@@ -60,6 +59,7 @@ import {
 import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
+import {computeSourceMapRoot} from './requests/WriteBundleRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {fromEnvironmentId} from './EnvironmentManager';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
@@ -590,64 +590,24 @@ export default class PackagerRunner {
     bundle: InternalBundle,
     map: SourceMap,
   ): Promise<string> {
-    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+    let sourceRoot = computeSourceMapRoot(bundle, this.options);
+    let inlineSources = sourceRoot === undefined;
+
     let filePath = joinProjectPath(
       bundle.target.distDir,
       nullthrows(bundle.name),
     );
     let fullPath = fromProjectPath(this.options.projectRoot, filePath);
-    let sourceRoot: string = path.relative(
-      path.dirname(fullPath),
-      this.options.projectRoot,
-    );
-    let inlineSources = false;
+    let mapFilename = fullPath + '.map';
 
     const bundleEnv = fromEnvironmentId(bundle.env);
-    if (bundle.target) {
-      const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
-
-      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
-        sourceRoot = bundleEnv.sourceMap.sourceRoot;
-      } else if (
-        this.options.serveOptions &&
-        bundleTargetEnv.context === 'browser'
-      ) {
-        sourceRoot = '/__parcel_source_root';
-      }
-
-      if (
-        bundleEnv.sourceMap &&
-        bundleEnv.sourceMap.inlineSources !== undefined
-      ) {
-        inlineSources = bundleEnv.sourceMap.inlineSources;
-      } else if (bundleTargetEnv.context !== 'node') {
-        // inlining should only happen in production for browser targets by default
-        inlineSources = this.options.mode === 'production';
-      }
-    }
-
-    let mapFilename = fullPath + '.map';
     let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
 
-    if (getFeatureFlag('omitSourcesContentInMemory') && !isInlineMap) {
-      if (
-        !(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)
-      ) {
-        /*
-          We're omitting sourcesContent during transformation to allow GC to run.
-          Ensure sources are still inlined into the final source maps written to disk. UNLESS the user explicitly disabled inlineSources.
-        */
-        inlineSources = true;
-      }
-    }
-
     let stringified = await map.stringify({
       file: path.basename(mapFilename),
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,
-      sourceRoot: !inlineSources
-        ? url.format(url.parse(sourceRoot + '/'))
-        : undefined,
+      sourceRoot,
       inlineSources,
       format: isInlineMap ? 'inline' : 'string',
     });

package/src/applyRuntimes.ts

@@ -505,7 +505,9 @@ function reconcileNewRuntimes<TResult extends RequestResult>(
     name: 'Runtimes',
     assetGroups,
     optionsRef,
-    skipSymbolProp: getFeatureFlag('skipRuntimeSymbolProp'),
+    skipSymbolProp:
+      getFeatureFlag('skipRuntimeSymbolProp') ||
+      getFeatureFlag('rustSymbolTracker'),
   });
 
   // rebuild the graph

package/src/requests/AssetGraphRequestRust.ts

@@ -2,7 +2,7 @@ import invariant from 'assert';
 
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Async} from '@atlaspack/types';
-import {instrument} from '@atlaspack/logger';
+import logger, {instrument} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph from '../AssetGraph';
@@ -51,8 +51,8 @@ export function createAssetGraphRequestRust(
   return (input: AssetGraphRequestInput) => ({
     type: requestTypes.asset_graph_request,
     id: input.name,
-    run: async (input) => {
-      let options = input.options;
+    run: async (runInput) => {
+      let options = runInput.options;
       let {assetGraphPromise, commitPromise} =
         await rustAtlaspack.buildAssetGraph();
 
@@ -69,7 +69,7 @@ export function createAssetGraphRequestRust(
       let prevResult = null;
       if (serializedAssetGraph.hadPreviousGraph) {
         prevResult =
-          await input.api.getPreviousResult<AssetGraphRequestResult>();
+          await runInput.api.getPreviousResult<AssetGraphRequestResult>();
       }
 
       let {assetGraph, changedAssets} = instrument(
@@ -78,20 +78,28 @@ export function createAssetGraphRequestRust(
       );
 
       let changedAssetsPropagation = new Set(changedAssets.keys());
-      let errors = propagateSymbols({
-        options,
-        assetGraph,
-        changedAssetsPropagation,
-        assetGroupsWithRemovedParents: new Set(),
-        previousErrors: new Map(), //this.previousSymbolPropagationErrors,
-      });
-
-      if (errors.size > 0) {
-        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-        throw new ThrowableDiagnostic({
-          diagnostic: [...errors.values()][0],
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (input.skipSymbolProp) {
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph',
         });
+      } else {
+        let errors = propagateSymbols({
+          options,
+          assetGraph,
+          changedAssetsPropagation,
+          assetGroupsWithRemovedParents: new Set(),
+          previousErrors: new Map(), //this.previousSymbolPropagationErrors,
+        });
+
+        if (errors.size > 0) {
+          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+          throw new ThrowableDiagnostic({
+            diagnostic: [...errors.values()][0],
+          });
+        }
       }
 
       await dumpGraphToGraphViz(assetGraph, 'AssetGraphV3');
@@ -116,8 +124,8 @@ export function createAssetGraphRequestRust(
         });
       }
 
-      await input.api.storeResult(result);
-      input.api.invalidateOnBuild();
+      await runInput.api.storeResult(result);
+      runInput.api.invalidateOnBuild();
 
       return result;
     },
@@ -314,6 +322,19 @@ export function getAssetGraph(
 
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();
+
+      if (node.used_symbols_up) {
+        for (let usedSymbol of node.used_symbols_up) {
+          // Transform Rust UsedSymbol { symbol: Symbol, asset: string }
+          // to JS format { symbol: string, asset: string } where symbol is the exported name
+          const exportedName = usedSymbol.symbol.exported;
+          usedSymbolsUp.set(exportedName, {
+            asset: usedSymbol.asset,
+            symbol: exportedName,
+          });
+        }
+      }
+
       if (dependency.isEntry && dependency.isLibrary) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);

package/src/requests/BundleGraphRequest.ts

@@ -151,6 +151,7 @@ export default function createBundleGraphRequest(
         lazyIncludes: options.lazyIncludes,
         lazyExcludes: options.lazyExcludes,
         requestedAssetIds,
+        skipSymbolProp: getFeatureFlag('rustSymbolTracker'),
       });
 
       let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(