@sentry/bundler-plugin-core 4.1.1 → 4.3.0

package/dist/cjs/index.js

@@ -8102,7 +8102,7 @@ function normalizeUserOptions(userOptions) {
  * @returns `true` if the options are valid, `false` otherwise
  */
 function validateOptions(options, logger) {
-  var _options$release, _options$release2, _options$release3;
+  var _options$release, _options$release2;
   var setCommits = (_options$release = options.release) === null || _options$release === void 0 ? void 0 : _options$release.setCommits;
   if (setCommits) {
     if (!setCommits.auto && !(setCommits.repo && setCommits.commit)) {
@@ -8113,7 +8113,7 @@ function validateOptions(options, logger) {
       logger.warn("The `setCommits` options includes `auto` but also `repo` and `commit`.", "Ignoring `repo` and `commit`.", "Please only set either `auto` or both, `repo` and `commit`.");
     }
   }
-  if ((_options$release2 = options.release) !== null && _options$release2 !== void 0 && _options$release2.deploy && !((_options$release3 = options.release) !== null && _options$release3 !== void 0 && _options$release3.deploy.env)) {
+  if ((_options$release2 = options.release) !== null && _options$release2 !== void 0 && _options$release2.deploy && _typeof(options.release.deploy) === "object" && !options.release.deploy.env) {
     logger.error("The `deploy` option was specified but is missing the required `env` property.", "Please set the `env` property.");
     return false;
   }
@@ -8307,7 +8307,7 @@ function createSentryInstance(options, shouldSendTelemetry, buildTool) {
     dsn: "https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737",
     tracesSampleRate: 1,
     sampleRate: 1,
-    release: "4.1.1",
+    release: "4.3.0",
     integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: stackParser,
@@ -8752,7 +8752,7 @@ function createCliInstance(options) {
     silent: options.silent,
     url: options.url,
     vcsRemote: options.release.vcsRemote,
-    headers: _objectSpread2({}, getTraceData())
+    headers: _objectSpread2(_objectSpread2({}, getTraceData()), options.headers)
   });
 }
 
@@ -8910,7 +8910,7 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
   });
 
   // Set the User-Agent that Sentry CLI will use when interacting with Sentry
-  process.env["SENTRY_PIPELINE"] = "".concat(bundlerPluginMetaContext.buildTool, "-plugin/", "4.1.1");
+  process.env["SENTRY_PIPELINE"] = "".concat(bundlerPluginMetaContext.buildTool, "-plugin/", "4.3.0");
 
   // Not a bulletproof check but should be good enough to at least sometimes determine
   // if the plugin is called in dev/watch mode or for a  prod build. The important part
@@ -9302,77 +9302,116 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
       }))();
     },
     /**
-     * Uploads sourcemaps using the "Debug ID" method. This function takes a list of build artifact paths that will be uploaded
+     * Uploads sourcemaps using the "Debug ID" method.
+     *
+     * By default, this prepares bundles in a temporary folder before uploading. You can opt into an
+     * in-place, direct upload path by setting `prepareArtifacts` to `false`. If `prepareArtifacts` is set to
+     * `false`, no preparation (e.g. adding `//# debugId=...` and writing adjusted source maps) is performed and no temp folder is used.
+     *
+     * @param buildArtifactPaths - The paths of the build artifacts to upload
+     * @param opts - Optional flags to control temp folder usage and preparation
      */
