@sentry/bundler-plugin-core 0.4.0 → 0.5.1

package/dist/esm/index.mjs

@@ -2,8 +2,17 @@ import { createUnplugin } from 'unplugin';
 import MagicString from 'magic-string';
 import SentryCli from '@sentry/cli';
 import { NodeClient, defaultStackParser, makeNodeTransport, Hub, makeMain } from '@sentry/node';
+import findUp from 'find-up';
+import * as path from 'path';
+import path__default from 'path';
+import * as fs from 'fs';
+import fs__default from 'fs';
+import os from 'os';
+import crypto from 'crypto';
 import '@sentry/tracing';
-import path from 'path';
+import * as util from 'util';
+import util__default from 'util';
+import { glob } from 'glob';
 
 function _regeneratorRuntime() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
@@ -759,13 +768,156 @@ timestampSource.nowSeconds.bind(timestampSource);
  * @param maybeArray Input to turn into an array, if necessary
  * @returns The input, if already an array, or an array with the input as the only element, if not
  */
+
 function arrayify(maybeArray) {
   return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 }
 
+/**
+ * Get the closes package.json from a given starting point upwards.
+ * This handles a few edge cases:
+ * * Check if a given file package.json appears to be an actual NPM package.json file
+ * * Stop at the home dir, to avoid looking too deeply
+ */
+function getPackageJson() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      cwd = _ref.cwd,
+      stopAt = _ref.stopAt;
+
+  return lookupPackageJson(cwd !== null && cwd !== void 0 ? cwd : process.cwd(), path__default.normalize(stopAt !== null && stopAt !== void 0 ? stopAt : os.homedir()));
+}
+function parseMajorVersion(version) {
+  // if it has a `v` prefix, remove it
+  if (version.startsWith("v")) {
+    version = version.slice(1);
+  } // First, try simple lookup of exact, ~ and ^ versions
+
+
+  var regex = /^[\^~]?(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var match = version.match(regex);
+
+  if (match) {
+    return parseInt(match[1], 10);
+  } // Try to parse e.g. 1.x
+
+
+  var coerced = parseInt(version, 10);
+
+  if (!Number.isNaN(coerced)) {
+    return coerced;
+  } // Match <= and >= ranges.
+
+
+  var gteLteRegex = /^[<>]=\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var gteLteMatch = version.match(gteLteRegex);
+
+  if (gteLteMatch) {
+    return parseInt(gteLteMatch[1], 10);
+  } // match < ranges
+
+
+  var ltRegex = /^<\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var ltMatch = version.match(ltRegex);
+
+  if (ltMatch) {
+    // Two scenarios:
+    // a) < 2.0.0 --> return 1
+    // b) < 2.1.0 --> return 2
+    var major = parseInt(ltMatch[1], 10);
+
+    if ( // minor version > 0
+    typeof ltMatch[2] === "string" && parseInt(ltMatch[2].slice(1), 10) > 0 || // patch version > 0
+    typeof ltMatch[3] === "string" && parseInt(ltMatch[3].slice(1), 10) > 0) {
+      return major;
+    }
+
+    return major - 1;
+  } // match > ranges
+
+
+  var gtRegex = /^>\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var gtMatch = version.match(gtRegex);
+
+  if (gtMatch) {
+    // We always return the version here, even though it _may_ be incorrect
+    // E.g. if given > 2.0.0, it should be 2 if there exists any 2.x.x version, else 3
+    // Since there is no way for us to know this, we're going to assume any kind of patch/feature release probably exists
+    return parseInt(gtMatch[1], 10);
+  }
+
+  return undefined;
+} // This is an explicit list of packages where we want to include the (major) version number.
+
+var PACKAGES_TO_INCLUDE_VERSION = ["react", "@angular/core", "vue", "ember-source", "svelte", "@sveltejs/kit", "webpack", "vite", "gatsby", "next", "remix", "rollup", "esbuild"];
+function getDependencies(packageJson) {
+  var _packageJson$devDepen, _packageJson$dependen;
+
+  var dependencies = Object.assign({}, (_packageJson$devDepen = packageJson["devDependencies"]) !== null && _packageJson$devDepen !== void 0 ? _packageJson$devDepen : {}, (_packageJson$dependen = packageJson["dependencies"]) !== null && _packageJson$dependen !== void 0 ? _packageJson$dependen : {});
+  var deps = Object.keys(dependencies).sort();
+  var depsVersions = deps.reduce(function (depsVersions, depName) {
+    if (PACKAGES_TO_INCLUDE_VERSION.includes(depName)) {
+      var version = dependencies[depName];
+      var majorVersion = parseMajorVersion(version);
+
+      if (majorVersion) {
+        depsVersions[depName] = majorVersion;
+      }
+    }
+
+    return depsVersions;
+  }, {});
+  return {
+    deps: deps,
+    depsVersions: depsVersions
+  };
+}
+
+function lookupPackageJson(cwd, stopAt) {
+  var jsonPath = findUp.sync(function (dirName) {
+    // Stop if we reach this dir
+    if (path__default.normalize(dirName) === stopAt) {
+      return findUp.stop;
+    }
+
+    return findUp.sync.exists(dirName + "/package.json") ? "package.json" : undefined;
+  }, {
+    cwd: cwd
+  });
+
+  if (!jsonPath) {
+    return undefined;
+  }
+
+  try {
+    var jsonStr = fs__default.readFileSync(jsonPath, "utf8");
+    var json = JSON.parse(jsonStr); // Ensure it is an actual package.json
+    // This is very much not bulletproof, but should be good enough
+
+    if ("name" in json || "private" in json) {
+      return json;
+    }
+  } catch (error) {// Ignore and walk up
+  } // Continue up the tree, if we find a fitting package.json
+
+
+  var newCwd = path__default.dirname(path__default.resolve(jsonPath + "/.."));
+  return lookupPackageJson(newCwd, stopAt);
+}
+/**
+ * Deterministically hashes a string and turns the hash into a uuid.
+ */
+
+
+function stringToUUID(str) {
+  var md5sum = crypto.createHash("md5");
+  md5sum.update(str);
+  var md5Hash = md5sum.digest("hex");
+  return (md5Hash.substring(0, 8) + "-" + md5Hash.substring(8, 12) + "-4" + md5Hash.substring(13, 16) + "-" + md5Hash.substring(16, 20) + "-" + md5Hash.substring(20)).toLowerCase();
+}
+
 var SENTRY_SAAS_URL = "https://sentry.io";
 function normalizeUserOptions(userOptions) {
-  var _userOptions$org, _userOptions$project, _ref, _userOptions$release, _ref2, _userOptions$url, _userOptions$finalize, _userOptions$cleanArt, _userOptions$dryRun, _userOptions$debug, _userOptions$silent, _userOptions$telemetr, _userOptions$injectRe;
+  var _userOptions$org, _userOptions$project, _ref, _userOptions$release, _ref2, _userOptions$url, _userOptions$finalize, _userOptions$cleanArt, _userOptions$dryRun, _userOptions$debug, _userOptions$silent, _userOptions$telemetr, _userOptions$injectRe, _userOptions$injectRe2, _userOptions$uploadSo, _userOptions$_experim;
 
   var options = {
     // include is the only strictly required option
@@ -794,6 +946,9 @@ function normalizeUserOptions(userOptions) {
     silent: (_userOptions$silent = userOptions.silent) !== null && _userOptions$silent !== void 0 ? _userOptions$silent : false,
     telemetry: (_userOptions$telemetr = userOptions.telemetry) !== null && _userOptions$telemetr !== void 0 ? _userOptions$telemetr : true,
     injectReleasesMap: (_userOptions$injectRe = userOptions.injectReleasesMap) !== null && _userOptions$injectRe !== void 0 ? _userOptions$injectRe : false,
+    injectRelease: (_userOptions$injectRe2 = userOptions.injectRelease) !== null && _userOptions$injectRe2 !== void 0 ? _userOptions$injectRe2 : true,
+    uploadSourceMaps: (_userOptions$uploadSo = userOptions.uploadSourceMaps) !== null && _userOptions$uploadSo !== void 0 ? _userOptions$uploadSo : true,
+    _experiments: (_userOptions$_experim = userOptions._experiments) !== null && _userOptions$_experim !== void 0 ? _userOptions$_experim : {},
     // These options and can also be set via env variables or the config file.
     // If they're set in the options, we simply pass them to the CLI constructor.
     // Sentry CLI will internally query env variables and read its config file if
@@ -933,7 +1088,7 @@ function makeSentryClient(dsn, allowedToSendTelemetryPromise, userProject) {
     // a dashboard.
     // Yes, this is slightly abusing the purpose of this field.
     dist: userProject,
-    release: "0.4.0",
+    release: "0.5.1",
     integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: defaultStackParser,
@@ -1035,7 +1190,8 @@ function addPluginOptionInformationToHub(options, hub, bundler) {
       dryRun = options.dryRun,
       errorHandler = options.errorHandler,
       deploy = options.deploy,
-      include = options.include;
+      include = options.include,
+      _experiments = options._experiments;
   hub.setTag("include", include.length > 1 ? "multiple-entries" : "single-entry"); // Optional release pipeline steps
 
   if (cleanArtifacts) {
@@ -1067,6 +1223,10 @@ function addPluginOptionInformationToHub(options, hub, bundler) {
     hub.setTag("error-handler", "custom");
   }
 
+  if (_experiments.debugIdUpload) {
+    hub.setTag("debug-id-upload", true);
+  }
+
   hub.setTag("node", process.version);
   hub.setTags({
     organization: org,
@@ -1278,74 +1438,141 @@ function _uploadSourceMaps() {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
+            if (options.uploadSourceMaps) {
+              _context3.next = 3;
+              break;
+            }
+
+            logger.debug("Skipping source maps upload.");
+            return _context3.abrupt("return");
+
+          case 3:
             span = addSpanToTransaction(ctx, "function.plugin.upload_sourcemaps");
             ctx.logger.info("Uploading Sourcemaps."); // Since our internal include entries contain all top-level sourcemaps options,
             // we only need to pass the include option here.
 
-            _context3.prev = 2;
-            _context3.next = 5;
+            _context3.prev = 5;
+            _context3.next = 8;
             return ctx.cli.releases.uploadSourceMaps(releaseName, {
               include: options.include,
               dist: options.dist
             });
 
-          case 5:
-            _context3.next = 11;
+          case 8:
+            _context3.next = 14;
             break;
 
-          case 7:
-            _context3.prev = 7;
-            _context3.t0 = _context3["catch"](2);
+          case 10:
+            _context3.prev = 10;
+            _context3.t0 = _context3["catch"](5);
             ctx.hub.captureException(new Error("CLI Error: Uploading source maps failed"));
             throw _context3.t0;
 
-          case 11:
-            _context3.prev = 11;
+          case 14:
+            _context3.prev = 14;
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context3.finish(11);
+            return _context3.finish(14);
 
-          case 14:
+          case 17:
             ctx.hub.addBreadcrumb({
               level: "info",
               message: "Successfully uploaded source maps."
             });
             ctx.logger.info("Successfully uploaded source maps.");
 
-          case 16:
+          case 19:
           case "end":
             return _context3.stop();
         }
       }
-    }, _callee3, null, [[2, 7, 11, 14]]);
+    }, _callee3, null, [[5, 10, 14, 17]]);
   }));
   return _uploadSourceMaps.apply(this, arguments);
 }
 
