@atlaspack/core 2.12.1-canary.3556 → 2.12.1-canary.3557

package/lib/CommittedAsset.js

@@ -18,16 +18,16 @@ function _buildCache() {
   };
   return data;
 }
-function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
-  _sourceMap = function () {
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
     return data;
   };
   return data;
 }
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
     return data;
   };
   return data;
@@ -98,6 +98,22 @@ class CommittedAsset {
     if (mapKey != null && this.mapBuffer == null) {
       this.mapBuffer = (async () => {
         try {
+          // Handle v3 assets that were processed by the native asset graph code (i.e. not runtime
+          // or helper assets)
+          if (this.options.featureFlags.atlaspackV3 && this.value.meta.isV3 === true) {
+            let buffer = await this.options.cache.getBuffer(mapKey);
+            if (!buffer) {
+              return buffer;
+            }
+
+            // We make the conversion from json to buffer here, since both js packagers lazily
+            // instantiate a sourcemap from the map buffer. This ensures we do not have to modify
+            // the packagers in any significant way. Additionally, storing the SourceMap objects
+            // upfront in these packagers appears to make larger builds more prone to failing.
+            let sourceMap = new (_sourceMap().default)(this.options.projectRoot);
+            sourceMap.addVLQMap(JSON.parse(buffer.toString()));
+            return sourceMap.toBuffer();
+          }
           return await this.options.cache.getBlob(mapKey);
         } catch (err) {
           if (err.code === 'ENOENT' && this.value.astKey != null) {

package/lib/atlaspack-v3/worker/compat/mutable-asset.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.MutableAsset = void 0;
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
 function _stream() {
   const data = require("stream");
   _stream = function () {
@@ -15,40 +22,42 @@ var _bitflags = require("./bitflags");
 var _assetSymbols = require("./asset-symbols");
 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 }; }
 class MutableAsset {
-  #inner;
+  #astDirty;
   #ast;
   #contents;
-  #astDirty;
+  #inner;
+  #map;
+  #projectRoot;
+  #sourceMap;
   get astGenerator() {
     throw new Error('get MutableAsset.astGenerator');
   }
   set astGenerator(value) {
     throw new Error('set MutableAsset.astGenerator');
   }
-  constructor(asset, contents, env, fs) {
-    this.#inner = asset;
-    this.stats = asset.stats;
-    this.id = asset.id;
+  constructor(asset, contents, env, fs, map, projectRoot) {
+    this.bundleBehavior = _bitflags.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+    this.env = env;
     this.filePath = asset.filePath;
-    this.type;
-    this.symbols = new _assetSymbols.MutableAssetSymbols(asset.symbols);
-    this.stats = asset.stats;
+    this.fs = fs;
     this.id = asset.id;
-    this.filePath = asset.filePath;
-    this.type = asset.type;
-    this.query = new URLSearchParams(asset.query);
+    this.isBundleSplittable = asset.isBundleSplittable;
     this.isSource = asset.isSource;
     this.meta = asset.meta;
-    this.bundleBehavior = _bitflags.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
-    this.isBundleSplittable = asset.isBundleSplittable;
+    this.pipeline = asset.pipeline;
+    this.query = new URLSearchParams(asset.query);
     this.sideEffects = asset.sideEffects;
+    this.stats = asset.stats;
+    this.symbols = new _assetSymbols.MutableAssetSymbols(asset.symbols);
+    this.type = asset.type;
     this.uniqueKey = asset.uniqueKey;
-    this.pipeline = asset.pipeline;
-    this.#contents = contents;
-    this.fs = fs;
-    this.env = env;
     this.#astDirty = false;
+    this.#contents = contents;
+    this.#inner = asset;
+    this.#map = map;
+    this.#projectRoot = projectRoot;
   }
 
   // eslint-disable-next-line require-await
@@ -94,16 +103,23 @@ class MutableAsset {
     });
   }
   getMap() {
-    // TODO: Provide source maps once they exist
-    return Promise.resolve(null);
+    // Only create the source map if it is requested
+    if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
+      let sourceMap = new (_sourceMap().default)(this.#projectRoot);
+      // $FlowFixMe Flow is dumb
+      sourceMap.addVLQMap(JSON.parse(this.#map));
+      this.#sourceMap = sourceMap;
+    }
+    return Promise.resolve(this.#sourceMap);
   }
 
   // eslint-disable-next-line no-unused-vars
-  setMap() {
-    throw new Error('MutableAsset.setMap()');
+  setMap(sourceMap) {
+    this.isMapDirty = true;
+    this.#sourceMap = sourceMap;
   }
   getMapBuffer() {
-    throw new Error('MutableAsset.getMapBuffer');
+    throw new Error('getMapBuffer() is considered an internal implementation detail, please use getMap() instead');
   }
   getDependencies() {
     throw new Error('MutableAsset.getDependencies');

package/lib/atlaspack-v3/worker/worker.js

@@ -169,7 +169,7 @@ class AtlaspackWorker {
     env: napiEnv,
     options,
     asset: innerAsset
-  }, contents) => {
+  }, contents, map) => {
     var _transformer$loadConf;
     const state = this.#transformers.get(key);
     if (!state) {
@@ -187,7 +187,7 @@ class AtlaspackWorker {
       return Promise.resolve(resolvedPath);
     };
     const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs);
+    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs, map, options.projectRoot);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
@@ -243,6 +243,9 @@ class AtlaspackWorker {
         } else {
           mutableAsset.setStream(output.content);
         }
+        if (output.map) {
+          mutableAsset.setMap(output.map);
+        }
       }
     }
     (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
@@ -250,19 +253,23 @@ class AtlaspackWorker {
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
-      filePath: mutableAsset.filePath,
-      type: mutableAsset.type,
       code: [],
+      filePath: mutableAsset.filePath,
+      isBundleSplittable: mutableAsset.isBundleSplittable,
+      isSource: mutableAsset.isSource,
       meta: mutableAsset.meta,
       pipeline: mutableAsset.pipeline,
       // Query should be undefined if it's empty
       query: mutableAsset.query.toString() || undefined,
-      symbols: mutableAsset.symbols.intoNapi(),
-      uniqueKey: mutableAsset.uniqueKey,
       sideEffects: mutableAsset.sideEffects,
-      isBundleSplittable: mutableAsset.isBundleSplittable,
-      isSource: mutableAsset.isSource
-    }, await mutableAsset.getBuffer()];
+      symbols: mutableAsset.symbols.intoNapi(),
+      type: mutableAsset.type,
+      uniqueKey: mutableAsset.uniqueKey
+    }, await mutableAsset.getBuffer(),
+    // Only send back the map if it has changed
+    mutableAsset.isMapDirty ?
+    // $FlowFixMe A dirty map means this will be valid
+    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
   });
 }
 exports.AtlaspackWorker = AtlaspackWorker;

package/lib/requests/AssetGraphRequestRust.js

@@ -18,24 +18,9 @@ function _diagnostic() {
   };
   return data;
 }
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
-var _constants = require("../constants");
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
-function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/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 }; }
@@ -57,7 +42,7 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       let {
         assetGraph,
         changedAssets
-      } = getAssetGraph(serializedAssetGraph, options);
+      } = getAssetGraph(serializedAssetGraph);
       let changedAssetsPropagation = new Set(changedAssets.keys());
       let errors = (0, _SymbolPropagation.propagateSymbols)({
         options,
@@ -86,7 +71,7 @@ function createAssetGraphRequestRust(rustAtlaspack) {
     input
   });
 }
