@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/lib/requests/WriteBundleRequest.js

@@ -3,6 +3,10 @@
 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");
 function _nullthrows() {
@@ -19,6 +23,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");
@@ -45,7 +56,6 @@ function _logger() {
   return data;
 }
 var _DevDepRequest = require("./DevDepRequest");
-var _AtlaspackConfig = require("../AtlaspackConfig");
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -68,11 +78,22 @@ function _featureFlags() {
   };
   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 }; }
+var _EnvironmentManager = require("../EnvironmentManager");
+function _sourceMap() {
+  const data = require("@atlaspack/source-map");
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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.
  */
@@ -86,6 +107,8 @@ function createWriteBundleRequest(input) {
     input
   };
 }
+
+// @ts-expect-error TS7031
 async function run({
   input,
   options,
@@ -121,7 +144,8 @@ async function run({
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete((0, _projectPath.toProjectPath)(options.projectRoot, fullPath + '.map'));
   }
   let dir = _path().default.dirname(fullPath);
@@ -141,24 +165,36 @@ async function run({
     contentStream = (0, _utils().blobToStream)(await options.cache.getBlob(cacheKeys.content));
   }
   let size = 0;
-  contentStream = contentStream.pipe(new (_utils().TapStream)(buf => {
+  contentStream = contentStream.pipe(
+  // @ts-expect-error TS2554
+  new (_utils().TapStream)(buf => {
     size += buf.length;
   }));
-  let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let configResult = (0, _nullthrows().default)(
+  // @ts-expect-error TS2347
+  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
   let {
     devDeps,
     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 hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
-  if (mapKey && bundle.env.sourceMap && !bundle.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);
+  const bundleReplacements = (0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') ? [] : undefined;
+  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) {
+      mapStream = (0, _utils().blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
+    } else {
+      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,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,
@@ -168,17 +204,255 @@ async function run({
   api.storeResult(res);
   return res;
 }
-async function writeFiles(inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+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);
+      }
+    }
+  }
+}
+
+/**
+ * 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
+ * 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.
+ */
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
+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, 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(runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
+    promises.push(
+    // @ts-expect-error TS2345
+    runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
   }
   await Promise.all(promises);
 }
-async function runCompressor(compressor, stream, options, outputFS, filePath, writeOptions, devDeps, api) {
+async function runCompressor(compressor,
+// @ts-expect-error TS2503
+stream, options, outputFS, filePath, writeOptions, devDeps, api) {
   let measurement;
   try {
     measurement = _profiler().tracer.createMeasurement(compressor.name, 'compress', _path().default.relative(options.projectRoot, filePath));
@@ -195,7 +469,9 @@ async function runCompressor(compressor, stream, options, outputFS, filePath, wr
     });
     if (res != null) {
       await new Promise((resolve, reject) => (0, _stream().pipeline)(res.stream, outputFS.createWriteStream(filePath + (res.type != null ? '.' + res.type : ''), writeOptions), err => {
-        if (err) reject(err);else resolve();
+        if (err) reject(err);
+        // @ts-expect-error TS2794
+        else resolve();
       }));
     }
   } catch (err) {
@@ -214,9 +490,25 @@ async function runCompressor(compressor, stream, options, outputFS, filePath, wr
     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)]);
@@ -234,15 +526,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) {
@@ -250,12 +556,15 @@ function replaceStream(hashRefToNameHash) {
     }
   });
 }
+
+// @ts-expect-error TS2503
 function cloneStream(readable) {
   let res = new (_stream().Readable)();
-  // $FlowFixMe
   res._read = () => {};
+  // @ts-expect-error TS7006
   readable.on('data', chunk => res.push(chunk));
   readable.on('end', () => res.push(null));
+  // @ts-expect-error TS7006
   readable.on('error', err => res.emit('error', err));
   return res;
 }

package/lib/requests/WriteBundlesRequest.js

@@ -12,6 +12,8 @@ function _featureFlags() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+var _types = require("../types");
+var _ReporterRunner = require("../ReporterRunner");
 var _constants = require("../constants");
 var _projectPath = require("../projectPath");
 function _nullthrows() {
@@ -30,7 +32,33 @@ function _rust() {
 }
 var _PackageRequest = require("./PackageRequest");
 var _WriteBundleRequest = _interopRequireDefault(require("./WriteBundleRequest"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** 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;
+  }
+  (0, _ReporterRunner.report)({
+    type: 'buildProgress',
+    phase: 'packagingAndOptimizing',
+    totalBundles,
+    completeBundles
+  });
+}
+
 /**
  * Packages, optimizes, and writes all bundles to the dist directory.
  */
@@ -67,15 +95,16 @@ async function run({
   const allBundles = bundleGraph.getBundles({
     includeInline: (0, _featureFlags().getFeatureFlag)('inlineBundlesSourceMapFixes')
   });
-  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== 'inline').filter(bundle => {
+  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated).filter(bundle => {
     // 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,
         type: bundle.type,
         // FIXME: this is wrong if the packager changes the type...
         stats: {
@@ -87,11 +116,14 @@ async function run({
     }
     return true;
   });
+  let cachedBundles = new Set(bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
 
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
-  let useMainThread = bundles.length === 1 || bundles.filter(b => !api.canSkipSubrequest(bundleGraph.getHash(b))).length === 1;
+  let useMainThread = bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
   try {
+    let completeBundles = cachedBundles.size;
+    reportPackagingProgress(completeBundles, bundles.length);
     await Promise.all(bundles.map(async bundle => {
       let request = (0, _PackageRequest.createPackageRequest)({
         bundle,
@@ -101,6 +133,10 @@ async function run({
         useMainThread
       });
       let info = await api.runRequest(request);
+      if (!cachedBundles.has(bundle)) {
+        completeBundles++;
+        reportPackagingProgress(completeBundles, bundles.length);
+      }
       if (!useMainThread) {
         // Force a refresh of the cache to avoid a race condition
         // between threaded reads and writes that can result in an LMDB cache miss:
@@ -114,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,
@@ -137,8 +173,26 @@ async function run({
       }));
       return promise.then(r => res.set(bundle.id, r));
     }));
-    api.storeResult(res);
-    return res;
+    let result = {
+      bundleInfo: res
+    };
+    if (_utils().debugTools['scope-hoisting-stats']) {
+      // Aggregate scope hoisting stats from all bundles
+      let aggregatedScopeHoistingStats = {
+        totalAssets: 0,
+        wrappedAssets: 0
+      };
+      for (let bundle of bundles) {
+        let bundleInfo = bundleInfoMap[bundle.id];
+        if (bundleInfo !== null && bundleInfo !== void 0 && bundleInfo.scopeHoistingStats) {
+          aggregatedScopeHoistingStats.totalAssets += bundleInfo.scopeHoistingStats.totalAssets;
+          aggregatedScopeHoistingStats.wrappedAssets += bundleInfo.scopeHoistingStats.wrappedAssets;
+        }
+      }
+      result.scopeHoistingStats = aggregatedScopeHoistingStats;
+    }
+    api.storeResult(result);
+    return result;
   } finally {
     await dispose();
   }
@@ -148,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/requests/asset-graph-diff.js

@@ -14,11 +14,11 @@ function _jestDiff() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 var _projectPath = require("../projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/* eslint-disable no-console */ // $FlowFixMe
-// $FlowFixMe
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable no-console */
+// @ts-expect-error missing types
+
 function filterNode(node) {
   let clone = (0, _default().default)(node);
 
@@ -43,6 +43,8 @@ function filterNode(node) {
   delete clone.value.dependencies;
   return clone;
 }
+
+// @ts-expect-error missing return type
 function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
   if (obj instanceof Map) {
     const copy = {};
@@ -53,6 +55,7 @@ function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
     });
     return copy;
   } else if (Array.isArray(obj)) {
+    // @ts-expect-error implicit any
     return obj.map(v => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
   } else if (typeof obj === 'object') {
     const copy = {};
@@ -74,17 +77,19 @@ function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
     return obj;
   }
 }
-function assetGraphDiff(jsAssetGraph, rustAssetGraph) {
+function assetGraphDiff(jsAssetGraph, rustAssetGraph, projectRoot) {
   const getNodes = graph => {
     let nodes = {};
+
+    // @ts-expect-error implicit any
     graph.traverse(nodeId => {
       let node = graph.getNode(nodeId) ?? null;
       if (!node) return;
       if (node.type === 'dependency') {
-        let sourcePath = node.value.sourcePath ?? (0, _projectPath.toProjectPath)('', 'entry');
-        nodes[`dep:${(0, _projectPath.fromProjectPathRelative)(sourcePath)}:${node.value.specifier}`] = filterNode(node);
+        let sourcePath = node.value.sourcePath ? (0, _projectPath.toProjectPath)(projectRoot, node.value.sourcePath) : (0, _projectPath.toProjectPath)(projectRoot, 'entry');
+        nodes[`dep:${sourcePath}:${node.value.specifier}`] = filterNode(node);
       } else if (node.type === 'asset') {
-        nodes[`asset:${(0, _projectPath.fromProjectPathRelative)(node.value.filePath)}`] = filterNode(node);
+        nodes[`asset:${(0, _projectPath.toProjectPath)(projectRoot, node.value.filePath)}`] = filterNode(node);
       }
     });
     return nodes;