-function setCommits(_x10, _x11, _x12) {
+function uploadDebugIdSourcemaps(_x10, _x11, _x12, _x13) {
+  return _uploadDebugIdSourcemaps.apply(this, arguments);
+}
+
+function _uploadDebugIdSourcemaps() {
+  _uploadDebugIdSourcemaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx, folderPathToUpload, releaseName) {
+    var span;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.upload_debug_id_sourcemaps");
+            ctx.logger.info("Uploading debug ID Sourcemaps."); // Since our internal include entries contain all top-level sourcemaps options,
+            // we only need to pass the include option here.
+
+            _context4.prev = 2;
+            _context4.next = 5;
+            return ctx.cli.releases.uploadSourceMaps(releaseName, {
+              include: [{
+                paths: [folderPathToUpload],
+                rewrite: false,
+                dist: options.dist
+              }],
+              useArtifactBundle: true
+            });
+
+          case 5:
+            _context4.next = 11;
+            break;
+
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](2);
+            ctx.hub.captureException(new Error("CLI Error: Uploading debug ID source maps failed"));
+            throw _context4.t0;
+
+          case 11:
+            _context4.prev = 11;
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context4.finish(11);
+
+          case 14:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully uploaded debug ID source maps."
+            });
+            ctx.logger.info("Successfully uploaded debug ID source maps.");
+
+          case 16:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[2, 7, 11, 14]]);
+  }));
+  return _uploadDebugIdSourcemaps.apply(this, arguments);
+}
+
+function setCommits(_x14, _x15, _x16) {
   return _setCommits.apply(this, arguments);
 }
 
 function _setCommits() {
-  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx, releaseName) {
+  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx, releaseName) {
     var span, _options$setCommits, auto, repo, commit, previousCommit, ignoreMissing, ignoreEmpty;
 
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context4.prev = _context4.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
             if (options.setCommits) {
-              _context4.next = 3;
+              _context5.next = 3;
               break;
             }
 
             logger.debug("Skipping setting commits to release.");
-            return _context4.abrupt("return");
+            return _context5.abrupt("return");
 
           case 3:
             span = addSpanToTransaction(ctx, "function.plugin.set_commits");
             _options$setCommits = options.setCommits, auto = _options$setCommits.auto, repo = _options$setCommits.repo, commit = _options$setCommits.commit, previousCommit = _options$setCommits.previousCommit, ignoreMissing = _options$setCommits.ignoreMissing, ignoreEmpty = _options$setCommits.ignoreEmpty;
-            _context4.prev = 5;
-            _context4.next = 8;
+            _context5.prev = 5;
+            _context5.next = 8;
             return ctx.cli.releases.setCommits(releaseName, {
               commit: commit,
               previousCommit: previousCommit,
@@ -1356,46 +1583,46 @@ function _setCommits() {
             });
 
           case 8:
-            _context4.next = 14;
+            _context5.next = 14;
             break;
 
           case 10:
-            _context4.prev = 10;
-            _context4.t0 = _context4["catch"](5);
+            _context5.prev = 10;
+            _context5.t0 = _context5["catch"](5);
             ctx.hub.captureException(new Error("CLI Error: Setting commits failed"));
-            throw _context4.t0;
+            throw _context5.t0;
 
           case 14:
-            _context4.prev = 14;
+            _context5.prev = 14;
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context4.finish(14);
+            return _context5.finish(14);
 
           case 17:
             ctx.logger.info("Successfully set commits.");
 
           case 18:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
       }
-    }, _callee4, null, [[5, 10, 14, 17]]);
+    }, _callee5, null, [[5, 10, 14, 17]]);
   }));
   return _setCommits.apply(this, arguments);
 }
 