-    uploadSourcemaps: function uploadSourcemaps(buildArtifactPaths) {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
-        return _regeneratorRuntime().wrap(function _callee18$(_context18) {
-          while (1) switch (_context18.prev = _context18.next) {
+    uploadSourcemaps: function uploadSourcemaps(buildArtifactPaths, opts) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
+        var _options$sourcemaps;
+        var assets;
+        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
             case 0:
               if (canUploadSourceMaps(options, logger, isDevMode)) {
-                _context18.next = 2;
+                _context19.next = 2;
                 break;
               }
-              return _context18.abrupt("return");
+              return _context19.abrupt("return");
             case 2:
-              _context18.next = 4;
+              // Early exit if assets is explicitly set to an empty array
+              assets = (_options$sourcemaps = options.sourcemaps) === null || _options$sourcemaps === void 0 ? void 0 : _options$sourcemaps.assets;
+              if (!(Array.isArray(assets) && assets.length === 0)) {
+                _context19.next = 6;
+                break;
+              }
+              logger.debug("Empty `sourcemaps.assets` option provided. Will not upload sourcemaps with debug ID.");
+              return _context19.abrupt("return");
+            case 6:
+              _context19.next = 8;
               return startSpan(
               // This is `forceTransaction`ed because this span is used in dashboards in the form of indexed transactions.
               {
                 name: "debug-id-sourcemap-upload",
                 scope: sentryScope,
                 forceTransaction: true
-              }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
-                var folderToCleanUp, freeUploadDependencyOnBuildArtifacts, _options$sourcemaps, tmpUploadFolder, assets, globAssets, globResult, debugIdChunkFilePaths, numUploadedFiles, _process$env2;
-                return _regeneratorRuntime().wrap(function _callee17$(_context17) {
-                  while (1) switch (_context17.prev = _context17.next) {
+              }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
+                var _opts$prepareArtifact;
+                var shouldPrepare, folderToCleanUp, freeUploadDependencyOnBuildArtifacts, _options$sourcemaps2, _options$sourcemaps3, _options$sourcemaps4, _options$sourcemaps5, pathsToUpload, ignorePaths, globAssets, globResult, debugIdChunkFilePaths, tmpUploadFolder, _process$env2;
+                return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+                  while (1) switch (_context18.prev = _context18.next) {
                     case 0:
+                      // If we're not using a temp folder, we must not prepare artifacts in-place (to avoid mutating user files)
+                      shouldPrepare = (_opts$prepareArtifact = opts === null || opts === void 0 ? void 0 : opts.prepareArtifacts) !== null && _opts$prepareArtifact !== void 0 ? _opts$prepareArtifact : true;
                       // It is possible that this writeBundle hook (which calls this function) is called multiple times in one build (for example when reusing the plugin, or when using build tooling like `@vitejs/plugin-legacy`)
                       // Therefore we need to actually register the execution of this hook as dependency on the sourcemap files.
                       freeUploadDependencyOnBuildArtifacts = createDependencyOnBuildArtifacts();
-                      _context17.prev = 1;
-                      _context17.next = 4;
+                      _context18.prev = 2;
+                      if (shouldPrepare) {
+                        _context18.next = 11;
+                        break;
+                      }
+                      // Direct CLI upload from existing artifact paths (no globbing, no preparation)
+
+                      if (assets) {
+                        pathsToUpload = Array.isArray(assets) ? assets : [assets];
+                        logger.debug("Direct upload mode: passing user-provided assets directly to CLI: ".concat(pathsToUpload.join(", ")));
+                      } else {
+                        // Use original paths e.g. like ['.next/server'] directly –> preferred way when no globbing is done
+                        pathsToUpload = buildArtifactPaths;
+                      }
+                      ignorePaths = (_options$sourcemaps2 = options.sourcemaps) !== null && _options$sourcemaps2 !== void 0 && _options$sourcemaps2.ignore ? Array.isArray((_options$sourcemaps3 = options.sourcemaps) === null || _options$sourcemaps3 === void 0 ? void 0 : _options$sourcemaps3.ignore) ? (_options$sourcemaps4 = options.sourcemaps) === null || _options$sourcemaps4 === void 0 ? void 0 : _options$sourcemaps4.ignore : [(_options$sourcemaps5 = options.sourcemaps) === null || _options$sourcemaps5 === void 0 ? void 0 : _options$sourcemaps5.ignore] : [];
+                      _context18.next = 8;
                       return startSpan({
-                        name: "mkdtemp",
+                        name: "upload",
                         scope: sentryScope
                       }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
-                        var _process$env;
+                        var _options$release$name;
+                        var cliInstance;
                         return _regeneratorRuntime().wrap(function _callee10$(_context10) {
                           while (1) switch (_context10.prev = _context10.next) {
                             case 0:
-                              _context10.t0 = (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env["SENTRY_TEST_OVERRIDE_TEMP_DIR"];
-                              if (_context10.t0) {
-                                _context10.next = 5;
-                                break;
-                              }
-                              _context10.next = 4;
-                              return fs__namespace.promises.mkdtemp(path__namespace.join(os__namespace.tmpdir(), "sentry-bundler-plugin-upload-"));
-                            case 4:
-                              _context10.t0 = _context10.sent;
-                            case 5:
-                              return _context10.abrupt("return", _context10.t0);
-                            case 6:
+                              cliInstance = createCliInstance(options);
+                              _context10.next = 3;
+                              return cliInstance.releases.uploadSourceMaps((_options$release$name = options.release.name) !== null && _options$release$name !== void 0 ? _options$release$name : "undefined", {
+                                include: [{
+                                  paths: pathsToUpload,
+                                  rewrite: true,
+                                  dist: options.release.dist
+                                }],
+                                ignore: ignorePaths,
+                                live: "rejectOnError"
+                              });
+                            case 3:
                             case "end":
                               return _context10.stop();
                           }
                         }, _callee10);
                       })));
-                    case 4:
-                      tmpUploadFolder = _context17.sent;
-                      folderToCleanUp = tmpUploadFolder;
-                      assets = (_options$sourcemaps = options.sourcemaps) === null || _options$sourcemaps === void 0 ? void 0 : _options$sourcemaps.assets;
+                    case 8:
+                      logger.info("Successfully uploaded source maps to Sentry");
+                      _context18.next = 28;
+                      break;
+                    case 11:
+                      // Prepare artifacts in temp folder before uploading
+
                       if (assets) {
                         globAssets = assets;
                       } else {
                         logger.debug("No `sourcemaps.assets` option provided, falling back to uploading detected build artifacts.");
                         globAssets = buildArtifactPaths;
                       }
-                      _context17.next = 10;
+                      _context18.next = 14;
                       return startSpan({
                         name: "glob",
                         scope: sentryScope
                       }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
-                        var _options$sourcemaps2;
+                        var _options$sourcemaps6;
                         return _regeneratorRuntime().wrap(function _callee11$(_context11) {
                           while (1) switch (_context11.prev = _context11.next) {
                             case 0:
@@ -9380,7 +9419,8 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                               return glob.glob(globAssets, {
                                 absolute: true,
                                 nodir: true,
-                                ignore: (_options$sourcemaps2 = options.sourcemaps) === null || _options$sourcemaps2 === void 0 ? void 0 : _options$sourcemaps2.ignore
+                                // We need individual files for preparation
+                                ignore: (_options$sourcemaps6 = options.sourcemaps) === null || _options$sourcemaps6 === void 0 ? void 0 : _options$sourcemaps6.ignore
                               });
                             case 2:
                               return _context11.abrupt("return", _context11.sent);
@@ -9390,241 +9430,255 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                           }
                         }, _callee11);
                       })));
-                    case 10:
-                      globResult = _context17.sent;
+                    case 14:
+                      globResult = _context18.sent;
                       debugIdChunkFilePaths = globResult.filter(function (debugIdChunkFilePath) {
                         return !!stripQueryAndHashFromPath(debugIdChunkFilePath).match(/\.(js|mjs|cjs)$/);
                       }); // The order of the files output by glob() is not deterministic
                       // Ensure order within the files so that {debug-id}-{chunkIndex} coupling is consistent
                       debugIdChunkFilePaths.sort();
-                      if (!(Array.isArray(assets) && assets.length === 0)) {
-                        _context17.next = 17;
-                        break;
-                      }
-                      logger.debug("Empty `sourcemaps.assets` option provided. Will not upload sourcemaps with debug ID.");
-                      _context17.next = 25;
-                      break;
-                    case 17:
                       if (!(debugIdChunkFilePaths.length === 0)) {
-                        _context17.next = 21;
+                        _context18.next = 21;
                         break;
                       }
                       logger.warn("Didn't find any matching sources for debug ID upload. Please check the `sourcemaps.assets` option.");
-                      _context17.next = 25;
+                      _context18.next = 28;
                       break;
                     case 21:
-                      _context17.next = 23;
+                      _context18.next = 23;
+                      return startSpan({
+                        name: "mkdtemp",
+                        scope: sentryScope
+                      }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                        var _process$env;
+                        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                          while (1) switch (_context12.prev = _context12.next) {
+                            case 0:
+                              _context12.t0 = (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env["SENTRY_TEST_OVERRIDE_TEMP_DIR"];
+                              if (_context12.t0) {
+                                _context12.next = 5;
+                                break;
+                              }
+                              _context12.next = 4;
+                              return fs__namespace.promises.mkdtemp(path__namespace.join(os__namespace.tmpdir(), "sentry-bundler-plugin-upload-"));
+                            case 4:
+                              _context12.t0 = _context12.sent;
+                            case 5:
+                              return _context12.abrupt("return", _context12.t0);
+                            case 6:
+                            case "end":
+                              return _context12.stop();
+                          }
+                        }, _callee12);
+                      })));
+                    case 23:
+                      tmpUploadFolder = _context18.sent;
+                      folderToCleanUp = tmpUploadFolder;
+
+                      // Prepare into temp folder, then upload
+                      _context18.next = 27;
                       return startSpan({
                         name: "prepare-bundles",
                         scope: sentryScope
                       }, /*#__PURE__*/function () {
-                        var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(prepBundlesSpan) {
+                        var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(prepBundlesSpan) {
                           var preparationTasks, workers, worker, workerIndex, files, stats, uploadSize;
-                          return _regeneratorRuntime().wrap(function _callee15$(_context15) {
-                            while (1) switch (_context15.prev = _context15.next) {
+                          return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+                            while (1) switch (_context16.prev = _context16.next) {
                               case 0:
                                 // Preparing the bundles can be a lot of work and doing it all at once has the potential of nuking the heap so
                                 // instead we do it with a maximum of 16 concurrent workers
                                 preparationTasks = debugIdChunkFilePaths.map(function (chunkFilePath, chunkIndex) {
-                                  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
-                                    var _options$sourcemaps$r, _options$sourcemaps3, _options$sourcemaps4;
-                                    return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-                                      while (1) switch (_context12.prev = _context12.next) {
+                                  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
+                                    var _options$sourcemaps$r, _options$sourcemaps7, _options$sourcemaps8;
+                                    return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+                                      while (1) switch (_context13.prev = _context13.next) {
                                         case 0:
-                                          _context12.next = 2;
-                                          return prepareBundleForDebugIdUpload(chunkFilePath, tmpUploadFolder, chunkIndex, logger, (_options$sourcemaps$r = (_options$sourcemaps3 = options.sourcemaps) === null || _options$sourcemaps3 === void 0 ? void 0 : _options$sourcemaps3.rewriteSources) !== null && _options$sourcemaps$r !== void 0 ? _options$sourcemaps$r : defaultRewriteSourcesHook, (_options$sourcemaps4 = options.sourcemaps) === null || _options$sourcemaps4 === void 0 ? void 0 : _options$sourcemaps4.resolveSourceMap);
+                                          _context13.next = 2;
+                                          return prepareBundleForDebugIdUpload(chunkFilePath, tmpUploadFolder, chunkIndex, logger, (_options$sourcemaps$r = (_options$sourcemaps7 = options.sourcemaps) === null || _options$sourcemaps7 === void 0 ? void 0 : _options$sourcemaps7.rewriteSources) !== null && _options$sourcemaps$r !== void 0 ? _options$sourcemaps$r : defaultRewriteSourcesHook, (_options$sourcemaps8 = options.sourcemaps) === null || _options$sourcemaps8 === void 0 ? void 0 : _options$sourcemaps8.resolveSourceMap);
                                         case 2:
                                         case "end":
-                                          return _context12.stop();
+                                          return _context13.stop();
                                       }
-                                    }, _callee12);
+                                    }, _callee13);
                                   }));
                                 });
                                 workers = [];
                                 worker = /*#__PURE__*/function () {
-                                  var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
+                                  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
                                     var task;
-                                    return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-                                      while (1) switch (_context13.prev = _context13.next) {
+                                    return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+                                      while (1) switch (_context14.prev = _context14.next) {
                                         case 0:
                                           if (!(preparationTasks.length > 0)) {
-                                            _context13.next = 7;
+                                            _context14.next = 7;
                                             break;
                                           }
                                           task = preparationTasks.shift();
                                           if (!task) {
-                                            _context13.next = 5;
+                                            _context14.next = 5;
                                             break;
                                           }
-                                          _context13.next = 5;
+                                          _context14.next = 5;
                                           return task();
                                         case 5:
-                                          _context13.next = 0;
+                                          _context14.next = 0;
                                           break;
                                         case 7:
                                         case "end":
-                                          return _context13.stop();
+                                          return _context14.stop();
                                       }
-                                    }, _callee13);
+                                    }, _callee14);
                                   }));
                                   return function worker() {
-                                    return _ref7.apply(this, arguments);
+                                    return _ref8.apply(this, arguments);
                                   };
                                 }();
                                 for (workerIndex = 0; workerIndex < 16; workerIndex++) {
                                   workers.push(worker());
                                 }
