@atlaspack/core 2.16.2-canary.410 → 2.16.2-canary.412

package/dist/PackagerRunner.js

@@ -44,7 +44,6 @@ const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
 const stream_1 = require("stream");
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const path_1 = __importDefault(require("path"));
-const url_1 = __importDefault(require("url"));
 const rust_1 = require("@atlaspack/rust");
 const Bundle_1 = require("./public/Bundle");
 const BundleGraph_1 = __importStar(require("./public/BundleGraph"));
@@ -58,6 +57,7 @@ const DevDepRequest_1 = require("./requests/DevDepRequest");
 const assetUtils_1 = require("./assetUtils");
 const utils_2 = require("./utils");
 const DevDepRequest_2 = require("./requests/DevDepRequest");
+const WriteBundleRequest_1 = require("./requests/WriteBundleRequest");
 const profiler_1 = require("@atlaspack/profiler");
 const EnvironmentManager_1 = require("./EnvironmentManager");
 const feature_flags_1 = require("@atlaspack/feature-flags");
@@ -330,48 +330,18 @@ class PackagerRunner {
         return optimized;
     }
     async generateSourceMap(bundle, map) {
-        // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+        let sourceRoot = (0, WriteBundleRequest_1.computeSourceMapRoot)(bundle, this.options);
+        let inlineSources = sourceRoot === undefined;
         let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, (0, nullthrows_1.default)(bundle.name));
         let fullPath = (0, projectPath_1.fromProjectPath)(this.options.projectRoot, filePath);