-function finalizeRelease(_x13, _x14, _x15) {
+function finalizeRelease(_x17, _x18, _x19) {
   return _finalizeRelease.apply(this, arguments);
 }
 
 function _finalizeRelease() {
-  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx, releaseName) {
+  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx, releaseName) {
     var span;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
       while (1) {
-        switch (_context5.prev = _context5.next) {
+        switch (_context6.prev = _context6.next) {
           case 0:
             if (options.finalize) {
-              _context5.next = 4;
+              _context6.next = 4;
               break;
             }
 
@@ -1404,28 +1631,28 @@ function _finalizeRelease() {
               message: "Skipping release finalization."
             });
             logger.debug("Skipping release finalization.");
-            return _context5.abrupt("return");
+            return _context6.abrupt("return");
 
           case 4:
             span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
-            _context5.prev = 5;
-            _context5.next = 8;
+            _context6.prev = 5;
+            _context6.next = 8;
             return ctx.cli.releases.finalize(releaseName);
 
           case 8:
-            _context5.next = 14;
+            _context6.next = 14;
             break;
 
           case 10:
-            _context5.prev = 10;
-            _context5.t0 = _context5["catch"](5);
+            _context6.prev = 10;
+            _context6.t0 = _context6["catch"](5);
             ctx.hub.captureException(new Error("CLI Error: Finalizing release failed"));
-            throw _context5.t0;
+            throw _context6.t0;
 
           case 14:
-            _context5.prev = 14;
+            _context6.prev = 14;
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context5.finish(14);
+            return _context6.finish(14);
 
           case 17:
             ctx.hub.addBreadcrumb({
@@ -1436,28 +1663,28 @@ function _finalizeRelease() {
 
           case 19:
           case "end":
-            return _context5.stop();
+            return _context6.stop();
         }
       }
-    }, _callee5, null, [[5, 10, 14, 17]]);
+    }, _callee6, null, [[5, 10, 14, 17]]);
   }));
   return _finalizeRelease.apply(this, arguments);
 }
 