-function getAssetGraph(serializedGraph, options) {
+function getAssetGraph(serializedGraph) {
   let graph = new _AssetGraph.default({
     _contentKeyToNodeId: new Map(),
     _nodeIdToContentKey: new Map(),
@@ -154,21 +139,18 @@ function getAssetGraph(serializedGraph, options) {
         deps = new Map();
         dependencyMap.set(id, deps);
       }
-      asset.dependencies = deps;
       asset.committed = true;
       asset.contentKey = id;
+      asset.dependencies = deps;
       asset.env.id = getEnvId(asset.env);
+      asset.mapKey = `map:${asset.id}`;
+
+      // We need to add this property for source map handling, as some assets like runtimes
+      // are processed after the Rust transformation and take the v2 code path
+      asset.meta.isV3 = true;
       if (asset.symbols != null) {
         asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
-      if (asset.map) {
-        let mapKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:map:${asset.id}`);
-        let sourceMap = new (_sourceMap().default)(options.projectRoot);
-        sourceMap.addVLQMap(JSON.parse(asset.map));
-        asset.mapKey = mapKey;
-        options.cache.setBlob(mapKey, sourceMap.toBuffer());
-        delete asset.map;
-      }
       cachedAssets.set(id, asset.code);
       changedAssets.set(id, asset);
       graph.addNodeByContentKey(id, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3556+d32468aff",
+  "version": "2.12.1-canary.3557+4ec090221",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/cache": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/diagnostic": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/events": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/feature-flags": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/fs": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/graph": "3.2.1-canary.3556+d32468aff",
-    "@atlaspack/logger": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/package-manager": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/plugin": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/profiler": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/rust": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/types": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/utils": "2.12.1-canary.3556+d32468aff",
-    "@atlaspack/workers": "2.12.1-canary.3556+d32468aff",
+    "@atlaspack/build-cache": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/cache": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/diagnostic": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/events": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/feature-flags": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/fs": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/graph": "3.2.1-canary.3557+4ec090221",
+    "@atlaspack/logger": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/package-manager": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/plugin": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/profiler": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/rust": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/types": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/utils": "2.12.1-canary.3557+4ec090221",
+    "@atlaspack/workers": "2.12.1-canary.3557+4ec090221",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -66,5 +66,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "d32468affac184f10d2167710022e72133ee162c"
+  "gitHead": "4ec0902215c46322d903e12467b31a8cedc0e879"
 }

package/src/CommittedAsset.js

@@ -1,15 +1,14 @@
 // @flow strict-local
 
-import type {AST, Blob} from '@atlaspack/types';
-import type {Asset, Dependency, AtlaspackOptions} from './types';
-
 import {Readable} from 'stream';
 
 import {deserializeRaw} from '@atlaspack/build-cache';
-import SourceMap from '@parcel/source-map';
+import type {AST, Blob} from '@atlaspack/types';
 import {bufferStream, blobToStream, streamFromPromise} from '@atlaspack/utils';
+import SourceMap from '@parcel/source-map';
 
 import {generateFromAST} from './assetUtils';
+import type {Asset, Dependency, AtlaspackOptions} from './types';
 
 export default class CommittedAsset {
   key: ?string;
@@ -20,7 +19,6 @@ export default class CommittedAsset {
   map: ?Promise<?SourceMap>;
   ast: ?Promise<AST>;
   code: ?string;
-  generatingPromise: ?Promise<void>;
 
   constructor(value: Asset, options: AtlaspackOptions) {
     this.value = value;
@@ -97,6 +95,26 @@ export default class CommittedAsset {
     if (mapKey != null && this.mapBuffer == null) {
       this.mapBuffer = (async () => {
         try {
+          // Handle v3 assets that were processed by the native asset graph code (i.e. not runtime
+          // or helper assets)
+          if (
+            this.options.featureFlags.atlaspackV3 &&
+            this.value.meta.isV3 === true
+          ) {
+            let buffer = await this.options.cache.getBuffer(mapKey);
+            if (!buffer) {
+              return buffer;
+            }
+
+            // We make the conversion from json to buffer here, since both js packagers lazily
+            // instantiate a sourcemap from the map buffer. This ensures we do not have to modify
+            // the packagers in any significant way. Additionally, storing the SourceMap objects
+            // upfront in these packagers appears to make larger builds more prone to failing.
+            let sourceMap = new SourceMap(this.options.projectRoot);
+            sourceMap.addVLQMap(JSON.parse(buffer.toString()));
+            return sourceMap.toBuffer();
+          }
+
           return await this.options.cache.getBlob(mapKey);
         } catch (err) {
           if (err.code === 'ENOENT' && this.value.astKey != null) {

package/src/atlaspack-v3/worker/compat/mutable-asset.js

@@ -1,6 +1,6 @@
 // @flow
 
-import type SourceMap from '@parcel/source-map';
+import SourceMap from '@parcel/source-map';
 import * as napi from '@atlaspack/rust';
 import {Readable} from 'stream';
 import type {
@@ -24,26 +24,30 @@ import {MutableAssetSymbols} from './asset-symbols';
 export type InnerAsset = napi.Asset;
 
 export class MutableAsset implements IMutableAsset {
-  fs: FileSystem;
+  bundleBehavior: ?BundleBehavior;
   env: Environment;
-  symbols: MutableAssetSymbols;
-  stats: Stats;
-  id: string;
   filePath: FilePath;
-  type: string;
-  query: URLSearchParams;
+  fs: FileSystem;
+  id: string;
+  isBundleSplittable: boolean;
+  isMapDirty: boolean;
   isSource: boolean;
   meta: Meta;
-  bundleBehavior: ?BundleBehavior;
-  isBundleSplittable: boolean;
+  pipeline: ?string;
+  query: URLSearchParams;
   sideEffects: boolean;
+  stats: Stats;
+  symbols: MutableAssetSymbols;
+  type: string;
   uniqueKey: ?string;
-  pipeline: ?string;
 
-  #inner: InnerAsset;
+  #astDirty: boolean;
   #ast: ?AST;
   #contents: Buffer;
-  #astDirty: boolean;
+  #inner: InnerAsset;
+  #map: ?string;
+  #projectRoot: string;
+  #sourceMap: ?SourceMap;
 
   get astGenerator(): ?ASTGenerator {
     throw new Error('get MutableAsset.astGenerator');
@@ -58,29 +62,30 @@ export class MutableAsset implements IMutableAsset {
     contents: Buffer,
     env: Environment,
     fs: FileSystem,
+    map: ?string,
+    projectRoot: string,
   ) {
-    this.#inner = asset;
-    this.stats = asset.stats;
-    this.id = asset.id;
+    this.bundleBehavior = bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+    this.env = env;
     this.filePath = asset.filePath;
-    this.type;
-    this.symbols = new MutableAssetSymbols(asset.symbols);
-    this.stats = asset.stats;
+    this.fs = fs;
     this.id = asset.id;
-    this.filePath = asset.filePath;
-    this.type = asset.type;
-    this.query = new URLSearchParams(asset.query);
+    this.isBundleSplittable = asset.isBundleSplittable;
     this.isSource = asset.isSource;
     this.meta = asset.meta;
-    this.bundleBehavior = bundleBehaviorMap.fromNullable(asset.bundleBehavior);
-    this.isBundleSplittable = asset.isBundleSplittable;
+    this.pipeline = asset.pipeline;
+    this.query = new URLSearchParams(asset.query);
     this.sideEffects = asset.sideEffects;
+    this.stats = asset.stats;
+    this.symbols = new MutableAssetSymbols(asset.symbols);
+    this.type = asset.type;
     this.uniqueKey = asset.uniqueKey;
-    this.pipeline = asset.pipeline;
-    this.#contents = contents;
-    this.fs = fs;
-    this.env = env;
+
     this.#astDirty = false;
+    this.#contents = contents;
+    this.#inner = asset;
+    this.#map = map;
+    this.#projectRoot = projectRoot;
   }
 
   // eslint-disable-next-line require-await
@@ -136,17 +141,27 @@ export class MutableAsset implements IMutableAsset {
   }
 
   getMap(): Promise<?SourceMap> {
-    // TODO: Provide source maps once they exist
-    return Promise.resolve(null);
+    // Only create the source map if it is requested
+    if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
+      let sourceMap = new SourceMap(this.#projectRoot);
+      // $FlowFixMe Flow is dumb
+      sourceMap.addVLQMap(JSON.parse(this.#map));
+      this.#sourceMap = sourceMap;
+    }
+
+    return Promise.resolve(this.#sourceMap);
   }
 
   // eslint-disable-next-line no-unused-vars
   setMap(sourceMap: ?SourceMap): void {
-    throw new Error('MutableAsset.setMap()');
+    this.isMapDirty = true;
+    this.#sourceMap = sourceMap;
   }
 
   getMapBuffer(): Promise<?Buffer> {
-    throw new Error('MutableAsset.getMapBuffer');
+    throw new Error(
+      'getMapBuffer() is considered an internal implementation detail, please use getMap() instead',
+    );
   }
 
   getDependencies(): $ReadOnlyArray<Dependency> {

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

@@ -159,10 +159,10 @@ export class AtlaspackWorker {
   );
 
   runTransformerTransform: JsCallable<
-    [RunTransformerTransformOptions, Buffer],
+    [RunTransformerTransformOptions, Buffer, ?string],
     Promise<RunTransformerTransformResult>,
   > = jsCallable(
-    async ({key, env: napiEnv, options, asset: innerAsset}, contents) => {
+    async ({key, env: napiEnv, options, asset: innerAsset}, contents, map) => {
       const state = this.#transformers.get(key);
       if (!state) {
         throw new Error(`Transformer not found: ${key}`);
@@ -188,6 +188,8 @@ export class AtlaspackWorker {
         contents,
         env,
         this.#fs,
+        map,
+        options.projectRoot,
       );
 
       const defaultOptions = {
@@ -250,6 +252,10 @@ export class AtlaspackWorker {
           } else {
             mutableAsset.setStream(output.content);
           }
+
+          if (output.map) {
+            mutableAsset.setMap(output.map);
+          }
         }
       }
 
@@ -269,20 +275,25 @@ export class AtlaspackWorker {
           bundleBehavior: bundleBehaviorMap.intoNullable(
             mutableAsset.bundleBehavior,
           ),
-          filePath: mutableAsset.filePath,
-          type: mutableAsset.type,
           code: [],
+          filePath: mutableAsset.filePath,
+          isBundleSplittable: mutableAsset.isBundleSplittable,
+          isSource: mutableAsset.isSource,
           meta: mutableAsset.meta,
           pipeline: mutableAsset.pipeline,
           // Query should be undefined if it's empty
           query: mutableAsset.query.toString() || undefined,
+          sideEffects: mutableAsset.sideEffects,
           symbols: mutableAsset.symbols.intoNapi(),
+          type: mutableAsset.type,
           uniqueKey: mutableAsset.uniqueKey,
-          sideEffects: mutableAsset.sideEffects,
-          isBundleSplittable: mutableAsset.isBundleSplittable,
-          isSource: mutableAsset.isSource,
         },
         await mutableAsset.getBuffer(),
+        // Only send back the map if it has changed
+        mutableAsset.isMapDirty
+          ? // $FlowFixMe A dirty map means this will be valid
+            JSON.stringify((await mutableAsset.getMap()).toVLQ())
+          : '',
       ];
     },
   );
@@ -366,4 +377,4 @@ type RunTransformerTransformOptions = {|
   asset: napi.Asset,
 |};
 
-type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer];
+type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];

package/src/requests/AssetGraphRequestRust.js

@@ -3,12 +3,10 @@
 import invariant from 'assert';
 
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
-import {hashString} from '@atlaspack/rust';
 import type {Async} from '@atlaspack/types';
 
 import AssetGraph, {nodeFromAssetGroup} from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
-import {ATLASPACK_VERSION} from '../constants';
 import {requestTypes, type StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
 import type {Environment} from '../types';
@@ -17,7 +15,6 @@ import type {
   AssetGraphRequestInput,
   AssetGraphRequestResult,
 } from './AssetGraphRequest';
-import SourceMap from '@parcel/source-map';
 
 type RunInput = {|
   input: AssetGraphRequestInput,
@@ -51,10 +48,7 @@ export function createAssetGraphRequestRust(
         });
       }
 
-      let {assetGraph, changedAssets} = getAssetGraph(
-        serializedAssetGraph,
-        options,
-      );
+      let {assetGraph, changedAssets} = getAssetGraph(serializedAssetGraph);
 
       let changedAssetsPropagation = new Set(changedAssets.keys());
       let errors = propagateSymbols({
@@ -86,7 +80,7 @@ export function createAssetGraphRequestRust(
   });
 }
 
-function getAssetGraph(serializedGraph, options) {
+function getAssetGraph(serializedGraph) {
   let graph = new AssetGraph({
     _contentKeyToNodeId: new Map(),
     _nodeIdToContentKey: new Map(),
@@ -176,23 +170,19 @@ function getAssetGraph(serializedGraph, options) {
         deps = new Map();
         dependencyMap.set(id, deps);
       }
-      asset.dependencies = deps;
 
       asset.committed = true;
       asset.contentKey = id;
+      asset.dependencies = deps;
       asset.env.id = getEnvId(asset.env);
-      if (asset.symbols != null) {
-        asset.symbols = new Map(asset.symbols.map(mapSymbols));
-      }
+      asset.mapKey = `map:${asset.id}`;
 
-      if (asset.map) {
-        let mapKey = hashString(`${ATLASPACK_VERSION}:map:${asset.id}`);
-        let sourceMap = new SourceMap(options.projectRoot);
-        sourceMap.addVLQMap(JSON.parse(asset.map));
+      // We need to add this property for source map handling, as some assets like runtimes
+      // are processed after the Rust transformation and take the v2 code path
+      asset.meta.isV3 = true;
 
-        asset.mapKey = mapKey;
-        options.cache.setBlob(mapKey, sourceMap.toBuffer());
-        delete asset.map;
+      if (asset.symbols != null) {
+        asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
 
       cachedAssets.set(id, asset.code);