-                                _context15.next = 6;
+                                _context16.next = 6;
                                 return Promise.all(workers);
                               case 6:
-                                _context15.next = 8;
+                                _context16.next = 8;
                                 return fs__namespace.promises.readdir(tmpUploadFolder);
                               case 8:
-                                files = _context15.sent;
+                                files = _context16.sent;
                                 stats = files.map(function (file) {
                                   return fs__namespace.promises.stat(path__namespace.join(tmpUploadFolder, file));
                                 });
-                                _context15.next = 12;
+                                _context16.next = 12;
                                 return Promise.all(stats);
                               case 12:
-                                uploadSize = _context15.sent.reduce(function (accumulator, _ref8) {
-                                  var size = _ref8.size;
+                                uploadSize = _context16.sent.reduce(function (accumulator, _ref9) {
+                                  var size = _ref9.size;
                                   return accumulator + size;
                                 }, 0);
                                 setMeasurement("files", files.length, "none", prepBundlesSpan);
                                 setMeasurement("upload_size", uploadSize, "byte", prepBundlesSpan);
-                                _context15.next = 17;
+                                _context16.next = 17;
                                 return startSpan({
                                   name: "upload",
                                   scope: sentryScope
-                                }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
-                                  var _options$release$name;
+                                }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
+                                  var _options$release$name2;
                                   var cliInstance;
-                                  return _regeneratorRuntime().wrap(function _callee14$(_context14) {
-                                    while (1) switch (_context14.prev = _context14.next) {
+                                  return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+                                    while (1) switch (_context15.prev = _context15.next) {
                                       case 0:
                                         cliInstance = createCliInstance(options);
-                                        _context14.next = 3;
-                                        return cliInstance.releases.uploadSourceMaps((_options$release$name = options.release.name) !== null && _options$release$name !== void 0 ? _options$release$name : "undefined",
-                                        // unfortunately this needs a value for now but it will not matter since debug IDs overpower releases anyhow
-                                        {
+                                        _context15.next = 3;
+                                        return cliInstance.releases.uploadSourceMaps((_options$release$name2 = options.release.name) !== null && _options$release$name2 !== void 0 ? _options$release$name2 : "undefined", {
                                           include: [{
                                             paths: [tmpUploadFolder],
                                             rewrite: false,
                                             dist: options.release.dist
                                           }],
-                                          // We want this promise to throw if the sourcemaps fail to upload so that we know about it.
-                                          // see: https://github.com/getsentry/sentry-cli/pull/2605
                                           live: "rejectOnError"
                                         });
                                       case 3:
                                       case "end":
-                                        return _context14.stop();
+                                        return _context15.stop();
                                     }
-                                  }, _callee14);
+                                  }, _callee15);
                                 })));
                               case 17:
-                                return _context15.abrupt("return", files.length);
-                              case 18:
                               case "end":
-                                return _context15.stop();
+                                return _context16.stop();
                             }
-                          }, _callee15);
+                          }, _callee16);
                         }));
                         return function (_x) {
-                          return _ref5.apply(this, arguments);
+                          return _ref6.apply(this, arguments);
                         };
                       }());
-                    case 23:
-                      numUploadedFiles = _context17.sent;
-                      if (numUploadedFiles > 0) {
-                        logger.info("Successfully uploaded source maps to Sentry");
-                      }
-                    case 25:
-                      _context17.next = 31;
-                      break;
                     case 27:
-                      _context17.prev = 27;
-                      _context17.t0 = _context17["catch"](1);
+                      logger.info("Successfully uploaded source maps to Sentry");
+                    case 28:
+                      _context18.next = 34;
+                      break;
+                    case 30:
+                      _context18.prev = 30;
+                      _context18.t0 = _context18["catch"](2);
                       sentryScope.captureException('Error in "debugIdUploadPlugin" writeBundle hook');
-                      handleRecoverableError(_context17.t0, false);
-                    case 31:
-                      _context17.prev = 31;
+                      handleRecoverableError(_context18.t0, false);
+                    case 34:
+                      _context18.prev = 34;
                       if (folderToCleanUp && !((_process$env2 = process.env) !== null && _process$env2 !== void 0 && _process$env2["SENTRY_TEST_OVERRIDE_TEMP_DIR"])) {
                         void startSpan({
                           name: "cleanup",
                           scope: sentryScope
-                        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
-                          return _regeneratorRuntime().wrap(function _callee16$(_context16) {
-                            while (1) switch (_context16.prev = _context16.next) {
+                        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
+                          return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+                            while (1) switch (_context17.prev = _context17.next) {
                               case 0:
                                 if (!folderToCleanUp) {
-                                  _context16.next = 3;
+                                  _context17.next = 3;
                                   break;
                                 }
-                                _context16.next = 3;
+                                _context17.next = 3;
                                 return fs__namespace.promises.rm(folderToCleanUp, {
                                   recursive: true,
                                   force: true
                                 });
                               case 3:
                               case "end":
-                                return _context16.stop();
+                                return _context17.stop();
                             }
-                          }, _callee16);
+                          }, _callee17);
                         })));
                       }
                       freeUploadDependencyOnBuildArtifacts();