-function addDeploy(_x16, _x17, _x18) {
+function addDeploy(_x20, _x21, _x22) {
   return _addDeploy.apply(this, arguments);
 }
 
 function _addDeploy() {
-  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx, releaseName) {
+  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(options, ctx, releaseName) {
     var span, _options$deploy, env, started, finished, time, name, url;
 
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
       while (1) {
-        switch (_context6.prev = _context6.next) {
+        switch (_context7.prev = _context7.next) {
           case 0:
             if (options.deploy) {
-              _context6.next = 4;
+              _context7.next = 4;
               break;
             }
 
@@ -1466,13 +1693,13 @@ function _addDeploy() {
               message: "Skipping adding deploy info to release."
             });
             logger.debug("Skipping adding deploy info to release.");
-            return _context6.abrupt("return");
+            return _context7.abrupt("return");
 
           case 4:
             span = addSpanToTransaction(ctx, "function.plugin.deploy");
             _options$deploy = options.deploy, env = _options$deploy.env, started = _options$deploy.started, finished = _options$deploy.finished, time = _options$deploy.time, name = _options$deploy.name, url = _options$deploy.url;
-            _context6.prev = 6;
-            _context6.next = 9;
+            _context7.prev = 6;
+            _context7.next = 9;
             return ctx.cli.releases.newDeploy(releaseName, {
               env: env,
               started: started,
@@ -1483,19 +1710,19 @@ function _addDeploy() {
             });
 
           case 9:
-            _context6.next = 15;
+            _context7.next = 15;
             break;
 
           case 11:
-            _context6.prev = 11;
-            _context6.t0 = _context6["catch"](6);
+            _context7.prev = 11;
+            _context7.t0 = _context7["catch"](6);
             ctx.hub.captureException(new Error("CLI Error: Adding deploy info failed"));
-            throw _context6.t0;
+            throw _context7.t0;
 
           case 15:
-            _context6.prev = 15;
+            _context7.prev = 15;
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context6.finish(15);
+            return _context7.finish(15);
 
           case 18:
             ctx.hub.addBreadcrumb({
@@ -1506,10 +1733,10 @@ function _addDeploy() {
 
           case 20:
           case "end":
-            return _context6.stop();
+            return _context7.stop();
         }
       }
-    }, _callee6, null, [[6, 11, 15, 18]]);
+    }, _callee7, null, [[6, 11, 15, 18]]);
   }));
   return _addDeploy.apply(this, arguments);
 }
@@ -1640,18 +1867,261 @@ function getDryRunCLI(cli, logger) {
   };
 }
 
