@atlaspack/core 2.16.2-canary.430 → 2.16.2-canary.432

package/dist/requests/WriteBundleRequest.js

@@ -36,8 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.default = createWriteBundleRequest;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 const constants_1 = require("../constants");
 const nullthrows_1 = __importDefault(require("nullthrows"));
@@ -56,10 +58,12 @@ const profiler_1 = require("@atlaspack/profiler");
 const RequestTracker_1 = require("../RequestTracker");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const EnvironmentManager_1 = require("../EnvironmentManager");
-const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const source_map_1 = require("@atlaspack/source-map");
 const HASH_REF_PREFIX_LEN = constants_1.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
 const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -136,28 +140,14 @@ async function run({ input, options, api }) {
     await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
     const hasSourceMap = await options.cache.has(mapKey);
     if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+        const mapEntry = await options.cache.getBlob(mapKey);
         let mapStream;
         if ((0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
             bundleReplacements &&
             bundleReplacements.length > 0) {
-            const mapEntry = 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 source_map_1.default(projectRoot, mapBuffer);
-            applyReplacementsToSourceMap(sourceMap, bundleReplacements);
-            const mapJson = await sourceMap.stringify({
-                format: 'string',
-                file: name,
-                sourceRoot: computeSourceMapRoot(bundle, options),
-            });
-            mapStream = (0, utils_1.blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+            mapStream = (0, utils_1.blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
         }
         else {
-            const mapEntry = await options.cache.getBlob(mapKey);
             mapStream = (0, utils_1.blobToStream)(mapEntry);
         }
         await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
@@ -192,6 +182,167 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
         }
     }
 }
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+function applyReplacementsToVLQMappings(mappings, replacements) {
+    if (replacements.length === 0)
+        return mappings;
+    // Group replacements by line (0-indexed), sorted by column ascending.
+    const byLine = new Map();
+    for (const r of replacements) {
+        let arr = byLine.get(r.line);
+        if (!arr) {
+            arr = [];
+            byLine.set(r.line, arr);
+        }
+        arr.push(r);
+    }
+    for (const arr of byLine.values()) {
+        arr.sort((a, b) => a.column - b.column);
+    }
+    const lines = mappings.split(';');
+    const resultLines = [];
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const lineReps = byLine.get(lineIdx);
+        if (!lineReps || lineReps.length === 0) {
+            resultLines.push(lines[lineIdx]);
+            continue;
+        }
+        const line = lines[lineIdx];
+        if (!line) {
+            resultLines.push('');
+            continue;
+        }
+        // Decode segment column deltas to absolute columns.
+        const segments = line.split(',');
+        const colVlqEnds = [];
+        const absCols = [];
+        let absCol = 0;
+        for (const seg of segments) {
+            const { value: colDelta, nextPos } = (0, source_map_1.decodeVLQ)(seg, 0);
+            absCol += colDelta;
+            colVlqEnds.push(nextPos);
+            absCols.push(absCol);
+        }
+        // Apply each replacement's column shift sequentially against the
+        // current absCol values (which have already been adjusted by previous
+        // replacements on this line), mirroring the sequential offsetColumns calls.
+        for (const r of lineReps) {
+            const delta = r.newLength - r.originalLength;
+            if (delta === 0)
+                continue;
+            const threshold = r.column + r.originalLength;
+            for (let i = 0; i < absCols.length; i++) {
+                if (absCols[i] >= threshold) {
+                    absCols[i] += delta;
+                }
+            }
+        }
+        // Re-encode with updated absolute columns; only the leading column VLQ
+        // field of each segment changes – the tail bytes are sliced unchanged.
+        const resultSegments = [];
+        let prevAbsCol = 0;
+        for (let i = 0; i < segments.length; i++) {
+            const newDelta = absCols[i] - prevAbsCol;
+            prevAbsCol = absCols[i];
+            resultSegments.push((0, source_map_1.encodeVLQ)(newDelta) + segments[i].slice(colVlqEnds[i]));
+        }
+        resultLines.push(resultSegments.join(','));
+    }
+    return resultLines.join(';');
+}
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+class SourceMapHashRefRewriteStream extends stream_1.Transform {
+    constructor(replacements) {
+        super();
+        this.replacements = replacements;
+        this.state = 'scanning';
+        this.scanBuf = Buffer.alloc(0);
+        this.mappingsBufs = [];
+    }
+    // @ts-expect-error TS7006
+    _transform(chunk, _encoding, cb) {
+        if (this.state === 'passthrough') {
+            this.push(chunk);
+            cb();
+            return;
+        }
+        if (this.state === 'scanning') {
+            const combined = Buffer.concat([this.scanBuf, chunk]);
+            const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+            if (idx === -1) {
+                // Key not yet found – hold back enough bytes to handle a split key.
+                const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+                if (combined.length > keepLen) {
+                    this.push(combined.slice(0, combined.length - keepLen));
+                }
+                this.scanBuf = combined.slice(combined.length - keepLen);
+                cb();
+                return;
+            }
+            // Emit everything up to and including the key.
+            const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+            this.push(combined.slice(0, keyEnd));
+            this.scanBuf = Buffer.alloc(0);
+            this.state = 'buffering';
+            this._bufferingTransform(combined.slice(keyEnd), cb);
+            return;
+        }
+        // state === 'buffering'
+        this._bufferingTransform(chunk, cb);
+    }
+    // @ts-expect-error TS7006
+    _bufferingTransform(chunk, cb) {
+        // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+        // so scanning for the closing '"' (0x22) is safe.
+        const closeIdx = chunk.indexOf(0x22);
+        if (closeIdx === -1) {
+            this.mappingsBufs.push(chunk);
+            cb();
+            return;
+        }
+        this.mappingsBufs.push(chunk.slice(0, closeIdx));
+        // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+        const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+        const rewritten = applyReplacementsToVLQMappings(mappingsStr, this.replacements);
+        this.push(Buffer.from(rewritten, 'latin1'));
+        // Emit the closing '"' and everything remaining in one push.
+        this.push(chunk.slice(closeIdx));
+        this.state = 'passthrough';
+        this.mappingsBufs = [];
+        cb();
+    }
+    // @ts-expect-error TS7006
+    _flush(cb) {
+        if (this.state === 'scanning' && this.scanBuf.length > 0) {
+            this.push(this.scanBuf);
+        }
+        else if (this.state === 'buffering') {
+            // Malformed JSON – flush whatever we buffered as-is.
+            this.push(Buffer.concat(this.mappingsBufs));
+        }
+        cb();
+    }
+}
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 /**
  * 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

package/lib/requests/WriteBundleRequest.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 exports.default = createWriteBundleRequest;
 var _constants = require("../constants");
@@ -78,7 +80,7 @@ function _featureFlags() {
 }
 var _EnvironmentManager = require("../EnvironmentManager");
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };
@@ -90,6 +92,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 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;
+
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -179,21 +184,11 @@ async function run({
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
   const hasSourceMap = await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = await options.cache.getBlob(mapKey);
     let mapStream;
     if ((0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') && bundleReplacements && bundleReplacements.length > 0) {
-      const mapEntry = 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'));
+      mapStream = (0, _utils().blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
     } else {
-      const mapEntry = 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);
@@ -228,6 +223,178 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
   }
 }
 
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+function applyReplacementsToVLQMappings(mappings, replacements) {
+  if (replacements.length === 0) return mappings;
+
+  // Group replacements by line (0-indexed), sorted by column ascending.
+  const byLine = new Map();
+  for (const r of replacements) {
+    let arr = byLine.get(r.line);
+    if (!arr) {
+      arr = [];
+      byLine.set(r.line, arr);
+    }
+    arr.push(r);
+  }
+  for (const arr of byLine.values()) {
+    arr.sort((a, b) => a.column - b.column);
+  }
+  const lines = mappings.split(';');
+  const resultLines = [];
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const lineReps = byLine.get(lineIdx);
+    if (!lineReps || lineReps.length === 0) {
+      resultLines.push(lines[lineIdx]);
+      continue;
+    }
+    const line = lines[lineIdx];
+    if (!line) {
+      resultLines.push('');
+      continue;
+    }
+
+    // Decode segment column deltas to absolute columns.
+    const segments = line.split(',');
+    const colVlqEnds = [];
+    const absCols = [];
+    let absCol = 0;
+    for (const seg of segments) {
+      const {
+        value: colDelta,
+        nextPos
+      } = (0, _sourceMap().decodeVLQ)(seg, 0);
+      absCol += colDelta;
+      colVlqEnds.push(nextPos);
+      absCols.push(absCol);
+    }
+
+    // Apply each replacement's column shift sequentially against the
+    // current absCol values (which have already been adjusted by previous
+    // replacements on this line), mirroring the sequential offsetColumns calls.
+    for (const r of lineReps) {
+      const delta = r.newLength - r.originalLength;
+      if (delta === 0) continue;
+      const threshold = r.column + r.originalLength;
+      for (let i = 0; i < absCols.length; i++) {
+        if (absCols[i] >= threshold) {
+          absCols[i] += delta;
+        }
+      }
+    }
+
+    // Re-encode with updated absolute columns; only the leading column VLQ
+    // field of each segment changes – the tail bytes are sliced unchanged.
+    const resultSegments = [];
+    let prevAbsCol = 0;
+    for (let i = 0; i < segments.length; i++) {
+      const newDelta = absCols[i] - prevAbsCol;
+      prevAbsCol = absCols[i];
+      resultSegments.push((0, _sourceMap().encodeVLQ)(newDelta) + segments[i].slice(colVlqEnds[i]));
+    }
+    resultLines.push(resultSegments.join(','));
+  }
+  return resultLines.join(';');
+}
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+class SourceMapHashRefRewriteStream extends _stream().Transform {
+  constructor(replacements) {
+    super();
+    this.replacements = replacements;
+    this.state = 'scanning';
+    this.scanBuf = Buffer.alloc(0);
+    this.mappingsBufs = [];
+  }
+
+  // @ts-expect-error TS7006
+  _transform(chunk, _encoding, cb) {
+    if (this.state === 'passthrough') {
+      this.push(chunk);
+      cb();
+      return;
+    }
+    if (this.state === 'scanning') {
+      const combined = Buffer.concat([this.scanBuf, chunk]);
+      const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+      if (idx === -1) {
+        // Key not yet found – hold back enough bytes to handle a split key.
+        const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+        if (combined.length > keepLen) {
+          this.push(combined.slice(0, combined.length - keepLen));
+        }
+        this.scanBuf = combined.slice(combined.length - keepLen);
+        cb();
+        return;
+      }
+
+      // Emit everything up to and including the key.
+      const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+      this.push(combined.slice(0, keyEnd));
+      this.scanBuf = Buffer.alloc(0);
+      this.state = 'buffering';
+      this._bufferingTransform(combined.slice(keyEnd), cb);
+      return;
+    }
+
+    // state === 'buffering'
+    this._bufferingTransform(chunk, cb);
+  }
+
+  // @ts-expect-error TS7006
+  _bufferingTransform(chunk, cb) {
+    // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+    // so scanning for the closing '"' (0x22) is safe.
+    const closeIdx = chunk.indexOf(0x22);
+    if (closeIdx === -1) {
+      this.mappingsBufs.push(chunk);
+      cb();
+      return;
+    }
+    this.mappingsBufs.push(chunk.slice(0, closeIdx));
+
+    // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+    const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+    const rewritten = applyReplacementsToVLQMappings(mappingsStr, this.replacements);
+    this.push(Buffer.from(rewritten, 'latin1'));
+
+    // Emit the closing '"' and everything remaining in one push.
+    this.push(chunk.slice(closeIdx));
+    this.state = 'passthrough';
+    this.mappingsBufs = [];
+    cb();
+  }
+
+  // @ts-expect-error TS7006
+  _flush(cb) {
+    if (this.state === 'scanning' && this.scanBuf.length > 0) {
+      this.push(this.scanBuf);
+    } else if (this.state === 'buffering') {
+      // Malformed JSON – flush whatever we buffered as-is.
+      this.push(Buffer.concat(this.mappingsBufs));
+    }
+    cb();
+  }
+}
+
 /**
  * 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
@@ -238,6 +405,7 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
  *
  * This logic must stay in sync with PackagerRunner.generateSourceMap.
  */
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 function computeSourceMapRoot(bundle, options) {
   let name = (0, _nullthrows().default)(bundle.name);
   let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, name);

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