-                      _context17.next = 36;
+                      _context18.next = 39;
                       return safeFlushTelemetry(sentryClient);
-                    case 36:
-                      return _context17.finish(31);
-                    case 37:
+                    case 39:
+                      return _context18.finish(34);
+                    case 40:
                     case "end":
-                      return _context17.stop();
+                      return _context18.stop();
                   }
-                }, _callee17, null, [[1, 27, 31, 37]]);
+                }, _callee18, null, [[2, 30, 34, 40]]);
               })));
-            case 4:
+            case 8:
             case "end":
-              return _context18.stop();
+              return _context19.stop();
           }
-        }, _callee18);
+        }, _callee19);
       }))();
     },
     /**
      * Will delete artifacts based on the passed `sourcemaps.filesToDeleteAfterUpload` option.
      */
     deleteArtifacts: function deleteArtifacts() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
-        var _options$sourcemaps5, filesToDelete, filePathsToDelete;
-        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
-          while (1) switch (_context19.prev = _context19.next) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20() {
+        var _options$sourcemaps9, filesToDelete, filePathsToDelete;
+        return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
             case 0:
-              _context19.prev = 0;
-              _context19.next = 3;
-              return (_options$sourcemaps5 = options.sourcemaps) === null || _options$sourcemaps5 === void 0 ? void 0 : _options$sourcemaps5.filesToDeleteAfterUpload;
+              _context20.prev = 0;
+              _context20.next = 3;
+              return (_options$sourcemaps9 = options.sourcemaps) === null || _options$sourcemaps9 === void 0 ? void 0 : _options$sourcemaps9.filesToDeleteAfterUpload;
             case 3:
-              filesToDelete = _context19.sent;
+              filesToDelete = _context20.sent;
               if (!(filesToDelete !== undefined)) {
-                _context19.next = 14;
+                _context20.next = 14;
                 break;
               }
-              _context19.next = 7;
+              _context20.next = 7;
               return glob.glob(filesToDelete, {
                 absolute: true,
                 nodir: true
               });
             case 7:
-              filePathsToDelete = _context19.sent;
+              filePathsToDelete = _context20.sent;
               logger.debug("Waiting for dependencies on generated files to be freed before deleting...");
-              _context19.next = 11;
+              _context20.next = 11;
               return waitUntilBuildArtifactDependenciesAreFreed();
             case 11:
               filePathsToDelete.forEach(function (filePathToDelete) {
                 logger.debug("Deleting asset after upload: ".concat(filePathToDelete));
               });
-              _context19.next = 14;
+              _context20.next = 14;
               return Promise.all(filePathsToDelete.map(function (filePathToDelete) {
                 return fs__namespace.promises.rm(filePathToDelete, {
                   force: true
@@ -9634,31 +9688,31 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                 });
               }));
             case 14:
-              _context19.next = 22;
+              _context20.next = 22;
               break;
             case 16:
-              _context19.prev = 16;
-              _context19.t0 = _context19["catch"](0);
+              _context20.prev = 16;
+              _context20.t0 = _context20["catch"](0);
               sentryScope.captureException('Error in "sentry-file-deletion-plugin" buildEnd hook');
-              _context19.next = 21;
+              _context20.next = 21;
               return safeFlushTelemetry(sentryClient);
             case 21:
               // We throw by default if we get here b/c not being able to delete
               // source maps could leak them to production
-              handleRecoverableError(_context19.t0, true);
+              handleRecoverableError(_context20.t0, true);
             case 22:
             case "end":
-              return _context19.stop();
+              return _context20.stop();
           }
-        }, _callee19, null, [[0, 16]]);
+        }, _callee20, null, [[0, 16]]);
       }))();
     },
     createDependencyOnBuildArtifacts: createDependencyOnBuildArtifacts
   };
 }
 function canUploadSourceMaps(options, logger, isDevMode) {
-  var _options$sourcemaps6;
-  if ((_options$sourcemaps6 = options.sourcemaps) !== null && _options$sourcemaps6 !== void 0 && _options$sourcemaps6.disable) {
+  var _options$sourcemaps10;
+  if ((_options$sourcemaps10 = options.sourcemaps) !== null && _options$sourcemaps10 !== void 0 && _options$sourcemaps10.disable) {
     logger.debug("Source map upload was disabled. Will not upload sourcemaps using debug ID process.");
     return false;
   }