+var DEBUG_ID_INJECTOR_SNIPPET = ';!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="__SENTRY_DEBUG_ID__",e._sentryDebugIdIdentifier="sentry-dbid-__SENTRY_DEBUG_ID__")}catch(e){}}();';
+function injectDebugIdSnippetIntoChunk(code) {
+  var _code$match;
+
+  var debugId = stringToUUID(code); // generate a deterministic debug ID
+
+  var ms = new MagicString(code);
+  var codeToInject = DEBUG_ID_INJECTOR_SNIPPET.replace(/__SENTRY_DEBUG_ID__/g, debugId); // We need to be careful not to inject the snippet before any `"use strict";`s.
+  // As an additional complication `"use strict";`s may come after any number of comments.
+
+  var commentUseStrictRegex = /^(?:\s*|\/\*(.|\r|\n)*?\*\/|\/\/.*?[\n\r])*(?:"use strict";|'use strict';)?/;
+
+  if ((_code$match = code.match(commentUseStrictRegex)) !== null && _code$match !== void 0 && _code$match[0]) {
+    // Add injected code after any comments or "use strict" at the beginning of the bundle.
+    ms.replace(commentUseStrictRegex, function (match) {
+      return "".concat(match).concat(codeToInject);
+    });
+  } else {
+    // ms.replace() doesn't work when there is an empty string match (which happens if
+    // there is neither, a comment, nor a "use strict" at the top of the chunk) so we
+    // need this special case here.
+    ms.prepend(codeToInject);
+  }
+
+  return {
+    code: ms.toString(),
+    map: ms.generateMap()
+  };
+}
+function prepareBundleForDebugIdUpload(_x, _x2, _x3, _x4) {
+  return _prepareBundleForDebugIdUpload.apply(this, arguments);
+}
+/**
+ * Looks for a particular string pattern (`sdbid-[debug ID]`) in the bundle
+ * source and extracts the bundle's debug ID from it.
+ *
+ * The string pattern is injected via the debug ID injection snipped.
+ */
+
+function _prepareBundleForDebugIdUpload() {
+  _prepareBundleForDebugIdUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(bundleFilePath, uploadFolder, uniqueUploadName, logger) {
+    var bundleContent, debugId, writeSourceFilePromise, writeSourceMapFilePromise;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return util.promisify(fs.readFile)(bundleFilePath, "utf8");
+
+          case 3:
+            bundleContent = _context2.sent;
+            _context2.next = 10;
+            break;
+
+          case 6:
+            _context2.prev = 6;
+            _context2.t0 = _context2["catch"](0);
+            logger.warn("Could not read bundle to determine debug ID and source map: ".concat(bundleFilePath));
+            return _context2.abrupt("return");
+
+          case 10:
+            debugId = determineDebugIdFromBundleSource(bundleContent);
+
+            if (!(debugId === undefined)) {
+              _context2.next = 14;
+              break;
+            }
+
+            logger.warn("Could not determine debug ID from bundle: ".concat(bundleFilePath));
+            return _context2.abrupt("return");
+
+          case 14:
+            bundleContent += "\n//# debugId=".concat(debugId);
+            writeSourceFilePromise = util.promisify(fs.writeFile)(path.join(uploadFolder, "".concat(uniqueUploadName, ".js")), bundleContent, "utf-8");
+            writeSourceMapFilePromise = determineSourceMapPathFromBundle(bundleFilePath, bundleContent, logger).then( /*#__PURE__*/function () {
+              var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(sourceMapPath) {
+                return _regeneratorRuntime().wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        if (!sourceMapPath) {
+                          _context.next = 4;
+                          break;
+                        }
+
+                        _context.next = 3;
+                        return prepareSourceMapForDebugIdUpload(sourceMapPath, path.join(uploadFolder, "".concat(uniqueUploadName, ".js.map")), debugId, logger);
+
+                      case 3:
+                        return _context.abrupt("return", _context.sent);
+
+                      case 4:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x12) {
+                return _ref.apply(this, arguments);
+              };
+            }());
+            return _context2.abrupt("return", Promise.all([writeSourceFilePromise, writeSourceMapFilePromise]));
+
+          case 18:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[0, 6]]);
+  }));
+  return _prepareBundleForDebugIdUpload.apply(this, arguments);
+}
+
+function determineDebugIdFromBundleSource(code) {
+  var match = code.match(/sentry-dbid-([0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12})/);
+
+  if (match) {
+    return match[1];
+  } else {
+    return undefined;
+  }
+}
+/**
+ * Applies a set of heuristics to find the source map for a particular bundle.
+ *
+ * @returns the path to the bundle's source map or `undefined` if none could be found.
+ */
+
+
+function determineSourceMapPathFromBundle(_x5, _x6, _x7) {
+  return _determineSourceMapPathFromBundle.apply(this, arguments);
+}
+/**
+ * Reads a source map, injects debug ID fields, and writes the source map to the target path.
+ */
+
+
+function _determineSourceMapPathFromBundle() {
+  _determineSourceMapPathFromBundle = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(bundlePath, bundleSource, logger) {
+    var sourceMappingUrlMatch, sourceMappingUrl, adjacentSourceMapFilePath;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            // 1. try to find source map at `sourceMappingURL` location
+            sourceMappingUrlMatch = bundleSource.match(/^\/\/# sourceMappingURL=(.*)$/);
+
+            if (!sourceMappingUrlMatch) {
+              _context3.next = 8;
+              break;
+            }
+
+            sourceMappingUrl = path.normalize(sourceMappingUrlMatch[1]);
+
+            if (!path.isAbsolute(sourceMappingUrl)) {
+              _context3.next = 7;
+              break;
+            }
+
+            return _context3.abrupt("return", sourceMappingUrl);
+
+          case 7:
+            return _context3.abrupt("return", path.join(path.dirname(bundlePath), sourceMappingUrl));
+
+          case 8:
+            _context3.prev = 8;
+            adjacentSourceMapFilePath = bundlePath + ".map";
+            _context3.next = 12;
+            return util.promisify(fs.access)(adjacentSourceMapFilePath);
+
+          case 12:
+            return _context3.abrupt("return", adjacentSourceMapFilePath);
+
+          case 15:
+            _context3.prev = 15;
+            _context3.t0 = _context3["catch"](8);
+
+          case 17:
+            logger.warn("Could not determine source map path for bundle: ".concat(bundlePath));
+            return _context3.abrupt("return", undefined);
+
+          case 19:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[8, 15]]);
+  }));
+  return _determineSourceMapPathFromBundle.apply(this, arguments);
+}
+
+function prepareSourceMapForDebugIdUpload(_x8, _x9, _x10, _x11) {
+  return _prepareSourceMapForDebugIdUpload.apply(this, arguments);
+}
+
+function _prepareSourceMapForDebugIdUpload() {
+  _prepareSourceMapForDebugIdUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(sourceMapPath, targetPath, debugId, logger) {
+    var sourceMapFileContent, map;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.prev = 0;
+            _context4.next = 3;
+            return util.promisify(fs.readFile)(sourceMapPath, {
+              encoding: "utf8"
+            });
+
+          case 3:
+            sourceMapFileContent = _context4.sent;
+            map = JSON.parse(sourceMapFileContent); // For now we write both fields until we know what will become the standard - if ever.
+
+            map["debug_id"] = debugId;
+            map["debugId"] = debugId;
+            _context4.next = 9;
+            return util.promisify(fs.writeFile)(targetPath, JSON.stringify(map), {
+              encoding: "utf8"
+            });
+
+          case 9:
+            _context4.next = 14;
+            break;
+
+          case 11:
+            _context4.prev = 11;
+            _context4.t0 = _context4["catch"](0);
+            logger.warn("Failed to prepare source map for debug ID upload: ".concat(sourceMapPath));
+
+          case 14:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[0, 11]]);
+  }));
+  return _prepareSourceMapForDebugIdUpload.apply(this, arguments);
+}
+
 var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".mjs"];