-        let sourceRoot = path_1.default.relative(path_1.default.dirname(fullPath), this.options.projectRoot);
-        let inlineSources = false;
-        const bundleEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
-        if (bundle.target) {
-            const bundleTargetEnv = (0, EnvironmentManager_1.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';
+        const bundleEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
         let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
-        if ((0, feature_flags_1.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_1.default.basename(mapFilename),
             fs: this.options.inputFS,
             rootDir: this.options.projectRoot,
-            sourceRoot: !inlineSources
-                ? url_1.default.format(url_1.default.parse(sourceRoot + '/'))
-                : undefined,
+            sourceRoot,
             inlineSources,
             format: isInlineMap ? 'inline' : 'string',
         });

package/dist/requests/WriteBundleRequest.js

@@ -37,9 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createWriteBundleRequest;
+exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.computeSourceMapRoot = computeSourceMapRoot;
 const constants_1 = require("../constants");
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
 const Bundle_1 = require("../public/Bundle");
 const utils_1 = require("@atlaspack/utils");
 const stream_1 = require("stream");
@@ -53,8 +56,10 @@ 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 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;
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -125,15 +130,43 @@ async function run({ input, options, api }) {
     let config = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, options);
     let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
     (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, options, config);
-    await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
+    const bundleReplacements = (0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs')
+        ? []
+        : undefined;
+    await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
     const hasSourceMap = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
         ? await options.cache.hasLargeBlob(mapKey)
         : await options.cache.has(mapKey);
     if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
-        const mapEntry = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-            ? await options.cache.getLargeBlob(mapKey)
-            : await options.cache.getBlob(mapKey);
-        await writeFiles((0, utils_1.blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+        let mapStream;
+        if ((0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
+            bundleReplacements &&
+            bundleReplacements.length > 0) {
+            const mapEntry = (0, feature_flags_1.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 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'));
+        }
+        else {
+            const mapEntry = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+                ? await options.cache.getLargeBlob(mapKey)
+                : 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);
     }
     let res = {
         filePath,
@@ -147,13 +180,75 @@ async function run({ input, options, api }) {
     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_1.default)(bundle.name);
+    let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name);
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    let sourceRoot = path_1.default.relative(path_1.default.dirname(fullPath), options.projectRoot);
+    let inlineSources = false;
+    const bundleEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
+    if (bundle.target) {
+        const bundleTargetEnv = (0, EnvironmentManager_1.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, feature_flags_1.getFeatureFlag)('omitSourcesContentInMemory') && !isInlineMap) {
+        if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+            inlineSources = true;
+        }
+    }
+    if (inlineSources) {
+        return undefined;
+    }
+    return url_1.default.format(url_1.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_1.fromProjectPathRelative)(filePath));
     let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
     let stream = info.hashReferences.length
-        ? inputStream.pipe(replaceStream(hashRefToNameHash))
+        ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements))
         : inputStream;
     let promises = [];
     for (let compressor of compressors) {
@@ -202,9 +297,23 @@ stream, options, outputFS, filePath, writeOptions, devDeps, api) {
         await (0, DevDepRequest_1.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_1.Transform({
         transform(chunk, encoding, cb) {
             let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
@@ -225,15 +334,29 @@ function replaceStream(hashRefToNameHash) {
                         .subarray(matchI, matchI + HASH_REF_PREFIX_LEN + constants_1.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_1.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/dist/requests/WriteBundlesRequest.js

@@ -15,6 +15,14 @@ const rust_1 = require("@atlaspack/rust");
 const PackageRequest_1 = require("./PackageRequest");
 const WriteBundleRequest_1 = __importDefault(require("./WriteBundleRequest"));
 const utils_1 = require("@atlaspack/utils");
+/** 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, feature_flags_1.getFeatureFlag)('cliProgressReportingImprovements')) {
         return;
@@ -57,9 +65,9 @@ async function run({ input, api, farm, options, }) {
         // 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_1.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_1.default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, nameHash);
             res.set(bundle.id, {
                 filePath: (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name),
                 bundleId: bundle.id,
@@ -106,9 +114,7 @@ async function run({ input, api, farm, options, }) {
             }
             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_1.default)({
                     bundle,
                     info,
@@ -162,11 +168,11 @@ function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, opti
         if (hashRefToNameHash.get(bundle.hashReference) != null) {
             continue;
         }
-        hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash
+        hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash
             ? (0, rust_1.hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
                 .map((bundleId) => bundleInfoMap[bundleId].hash)
-                .join(':')).slice(-8)
-            : bundle.id.slice(-8));
+                .join(':'))
+            : bundle.id));
     }
 }
 function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {

package/lib/PackagerRunner.js

@@ -60,13 +60,6 @@ function _path() {
   };
   return data;
 }
-function _url() {
-  const data = _interopRequireDefault(require("url"));
-  _url = function () {
-    return data;
-  };
-  return data;
-}
 function _rust() {
   const data = require("@atlaspack/rust");
   _rust = function () {
@@ -85,6 +78,7 @@ var _ConfigRequest = require("./requests/ConfigRequest");
 var _DevDepRequest = require("./requests/DevDepRequest");
 var _assetUtils = require("./assetUtils");
 var _utils2 = require("./utils");
+var _WriteBundleRequest = require("./requests/WriteBundleRequest");
 function _profiler() {
   const data = require("@atlaspack/profiler");
   _profiler = function () {
@@ -407,42 +401,18 @@ class PackagerRunner {
     return optimized;
   }
   async generateSourceMap(bundle, map) {
-    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+    let sourceRoot = (0, _WriteBundleRequest.computeSourceMapRoot)(bundle, this.options);
+    let inlineSources = sourceRoot === undefined;
     let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, (0, _nullthrows().default)(bundle.name));
     let fullPath = (0, _projectPath.fromProjectPath)(this.options.projectRoot, filePath);
-    let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), this.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 (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';
+    const bundleEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
     let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
-    if ((0, _featureFlags().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().default.basename(mapFilename),
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,
-      sourceRoot: !inlineSources ? _url().default.format(_url().default.parse(sourceRoot + '/')) : undefined,
+      sourceRoot,
       inlineSources,
       format: isInlineMap ? 'inline' : 'string'
     });

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()) {