@@ -4,6 +4,7 @@ import type { StaticRunOpts } from '../RequestTracker';
 import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
 import type BundleGraph from '../BundleGraph';
 import type { BundleInfo } from '../PackagerRunner';
+import { Transform } from 'stream';
 import { requestTypes } from '../RequestTracker';
 import SourceMap from '@atlaspack/source-map';
 export type HashRefReplacement = {
@@ -33,6 +34,38 @@ export type WriteBundleRequest = {
  */
 export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
 export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+export declare function applyReplacementsToVLQMappings(mappings: string, replacements: HashRefReplacement[]): string;
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+export declare class SourceMapHashRefRewriteStream extends Transform {
+    private replacements;
+    private state;
+    private scanBuf;
+    private mappingsBufs;
+    constructor(replacements: HashRefReplacement[]);
+    _transform(chunk: Buffer, _encoding: string, cb: any): void;
+    private _bufferingTransform;
+    _flush(cb: any): 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.430+3465724e6",
+  "version": "2.16.2-canary.432+bddd21a53",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,22 +22,22 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.498+3465724e6",
-    "@atlaspack/cache": "3.1.1-canary.430+3465724e6",
-    "@atlaspack/diagnostic": "2.14.1-canary.498+3465724e6",
-    "@atlaspack/events": "2.14.1-canary.498+3465724e6",
-    "@atlaspack/feature-flags": "2.14.1-canary.498+3465724e6",
-    "@atlaspack/fs": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/graph": "3.4.1-canary.498+3465724e6",
-    "@atlaspack/logger": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/package-manager": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/plugin": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/profiler": "2.14.1-canary.498+3465724e6",
-    "@atlaspack/rust": "3.2.1-canary.430+3465724e6",
-    "@atlaspack/source-map": "3.2.11-canary.4209+3465724e6",
-    "@atlaspack/types": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/utils": "2.14.5-canary.430+3465724e6",
-    "@atlaspack/workers": "2.14.5-canary.430+3465724e6",
+    "@atlaspack/build-cache": "2.13.3-canary.500+bddd21a53",
+    "@atlaspack/cache": "3.1.1-canary.432+bddd21a53",
+    "@atlaspack/diagnostic": "2.14.1-canary.500+bddd21a53",
+    "@atlaspack/events": "2.14.1-canary.500+bddd21a53",
+    "@atlaspack/feature-flags": "2.14.1-canary.500+bddd21a53",
+    "@atlaspack/fs": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/graph": "3.4.1-canary.500+bddd21a53",
+    "@atlaspack/logger": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/package-manager": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/plugin": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/profiler": "2.14.1-canary.500+bddd21a53",
+    "@atlaspack/rust": "3.2.1-canary.432+bddd21a53",
+    "@atlaspack/source-map": "3.2.11-canary.4211+bddd21a53",
+    "@atlaspack/types": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/utils": "2.14.5-canary.432+bddd21a53",
+    "@atlaspack/workers": "2.14.5-canary.432+bddd21a53",
     "@mischnic/json-sourcemap": "^0.1.0",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -61,5 +61,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "3465724e6b1f7e805f9d30828417104f40a0c2ce"
+  "gitHead": "bddd21a5313974ca333c02b2da1c6f85d1afaaea"
 }