+
+var releaseInjectionFilePath = require.resolve("@sentry/bundler-plugin-core/sentry-release-injection-file");
 /**
  * The sentry bundler plugin concerns itself with two things:
  * - Release injection
  * - Sourcemaps upload
  *
  * Release injection:
- * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into
- * each JavaScript/TypeScript entrypoint. On a technical level this is done by identifying
- * entrypoints in the `resolveId` hook and prepending user code in the `transform` hook.
- * If a user wants to inject the release into a particular set of modules instead,
- * they can use the `releaseInjectionTargets` option.
+ * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into each JavaScript/TypeScript module
+ * that is part of the bundle. On a technical level this is done by appending an import (`import "sentry-release-injector;"`)
+ * to all entrypoint files of the user code (see `transformInclude` and `transform` hooks). This import is then resolved
+ * by the sentry plugin to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
+ * If a user wants to inject the release into a particular set of modules they can use the `releaseInjectionTargets` option.
  *
  * Source maps upload:
  *
@@ -1669,6 +2139,7 @@ var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".mjs"]
  * This release creation pipeline relies on Sentry CLI to execute the different steps.
  */
 
+
 var unplugin = createUnplugin(function (options, unpluginMetaContext) {
   var internalOptions = normalizeUserOptions(options);
   var allowedToSendTelemetryPromise = shouldSendTelemetry(internalOptions);
@@ -1704,7 +2175,6 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
   });
   var transaction;
   var releaseInjectionSpan;
-  var absolueEntrypointPaths = new Set();
   return {
     name: "sentry-plugin",
     enforce: "pre",
@@ -1741,10 +2211,14 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
                   });
                 }
 
-                _context.next = 7;
+                if (process.cwd().match(/\\node_modules\\|\/node_modules\//)) {
+                  logger.warn("Running Sentry plugin from within a `node_modules` folder. Some features may not work.");
+                }
+
+                _context.next = 8;
                 return releaseNamePromise;
 
-              case 7:
+              case 8:
                 releaseName = _context.sent;
 
                 // At this point, we either have determined a release or we have to bail
@@ -1763,7 +2237,7 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
                   cli: cli
                 }, "function.plugin.inject_release", "Release injection");
 
-              case 11:
+              case 12:
               case "end":
                 return _context.stop();
             }
@@ -1790,11 +2264,6 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
         importer: importer,
         isEntry: isEntry
       });
-
-      if (isEntry) {
-        absolueEntrypointPaths.add(path.resolve(path.normalize(id)));
-      }
-
       return undefined;
     },
 
@@ -1809,10 +2278,19 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
     transformInclude: function transformInclude(id) {
       logger.debug('Called "transformInclude":', {
         id: id
-      }); // We normalize the id because vite always passes `id` as a unix style path which causes problems when a user passes
+      });
+
+      if (id.match(/\\node_modules\\|\/node_modules\//)) {
+        return false; // never transform 3rd party modules
+      } // We normalize the id because vite always passes `id` as a unix style path which causes problems when a user passes
       // a windows style path to `releaseInjectionTargets`
 
-      var normalizedId = path.normalize(id);
+
+      var normalizedId = path__default.normalize(id);
+
+      if (id.includes("sentry-release-injection-file")) {
+        return true;
+      }
 
       if (internalOptions.releaseInjectionTargets) {
         // If there's an `releaseInjectionTargets` option transform (ie. inject the release varible) when the file path matches the option.
@@ -1824,18 +2302,16 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
           if (entry instanceof RegExp) {
             return entry.test(normalizedId);
           } else {
-            var normalizedEntry = path.normalize(entry);
+            var normalizedEntry = path__default.normalize(entry);
             return normalizedId === normalizedEntry;
           }
         });
-      } else if (absolueEntrypointPaths.has(normalizedId)) {
+      } else {
         var pathIsOrdinary = !normalizedId.includes("?") && !normalizedId.includes("#");
         var pathHasAllowedFileEnding = ALLOWED_TRANSFORMATION_FILE_ENDINGS.some(function (allowedFileEnding) {
           return normalizedId.endsWith(allowedFileEnding);
         });
         return pathIsOrdinary && pathHasAllowedFileEnding;
-      } else {
-        return false;
       }
     },
 
@@ -1856,43 +2332,70 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
               case 0:
                 logger.debug('Called "transform":', {
                   id: id
-                }); // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
+                });
+
+                if (internalOptions.injectRelease) {
+                  _context2.next = 3;
+                  break;
+                }
+
+                return _context2.abrupt("return");
 
+              case 3:
+                // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
                 ms = new MagicString(code);
+
+                if (!code.includes("_sentry_release_injection_file")) {
+                  _context2.next = 19;
+                  break;
+                }
+
                 _context2.t0 = ms;
                 _context2.t1 = generateGlobalInjectorCode;
-                _context2.next = 6;
+                _context2.next = 9;
                 return releaseNamePromise;
 
-              case 6:
+              case 9:
                 _context2.t2 = _context2.sent;
                 _context2.t3 = internalOptions.injectReleasesMap;
-                _context2.t4 = internalOptions.org;
-                _context2.t5 = internalOptions.project;
-                _context2.t6 = {
+                _context2.t4 = internalOptions._experiments.injectBuildInformation || false;
+                _context2.t5 = internalOptions.org;
+                _context2.t6 = internalOptions.project;
+                _context2.t7 = {
                   release: _context2.t2,
                   injectReleasesMap: _context2.t3,
-                  org: _context2.t4,
-                  project: _context2.t5
+                  injectBuildInformation: _context2.t4,
+                  org: _context2.t5,
+                  project: _context2.t6
                 };
-                _context2.t7 = (0, _context2.t1)(_context2.t6);
+                _context2.t8 = (0, _context2.t1)(_context2.t7);
 
-                _context2.t0.prepend.call(_context2.t0, _context2.t7);
+                _context2.t0.append.call(_context2.t0, _context2.t8);
 
+                _context2.next = 20;
+                break;
+
+              case 19:
+                // Appending instead of prepending has less probability of mucking with user's source maps.
+                // Luckily import statements get hoisted to the top anyways.
+                // The import needs to be an absolute path because Rollup doesn't bundle stuff in `node_modules` by default when bundling CJS (unless the import path is absolute or the node-resolve-plugin is used).
+                ms.append(";\nimport \"".concat(releaseInjectionFilePath.replace(/\\/g, "\\\\"), "\";"));
+
+              case 20:
                 if (!(unpluginMetaContext.framework === "esbuild")) {
-                  _context2.next = 17;
+                  _context2.next = 24;
                   break;
                 }
 
                 return _context2.abrupt("return", ms.toString());
 
-              case 17:
+              case 24:
                 return _context2.abrupt("return", {
                   code: ms.toString(),
                   map: ms.generateMap()
                 });
 
-              case 18:
+              case 25:
               case "end":
                 return _context2.stop();
             }
@@ -1906,14 +2409,14 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
      * Sentry.io, uploading sourcemaps, associating commits and deploys and finalizing the release)
      */
     writeBundle: function writeBundle() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
         var _releaseInjectionSpan;
 
-        var releasePipelineSpan, ctx, releaseName, _transaction, _transaction2, _transaction3;
+        var releasePipelineSpan, ctx, releaseName, tmpUploadFolder, _transaction, debugIdChunkFilePaths, sourceFileUploadFolderPromise, _transaction2, _transaction3;
 
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) {
-            switch (_context3.prev = _context3.next) {
+            switch (_context4.prev = _context4.next) {
               case 0:
                 logger.debug('Called "writeBundle"');
                 (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
@@ -1933,75 +2436,172 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
                   logger: logger,
                   cli: cli
                 };
-                _context3.next = 7;
+                _context4.next = 7;
                 return releaseNamePromise;
 
               case 7:
-                releaseName = _context3.sent;
-                _context3.prev = 8;
-                _context3.next = 11;
+                releaseName = _context4.sent;
+                _context4.prev = 8;
+
+                if (!internalOptions._experiments.debugIdUpload) {
+                  _context4.next = 21;
+                  break;
+                }
+
+                _context4.next = 12;
+                return glob(internalOptions._experiments.debugIdUpload.include, {
+                  absolute: true,
+                  nodir: true,
+                  ignore: internalOptions._experiments.debugIdUpload.ignore
+                });
+
+              case 12:
+                debugIdChunkFilePaths = _context4.sent.filter(function (p) {
+                  return p.endsWith(".js") || p.endsWith(".mjs");
+                });
+                sourceFileUploadFolderPromise = util__default.promisify(fs__default.mkdtemp)(path__default.join(os.tmpdir(), "sentry-bundler-plugin-upload-"));
+                _context4.next = 16;
+                return Promise.all(debugIdChunkFilePaths.map( /*#__PURE__*/function () {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(chunkFilePath, chunkIndex) {
+                    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            _context3.t0 = prepareBundleForDebugIdUpload;
+                            _context3.t1 = chunkFilePath;
+                            _context3.next = 4;
+                            return sourceFileUploadFolderPromise;
+
+                          case 4:
+                            _context3.t2 = _context3.sent;
+                            _context3.t3 = String(chunkIndex);
+                            _context3.t4 = logger;
+                            _context3.next = 9;
+                            return (0, _context3.t0)(_context3.t1, _context3.t2, _context3.t3, _context3.t4);
+
+                          case 9:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+
+                  return function (_x, _x2) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }()));
+
+              case 16:
+                _context4.next = 18;
+                return sourceFileUploadFolderPromise;
+
+              case 18:
+                tmpUploadFolder = _context4.sent;
+                _context4.next = 21;
+                return uploadDebugIdSourcemaps(internalOptions, ctx, tmpUploadFolder, releaseName);
+
+              case 21:
+                _context4.next = 23;
                 return createNewRelease(internalOptions, ctx, releaseName);
 
-              case 11:
-                _context3.next = 13;
+              case 23:
+                _context4.next = 25;
                 return cleanArtifacts(internalOptions, ctx, releaseName);
 
-              case 13:
-                _context3.next = 15;
+              case 25:
+                _context4.next = 27;
                 return uploadSourceMaps(internalOptions, ctx, releaseName);
 
-              case 15:
-                _context3.next = 17;
+              case 27:
+                _context4.next = 29;
                 return setCommits(internalOptions, ctx, releaseName);
 
-              case 17:
-                _context3.next = 19;
+              case 29:
+                _context4.next = 31;
                 return finalizeRelease(internalOptions, ctx, releaseName);
 
-              case 19:
-                _context3.next = 21;
+              case 31:
+                _context4.next = 33;
                 return addDeploy(internalOptions, ctx, releaseName);
 
-              case 21:
+              case 33:
                 (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
-                _context3.next = 29;
+                _context4.next = 41;
                 break;
 
-              case 24:
-                _context3.prev = 24;
-                _context3.t0 = _context3["catch"](8);
+              case 36:
+                _context4.prev = 36;
+                _context4.t0 = _context4["catch"](8);
                 (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
                 sentryHub.addBreadcrumb({
                   level: "error",
                   message: "Error during writeBundle"
                 });
-                handleError(_context3.t0, logger, internalOptions.errorHandler);
+                handleError(_context4.t0, logger, internalOptions.errorHandler);
+
+              case 41:
+                _context4.prev = 41;
+
+                if (tmpUploadFolder) {
+                  fs__default.rm(tmpUploadFolder, {
+                    recursive: true,
+                    force: true
+                  }, function () {// We don't care if this errors
+                  });
+                }
 
-              case 29:
-                _context3.prev = 29;
                 releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
                 (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
-                _context3.next = 34;
+                _context4.next = 47;
                 return sentryClient.flush().then(null, function () {
                   logger.warn("Sending of telemetry failed");
                 });
 
-              case 34:
-                return _context3.finish(29);
+              case 47:
+                return _context4.finish(41);
 
-              case 35:
+              case 48:
                 sentryHub.addBreadcrumb({
                   category: "writeBundle:finish",
                   level: "info"
                 });
 
-              case 36:
+              case 49:
               case "end":
-                return _context3.stop();
+                return _context4.stop();
             }
           }
-        }, _callee3, null, [[8, 24, 29, 35]]);
+        }, _callee4, null, [[8, 36, 41, 48]]);
       }))();
+    },
+    rollup: {
+      renderChunk: function renderChunk(code, chunk) {
+        var _options$_experiments;
+
+        if ((_options$_experiments = options._experiments) !== null && _options$_experiments !== void 0 && _options$_experiments.debugIdUpload && [".js", ".mjs"].some(function (ending) {
+          return chunk.fileName.endsWith(ending);
+        }) // chunks could be any file (html, md, ...)
+        ) {
+          return injectDebugIdSnippetIntoChunk(code);
+        } else {
+          return null; // returning null means not modifying the chunk at all
+        }
+      }
+    },
+    vite: {
+      renderChunk: function renderChunk(code, chunk) {
+        var _options$_experiments2;
+
+        if ((_options$_experiments2 = options._experiments) !== null && _options$_experiments2 !== void 0 && _options$_experiments2.debugIdUpload && [".js", ".mjs"].some(function (ending) {
+          return chunk.fileName.endsWith(ending);
+        }) // chunks could be any file (html, md, ...)
+        ) {
+          return injectDebugIdSnippetIntoChunk(code);
+        } else {
+          return null; // returning null means not modifying the chunk at all
+        }
+      }
     }
   };
 });
@@ -2024,16 +2624,17 @@ function handleError(unknownError, logger, errorHandler) {
   }
 }
 /**
- * Generates code for the "sentry-release-injector" which is responsible for setting the global `SENTRY_RELEASE`
- * variable.
+ * Generates code for the global injector which is responsible for setting the global
+ * `SENTRY_RELEASE` & `SENTRY_BUILD_INFO` variables.
  */
 
 
-function generateGlobalInjectorCode(_ref2) {
-  var release = _ref2.release,
-      injectReleasesMap = _ref2.injectReleasesMap,
-      org = _ref2.org,
-      project = _ref2.project;
+function generateGlobalInjectorCode(_ref3) {
+  var release = _ref3.release,
+      injectReleasesMap = _ref3.injectReleasesMap,
+      injectBuildInformation = _ref3.injectBuildInformation,
+      org = _ref3.org,
+      project = _ref3.project;
   // The code below is mostly ternary operators because it saves bundle size.
   // The checks are to support as many environments as possible. (Node.js, Browser, webworkers, etc.)
   var code = "\n    var _global =\n      typeof window !== 'undefined' ?\n        window :\n        typeof global !== 'undefined' ?\n          global :\n          typeof self !== 'undefined' ?\n            self :\n            {};\n\n    _global.SENTRY_RELEASE={id:\"".concat(release, "\"};");
@@ -2043,9 +2644,39 @@ function generateGlobalInjectorCode(_ref2) {
     code += "\n      _global.SENTRY_RELEASES=_global.SENTRY_RELEASES || {};\n      _global.SENTRY_RELEASES[\"".concat(key, "\"]={id:\"").concat(release, "\"};");
   }
 
+  if (injectBuildInformation) {
+    var buildInfo = getBuildInformation();
+    code += "\n      _global.SENTRY_BUILD_INFO=".concat(JSON.stringify(buildInfo), ";");
+  }
+
   return code;
-} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}
+
+function getBuildInformation() {
+  var packageJson = getPackageJson();
+
+  var _ref4 = packageJson ? getDependencies(packageJson) : {
+    deps: [],
+    depsVersions: {}
+  },
+      deps = _ref4.deps,
+      depsVersions = _ref4.depsVersions;
+
+  return {
+    deps: deps,
+    depsVersions: depsVersions,
+    nodeVersion: parseMajorVersion(process.version)
+  };
+}
+/**
+ * Determines whether the Sentry CLI binary is in its expected location.
+ * This function is useful since `@sentry/cli` installs the binary via a post-install
+ * script and post-install scripts may not always run. E.g. with `npm i --ignore-scripts`.
+ */
 
+function sentryCliBinaryExists() {
+  return fs__default.existsSync(SentryCli.getPath());
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
 var sentryVitePlugin = unplugin.vite; // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
@@ -2055,5 +2686,5 @@ var sentryWebpackPlugin = unplugin.webpack; // eslint-disable-next-line @typescr
 
 var sentryEsbuildPlugin = unplugin.esbuild;
 
-export { sentryEsbuildPlugin, sentryRollupPlugin, sentryVitePlugin, sentryWebpackPlugin };
+export { getBuildInformation, sentryCliBinaryExists, sentryEsbuildPlugin, sentryRollupPlugin, sentryVitePlugin, sentryWebpackPlugin };
 //# sourceMappingURL=index.mjs.map